From 3189a4f08233fbf1727bf0cd383d48167f4df0d6 Mon Sep 17 00:00:00 2001
From: Ryan Karn <rkarn@amazon.com>
Date: Thu, 14 May 2026 14:02:08 -0700
Subject: [PATCH 1/4] fix: sandbox msging bugs (shared origin #29,
 isPermittedFrom #35)

Fixing issues for handling messages and errors when sandboxes use
the same origin.  Namely, this approach defines and passes an id
that is passed to the sandbox, and provides a hook that allows
sandboxes to use this for messaging.  This is to distinguish views
on the same origin that share the same runtime and globals.

This also addresses an issue there allowOrigin checks where checking
sender side allows rather than receiver side.

ref: https://github.com/callstackincubator/react-native-sandbox/issues/29
ref: https://github.com/callstackincubator/react-native-sandbox/issues/35
---
 apps/origin-pooling/App.tsx                   |    57 +-
 apps/origin-pooling/README.md                 |    78 +
 apps/origin-pooling/SandboxApp.tsx            |    39 +-
 apps/origin-pooling/SandboxAppConvention.tsx  |   162 +
 apps/origin-pooling/ios/Podfile.lock          |  2465 +
 .../LogBox/UI/LogBoxImages/alert-triangle.png |   Bin 0 -> 609 bytes
 .../LogBox/UI/LogBoxImages/chevron-left.png   |   Bin 0 -> 126 bytes
 .../LogBox/UI/LogBoxImages/chevron-right.png  |   Bin 0 -> 123 bytes
 .../LogBox/UI/LogBoxImages/close.png          |   Bin 0 -> 187 bytes
 .../LogBox/UI/LogBoxImages/loader.png         |   Bin 0 -> 282 bytes
 apps/origin-pooling/ios/sandbox.jsbundle      | 99314 ++++++++++++++++
 apps/origin-pooling/sandbox.js                |     5 +
 apps/p2p-counter/App.tsx                      |    14 +-
 ...stancePOC.xcscheme => P2PCounter.xcscheme} |    19 +-
 apps/p2p-counter/ios/Podfile.lock             |     4 +-
 .../rnsandbox/SandboxJSIInstaller.kt          |    46 +
 .../rnsandbox/SandboxReactNativeDelegate.kt   |   137 +-
 .../SandboxReactNativeViewManager.kt          |    26 +-
 .../src/main/jni/SandboxJSIInstaller.cpp      |   514 +-
 .../cxx/ISandboxDelegate.h                    |    13 +
 .../cxx/SandboxDelegateWrapper.h              |     5 +
 .../cxx/SandboxRegistry.cpp                   |    28 +-
 .../cxx/SandboxRegistry.h                     |    15 +
 .../ios/SandboxDelegateWrapper.mm             |    11 +
 .../ios/SandboxReactNativeDelegate.h          |    36 +
 .../ios/SandboxReactNativeDelegate.mm         |   292 +-
 .../SandboxReactNativeViewComponentView.mm    |    44 +
 packages/react-native-sandbox/src/index.tsx   |     1 +
 .../src/useSurfaceMessaging.ts                |    75 +
 .../tests/MockSandboxDelegate.h               |     8 +
 .../tests/SandboxRegistryTest.cpp             |    20 +-
 31 files changed, 103240 insertions(+), 188 deletions(-)
 create mode 100644 apps/origin-pooling/SandboxAppConvention.tsx
 create mode 100644 apps/origin-pooling/ios/Podfile.lock
 create mode 100644 apps/origin-pooling/ios/assets/__node_modules/react-native/Libraries/LogBox/UI/LogBoxImages/alert-triangle.png
 create mode 100644 apps/origin-pooling/ios/assets/__node_modules/react-native/Libraries/LogBox/UI/LogBoxImages/chevron-left.png
 create mode 100644 apps/origin-pooling/ios/assets/__node_modules/react-native/Libraries/LogBox/UI/LogBoxImages/chevron-right.png
 create mode 100644 apps/origin-pooling/ios/assets/__node_modules/react-native/Libraries/LogBox/UI/LogBoxImages/close.png
 create mode 100644 apps/origin-pooling/ios/assets/__node_modules/react-native/Libraries/LogBox/UI/LogBoxImages/loader.png
 create mode 100644 apps/origin-pooling/ios/sandbox.jsbundle
 rename apps/p2p-counter/ios/P2PCounter.xcodeproj/xcshareddata/xcschemes/{MultiInstancePOC.xcscheme => P2PCounter.xcscheme} (79%)
 create mode 100644 packages/react-native-sandbox/src/useSurfaceMessaging.ts

diff --git a/apps/origin-pooling/App.tsx b/apps/origin-pooling/App.tsx
index e3ff4b0..dfcf3a5 100644
--- a/apps/origin-pooling/App.tsx
+++ b/apps/origin-pooling/App.tsx
@@ -2,8 +2,13 @@
  * Origin Pooling Demo
  *
  * Dynamically add/remove sandboxes under two shared origins (alpha, beta)
- * plus an isolated (no-origin) option. Same-origin sandboxes share a
- * ReactHost / Hermes VM; removing the last one triggers the idle TTL.
+ * plus isolated sandboxes (each gets a unique origin and its own VM).
+ * Same-origin sandboxes share a ReactHost / Hermes VM; removing the last
+ * one triggers the idle TTL.
+ *
+ * Access control demo: alpha and beta only accept messages from "isolated-1".
+ * Other isolated sandboxes (isolated-2, isolated-3, …) will get
+ * AccessDeniedError when trying to ping alpha or beta.
  *
  * Messaging is handled inside the sandbox widget via globalThis.postMessage.
  * The host only logs messages received via onMessage.
@@ -25,13 +30,21 @@ type SandboxEntry = {key: string; label: string; origin: string}
 type LogEntry = {source: string; text: string; ts: number}
 
 let nextId = 0
+let nextIsolatedId = 0
 
 const ORIGIN_ALPHA = 'alpha'
 const ORIGIN_BETA = 'beta'
+const ISOLATED_PREFIX = 'isolated-'
 const COLOR_ALPHA = '#8232ff'
 const COLOR_BETA = '#e67e22'
 const COLOR_ISOLATED = '#6c757d'
 
+/**
+ * Only "isolated-1" is permitted to send messages to alpha/beta.
+ * All other isolated origins will be denied.
+ */
+const PERMITTED_ISOLATED = `${ISOLATED_PREFIX}1`
+
 /** Alpha uses a function-based TTL (4 seconds) */
 const ALPHA_TTL = () => 4000
 /** Beta and isolated use a static TTL (2 seconds) */
@@ -48,7 +61,14 @@ export default function App() {
 
   const addSandbox = useCallback((origin: string) => {
     const id = String(++nextId)
-    setSandboxes(prev => [...prev, {key: id, label: `#${id}`, origin}])
+    const actualOrigin =
+      origin === ISOLATED_PREFIX
+        ? `${ISOLATED_PREFIX}${++nextIsolatedId}`
+        : origin
+    setSandboxes(prev => [
+      ...prev,
+      {key: id, label: `#${id}`, origin: actualOrigin},
+    ])
   }, [])
 
   const removeSandbox = useCallback((key: string) => {
@@ -59,14 +79,15 @@ export default function App() {
 
   const alphas = sandboxes.filter(s => s.origin === ORIGIN_ALPHA)
   const betas = sandboxes.filter(s => s.origin === ORIGIN_BETA)
-  const isolated = sandboxes.filter(s => s.origin === '')
+  const isolated = sandboxes.filter(s => s.origin.startsWith(ISOLATED_PREFIX))
 
   return (
     <SafeAreaView style={styles.safe}>
       <Text style={styles.heading}>Origin Pooling Demo</Text>
       <Text style={styles.subtitle}>
-        Same-origin sandboxes share a VM. Alpha: function-based TTL (4s). Beta:
-        static TTL (2s).
+        Same-origin sandboxes share a VM. Isolated sandboxes each get a unique
+        origin (own VM). Only isolated-1 can message alpha/beta — others get
+        AccessDeniedError.
       </Text>
 
       <View style={styles.controls}>
@@ -83,7 +104,7 @@ export default function App() {
         <Button
           title="+ Isolated"
           color={COLOR_ISOLATED}
-          onPress={() => addSandbox('')}
+          onPress={() => addSandbox(ISOLATED_PREFIX)}
         />
         <Button title="Clear Log" onPress={clearLog} />
       </View>
@@ -101,6 +122,8 @@ export default function App() {
             key={sb.key}
             entry={sb}
             color={COLOR_ALPHA}
+            componentName="SandboxAppConvention"
+            allowedOrigins={[ORIGIN_ALPHA, ORIGIN_BETA, PERMITTED_ISOLATED]}
             idleTTL={ALPHA_TTL}
             onRemove={() => removeSandbox(sb.key)}
             onMessage={data =>
@@ -129,6 +152,8 @@ export default function App() {
             key={sb.key}
             entry={sb}
             color={COLOR_BETA}
+            componentName="SandboxApp"
+            allowedOrigins={[ORIGIN_ALPHA, ORIGIN_BETA, PERMITTED_ISOLATED]}
             idleTTL={DEFAULT_TTL}
             onRemove={() => removeSandbox(sb.key)}
             onMessage={data => addLog(`beta ${sb.label}`, JSON.stringify(data))}
@@ -142,9 +167,9 @@ export default function App() {
         )}
       </ScrollView>
 
-      {/* Isolated sandboxes */}
+      {/* Isolated sandboxes — each gets a unique origin (own VM) */}
       <Text style={[styles.groupLabel, {color: COLOR_ISOLATED}]}>
-        no origin / isolated ({isolated.length})
+        isolated ({isolated.length}) — only isolated-1 can reach alpha/beta
       </Text>
       <ScrollView
         horizontal
@@ -155,6 +180,8 @@ export default function App() {
             key={sb.key}
             entry={sb}
             color={COLOR_ISOLATED}
+            componentName="SandboxApp"
+            allowedOrigins={[ORIGIN_ALPHA, ORIGIN_BETA]}
             idleTTL={DEFAULT_TTL}
             onRemove={() => removeSandbox(sb.key)}
             onMessage={data =>
@@ -192,6 +219,8 @@ export default function App() {
 type SandboxCardProps = {
   entry: SandboxEntry
   color: string
+  componentName: string
+  allowedOrigins: string[]
   idleTTL: number | (() => number)
   onRemove: () => void
   onMessage: (data: unknown) => void
@@ -201,6 +230,8 @@ type SandboxCardProps = {
 function SandboxCard({
   entry,
   color,
+  componentName,
+  allowedOrigins,
   idleTTL,
   onRemove,
   onMessage,
@@ -210,17 +241,17 @@ function SandboxCard({
     <View style={[styles.card, {borderColor: color}]}>
       <View style={[styles.cardHeader, {backgroundColor: color}]}>
         <Text style={styles.cardLabel}>
-          {entry.origin || 'isolated'} {entry.label}
+          {entry.origin} {entry.label}
         </Text>
         <Text style={styles.cardRemove} onPress={onRemove}>
           ✕
         </Text>
       </View>
       <SandboxReactNativeView
-        origin={entry.origin || undefined}
-        allowedOrigins={[ORIGIN_ALPHA, ORIGIN_BETA]}
+        origin={entry.origin}
+        allowedOrigins={allowedOrigins}
         idleTTL={idleTTL}
-        componentName="SandboxApp"
+        componentName={componentName}
         jsBundleSource="sandbox"
         onMessage={onMessage}
         onError={onError}
diff --git a/apps/origin-pooling/README.md b/apps/origin-pooling/README.md
index abfd41a..07e7acd 100644
--- a/apps/origin-pooling/README.md
+++ b/apps/origin-pooling/README.md
@@ -32,3 +32,81 @@ npx react-native run-ios
 # or
 npx react-native run-android
 ```
+
+## Multi-Origin Messaging Approaches
+
+This demo showcases two approaches for per-surface messaging in sandboxes
+that share a Hermes VM. Alpha sandboxes use the convention-based approach,
+while Beta sandboxes use the library-based approach.
+
+### Library approach (`useSurfaceMessaging`)
+
+Import the hook from `@callstack/react-native-sandbox`:
+
+```tsx
+import {useSurfaceMessaging} from '@callstack/react-native-sandbox'
+
+function MySandboxWidget({__sandboxDelegateId}: Props) {
+  const {postMessage, setOnMessage} = useSurfaceMessaging(__sandboxDelegateId)
+
+  // Send to host (per-surface routed)
+  postMessage({type: 'hello'})
+
+  // Send to another origin
+  postMessage({type: 'ping'}, 'beta')
+
+  // Receive messages (per-surface)
+  setOnMessage((msg) => console.log('received', msg))
+}
+```
+
+The hook handles delegate ID injection and per-surface listener registration
+internally. This is the recommended approach when you already depend on the
+sandbox library.
+
+See: `SandboxApp.tsx`
+
+### Convention approach (no library dependency)
+
+Use `globalThis.postMessage` and `globalThis.setOnMessage` directly,
+following the delegate ID conventions:
+
+```tsx
+declare const globalThis: {
+  postMessage: (msg: unknown, targetOrigin?: string) => void
+  setOnMessage: (cb: (msg: unknown) => void, delegateId?: string) => void
+}
+
+function MySandboxWidget({__sandboxDelegateId}: Props) {
+  // Send to host — spread delegateId into payload for per-surface routing
+  const send = (msg: Record<string, unknown>, targetOrigin?: string) => {
+    const payload = !targetOrigin && __sandboxDelegateId
+      ? {...msg, __sandboxDelegateId}
+      : msg
+    globalThis.postMessage(payload, targetOrigin)
+  }
+
+  // Send to another origin (no delegateId needed)
+  send({type: 'ping'}, 'alpha')
+
+  // Receive messages — pass delegateId as 2nd arg for per-surface listener
+  globalThis.setOnMessage((msg) => {
+    console.log('received', msg)
+  }, __sandboxDelegateId)
+}
+```
+
+This approach has zero library dependencies — useful when the sandbox JS
+bundle is built independently or when you want to minimize the sandbox's
+dependency footprint.
+
+See: `SandboxAppConvention.tsx`
+
+### Key differences
+
+| | Library | Convention |
+|---|---|---|
+| Import needed | `@callstack/react-native-sandbox` | None |
+| Delegate routing | Handled by hook | Manual (`__sandboxDelegateId` in payload) |
+| Cross-origin send | `postMessage(msg, origin)` | `globalThis.postMessage(msg, origin)` |
+| Per-surface listen | `setOnMessage(cb)` | `globalThis.setOnMessage(cb, delegateId)` |
diff --git a/apps/origin-pooling/SandboxApp.tsx b/apps/origin-pooling/SandboxApp.tsx
index ac5fd73..42ec2c0 100644
--- a/apps/origin-pooling/SandboxApp.tsx
+++ b/apps/origin-pooling/SandboxApp.tsx
@@ -1,10 +1,10 @@
 /**
- * SandboxApp — runs INSIDE each sandbox.
+ * SandboxApp — runs INSIDE each sandbox (library approach).
  *
- * Uses globalThis.postMessage directly (broadcast fallback, no per-surface routing).
- * Provides buttons to ping alpha/beta origins and send heartbeats to the host.
- * Displays an internal log of incoming and outgoing messages.
+ * Uses useSurfaceMessaging from @callstack/react-native-sandbox
+ * for per-surface routing.
  */
+import {useSurfaceMessaging} from '@callstack/react-native-sandbox'
 import React, {useEffect, useRef, useState} from 'react'
 import {
   ScrollView,
@@ -14,14 +14,14 @@ import {
   View,
 } from 'react-native'
 
-declare const globalThis: {
-  postMessage: (msg: unknown, targetOrigin?: string) => void
-  setOnMessage: (cb: (msg: unknown) => void) => void
-}
-
 type LogEntry = {dir: 'in' | 'out'; text: string; ts: number}
 
-export default function SandboxApp() {
+type Props = {
+  __sandboxDelegateId?: string
+}
+
+export default function SandboxApp({__sandboxDelegateId}: Props) {
+  const {postMessage, setOnMessage} = useSurfaceMessaging(__sandboxDelegateId)
   const [log, setLog] = useState<LogEntry[]>([])
   const instanceId = useRef(Math.random().toString(36).slice(2, 6)).current
   const seq = useRef(0)
@@ -30,33 +30,32 @@ export default function SandboxApp() {
   const addLog = (dir: 'in' | 'out', text: string) =>
     setLog(prev => [...prev.slice(-19), {dir, text, ts: Date.now()}])
 
-  // Signal first render to host
   useEffect(() => {
-    globalThis.postMessage({type: 'rendered', instanceId})
+    postMessage({type: 'rendered', instanceId})
     addLog('out', `rendered (${instanceId})`)
-  }, [instanceId])
+  }, [instanceId, postMessage])
 
-  // Listen for incoming messages (pings from other origins)
   useEffect(() => {
-    globalThis.setOnMessage((msg: unknown) => {
+    const unsubscribe = setOnMessage((msg: unknown) => {
       const data = msg as Record<string, unknown>
       addLog('in', `from ${data.instanceId ?? '?'}: ${data.type}`)
     })
-  }, [])
+    return unsubscribe
+  }, [setOnMessage])
 
   const sendHeartbeat = () => {
     const s = ++seq.current
-    globalThis.postMessage({type: 'heartbeat', instanceId, seq: s})
+    postMessage({type: 'heartbeat', instanceId, seq: s})
     addLog('out', `heartbeat seq=${s}`)
   }
 
   const pingAlpha = () => {
-    globalThis.postMessage({type: 'ping', instanceId}, 'alpha')
+    postMessage({type: 'ping', instanceId}, 'alpha')
     addLog('out', 'ping → alpha')
   }
 
   const pingBeta = () => {
-    globalThis.postMessage({type: 'ping', instanceId}, 'beta')
+    postMessage({type: 'ping', instanceId}, 'beta')
     addLog('out', 'ping → beta')
   }
 
@@ -70,6 +69,7 @@ export default function SandboxApp() {
   return (
     <View style={styles.root}>
       <Text style={styles.title}>ID: {instanceId}</Text>
+      <Text style={styles.approach}>Library (useSurfaceMessaging)</Text>
       <View style={styles.buttons}>
         <View style={styles.btnRow}>
           <TouchableOpacity style={styles.btnGreen} onPress={sendHeartbeat}>
@@ -106,6 +106,7 @@ export default function SandboxApp() {
 const styles = StyleSheet.create({
   root: {flex: 1, padding: 6, backgroundColor: '#1a1a2e'},
   title: {color: '#d3e945', fontWeight: '700', fontSize: 13},
+  approach: {color: '#888', fontSize: 9, marginBottom: 4},
   buttons: {gap: 4, marginBottom: 4},
   btnRow: {flexDirection: 'row', gap: 4},
   btnGreen: {
diff --git a/apps/origin-pooling/SandboxAppConvention.tsx b/apps/origin-pooling/SandboxAppConvention.tsx
new file mode 100644
index 0000000..ce3f6da
--- /dev/null
+++ b/apps/origin-pooling/SandboxAppConvention.tsx
@@ -0,0 +1,162 @@
+/**
+ * SandboxAppConvention — convention-based approach (no library dependency).
+ *
+ * Uses the __sandboxDelegateId prop directly with globalThis.postMessage
+ * and globalThis.setOnMessage for per-surface routing. No import from
+ * @callstack/react-native-sandbox needed.
+ */
+import React, {useEffect, useRef, useState} from 'react'
+import {
+  ScrollView,
+  StyleSheet,
+  Text,
+  TouchableOpacity,
+  View,
+} from 'react-native'
+
+declare const globalThis: {
+  postMessage: (msg: unknown, targetOrigin?: string) => void
+  setOnMessage: (cb: (msg: unknown) => void, delegateId?: string) => void
+}
+
+type LogEntry = {dir: 'in' | 'out'; text: string; ts: number}
+
+type Props = {
+  __sandboxDelegateId?: string
+}
+
+export default function SandboxAppConvention({__sandboxDelegateId}: Props) {
+  const [log, setLog] = useState<LogEntry[]>([])
+  const instanceId = useRef(Math.random().toString(36).slice(2, 6)).current
+  const seq = useRef(0)
+  const logRef = useRef<ScrollView>(null)
+
+  const addLog = (dir: 'in' | 'out', text: string) =>
+    setLog(prev => [...prev.slice(-19), {dir, text, ts: Date.now()}])
+
+  // Convention: spread __sandboxDelegateId into the payload for per-surface routing
+  const send = React.useCallback(
+    (msg: Record<string, unknown>, targetOrigin?: string) => {
+      const payload =
+        !targetOrigin && __sandboxDelegateId
+          ? {...msg, __sandboxDelegateId}
+          : msg
+      globalThis.postMessage(payload, targetOrigin)
+    },
+    [__sandboxDelegateId]
+  )
+
+  useEffect(() => {
+    send({type: 'rendered', instanceId})
+    addLog('out', `rendered (${instanceId})`)
+  }, [instanceId, send])
+
+  // Convention: pass delegateId as 2nd arg for per-surface listener
+  useEffect(() => {
+    globalThis.setOnMessage((msg: unknown) => {
+      const data = msg as Record<string, unknown>
+      addLog('in', `from ${data.instanceId ?? '?'}: ${data.type}`)
+    }, __sandboxDelegateId)
+    return () => {
+      globalThis.setOnMessage(() => {}, __sandboxDelegateId)
+    }
+  }, [__sandboxDelegateId])
+
+  const sendHeartbeat = () => {
+    const s = ++seq.current
+    send({type: 'heartbeat', instanceId, seq: s})
+    addLog('out', `heartbeat seq=${s}`)
+  }
+
+  const pingAlpha = () => {
+    send({type: 'ping', instanceId}, 'alpha')
+    addLog('out', 'ping → alpha')
+  }
+
+  const pingBeta = () => {
+    send({type: 'ping', instanceId}, 'beta')
+    addLog('out', 'ping → beta')
+  }
+
+  const triggerError = () => {
+    addLog('out', 'throwing uncaught error…')
+    setTimeout(() => {
+      throw new Error(`Boom from ${instanceId}`)
+    }, 0)
+  }
+
+  return (
+    <View style={styles.root}>
+      <Text style={styles.title}>ID: {instanceId}</Text>
+      <Text style={styles.approach}>Convention (no import)</Text>
+      <View style={styles.buttons}>
+        <View style={styles.btnRow}>
+          <TouchableOpacity style={styles.btnGreen} onPress={sendHeartbeat}>
+            <Text style={styles.btnText}>Heartbeat</Text>
+          </TouchableOpacity>
+          <TouchableOpacity style={styles.btnRed} onPress={triggerError}>
+            <Text style={styles.btnText}>Error</Text>
+          </TouchableOpacity>
+        </View>
+        <View style={styles.btnRow}>
+          <TouchableOpacity style={styles.btnPurple} onPress={pingAlpha}>
+            <Text style={styles.btnText}>Ping alpha</Text>
+          </TouchableOpacity>
+          <TouchableOpacity style={styles.btnOrange} onPress={pingBeta}>
+            <Text style={styles.btnText}>Ping beta</Text>
+          </TouchableOpacity>
+        </View>
+      </View>
+      <ScrollView
+        ref={logRef}
+        style={styles.log}
+        onContentSizeChange={() => logRef.current?.scrollToEnd()}>
+        {log.map((e, i) => (
+          <Text key={i} style={styles.logLine}>
+            {e.dir === 'in' ? '← ' : '→ '}
+            {e.text}
+          </Text>
+        ))}
+      </ScrollView>
+    </View>
+  )
+}
+
+const styles = StyleSheet.create({
+  root: {flex: 1, padding: 6, backgroundColor: '#1a1a2e'},
+  title: {color: '#d3e945', fontWeight: '700', fontSize: 13},
+  approach: {color: '#888', fontSize: 9, marginBottom: 4},
+  buttons: {gap: 4, marginBottom: 4},
+  btnRow: {flexDirection: 'row', gap: 4},
+  btnGreen: {
+    backgroundColor: '#16c79a',
+    borderRadius: 4,
+    paddingHorizontal: 6,
+    paddingVertical: 2,
+    flex: 1,
+  },
+  btnPurple: {
+    backgroundColor: '#8232ff',
+    borderRadius: 4,
+    paddingHorizontal: 6,
+    paddingVertical: 2,
+    flex: 1,
+  },
+  btnOrange: {
+    backgroundColor: '#e67e22',
+    borderRadius: 4,
+    paddingHorizontal: 6,
+    paddingVertical: 2,
+    flex: 1,
+  },
+  btnRed: {
+    backgroundColor: '#e94560',
+    borderRadius: 4,
+    paddingHorizontal: 6,
+    paddingVertical: 2,
+    flex: 1,
+  },
+  btnText: {color: '#fff', fontSize: 10, fontWeight: '600'},
+  log: {flex: 1},
+  logLine: {color: '#16c79a', fontSize: 10, fontFamily: 'monospace'},
+})
diff --git a/apps/origin-pooling/ios/Podfile.lock b/apps/origin-pooling/ios/Podfile.lock
new file mode 100644
index 0000000..5ea3af9
--- /dev/null
+++ b/apps/origin-pooling/ios/Podfile.lock
@@ -0,0 +1,2465 @@
+PODS:
+  - boost (1.84.0)
+  - DoubleConversion (1.1.6)
+  - fast_float (8.0.0)
+  - FBLazyVector (0.80.1)
+  - fmt (11.0.2)
+  - glog (0.3.5)
+  - hermes-engine (0.80.1):
+    - hermes-engine/Pre-built (= 0.80.1)
+  - hermes-engine/Pre-built (0.80.1)
+  - RCT-Folly (2024.11.18.00):
+    - boost
+    - DoubleConversion
+    - fast_float (= 8.0.0)
+    - fmt (= 11.0.2)
+    - glog
+    - RCT-Folly/Default (= 2024.11.18.00)
+  - RCT-Folly/Default (2024.11.18.00):
+    - boost
+    - DoubleConversion
+    - fast_float (= 8.0.0)
+    - fmt (= 11.0.2)
+    - glog
+  - RCT-Folly/Fabric (2024.11.18.00):
+    - boost
+    - DoubleConversion
+    - fast_float (= 8.0.0)
+    - fmt (= 11.0.2)
+    - glog
+  - RCTDeprecation (0.80.1)
+  - RCTRequired (0.80.1)
+  - RCTTypeSafety (0.80.1):
+    - FBLazyVector (= 0.80.1)
+    - RCTRequired (= 0.80.1)
+    - React-Core (= 0.80.1)
+  - React (0.80.1):
+    - React-Core (= 0.80.1)
+    - React-Core/DevSupport (= 0.80.1)
+    - React-Core/RCTWebSocket (= 0.80.1)
+    - React-RCTActionSheet (= 0.80.1)
+    - React-RCTAnimation (= 0.80.1)
+    - React-RCTBlob (= 0.80.1)
+    - React-RCTImage (= 0.80.1)
+    - React-RCTLinking (= 0.80.1)
+    - React-RCTNetwork (= 0.80.1)
+    - React-RCTSettings (= 0.80.1)
+    - React-RCTText (= 0.80.1)
+    - React-RCTVibration (= 0.80.1)
+  - React-callinvoker (0.80.1)
+  - React-Core (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTDeprecation
+    - React-Core/Default (= 0.80.1)
+    - React-cxxreact
+    - React-featureflags
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-jsinspector
+    - React-jsinspectorcdp
+    - React-jsitooling
+    - React-perflogger
+    - React-runtimescheduler
+    - React-utils
+    - SocketRocket
+    - Yoga
+  - React-Core/CoreModulesHeaders (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTDeprecation
+    - React-Core/Default
+    - React-cxxreact
+    - React-featureflags
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-jsinspector
+    - React-jsinspectorcdp
+    - React-jsitooling
+    - React-perflogger
+    - React-runtimescheduler
+    - React-utils
+    - SocketRocket
+    - Yoga
+  - React-Core/Default (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTDeprecation
+    - React-cxxreact
+    - React-featureflags
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-jsinspector
+    - React-jsinspectorcdp
+    - React-jsitooling
+    - React-perflogger
+    - React-runtimescheduler
+    - React-utils
+    - SocketRocket
+    - Yoga
+  - React-Core/DevSupport (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTDeprecation
+    - React-Core/Default (= 0.80.1)
+    - React-Core/RCTWebSocket (= 0.80.1)
+    - React-cxxreact
+    - React-featureflags
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-jsinspector
+    - React-jsinspectorcdp
+    - React-jsitooling
+    - React-perflogger
+    - React-runtimescheduler
+    - React-utils
+    - SocketRocket
+    - Yoga
+  - React-Core/RCTActionSheetHeaders (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTDeprecation
+    - React-Core/Default
+    - React-cxxreact
+    - React-featureflags
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-jsinspector
+    - React-jsinspectorcdp
+    - React-jsitooling
+    - React-perflogger
+    - React-runtimescheduler
+    - React-utils
+    - SocketRocket
+    - Yoga
+  - React-Core/RCTAnimationHeaders (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTDeprecation
+    - React-Core/Default
+    - React-cxxreact
+    - React-featureflags
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-jsinspector
+    - React-jsinspectorcdp
+    - React-jsitooling
+    - React-perflogger
+    - React-runtimescheduler
+    - React-utils
+    - SocketRocket
+    - Yoga
+  - React-Core/RCTBlobHeaders (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTDeprecation
+    - React-Core/Default
+    - React-cxxreact
+    - React-featureflags
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-jsinspector
+    - React-jsinspectorcdp
+    - React-jsitooling
+    - React-perflogger
+    - React-runtimescheduler
+    - React-utils
+    - SocketRocket
+    - Yoga
+  - React-Core/RCTImageHeaders (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTDeprecation
+    - React-Core/Default
+    - React-cxxreact
+    - React-featureflags
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-jsinspector
+    - React-jsinspectorcdp
+    - React-jsitooling
+    - React-perflogger
+    - React-runtimescheduler
+    - React-utils
+    - SocketRocket
+    - Yoga
+  - React-Core/RCTLinkingHeaders (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTDeprecation
+    - React-Core/Default
+    - React-cxxreact
+    - React-featureflags
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-jsinspector
+    - React-jsinspectorcdp
+    - React-jsitooling
+    - React-perflogger
+    - React-runtimescheduler
+    - React-utils
+    - SocketRocket
+    - Yoga
+  - React-Core/RCTNetworkHeaders (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTDeprecation
+    - React-Core/Default
+    - React-cxxreact
+    - React-featureflags
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-jsinspector
+    - React-jsinspectorcdp
+    - React-jsitooling
+    - React-perflogger
+    - React-runtimescheduler
+    - React-utils
+    - SocketRocket
+    - Yoga
+  - React-Core/RCTSettingsHeaders (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTDeprecation
+    - React-Core/Default
+    - React-cxxreact
+    - React-featureflags
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-jsinspector
+    - React-jsinspectorcdp
+    - React-jsitooling
+    - React-perflogger
+    - React-runtimescheduler
+    - React-utils
+    - SocketRocket
+    - Yoga
+  - React-Core/RCTTextHeaders (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTDeprecation
+    - React-Core/Default
+    - React-cxxreact
+    - React-featureflags
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-jsinspector
+    - React-jsinspectorcdp
+    - React-jsitooling
+    - React-perflogger
+    - React-runtimescheduler
+    - React-utils
+    - SocketRocket
+    - Yoga
+  - React-Core/RCTVibrationHeaders (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTDeprecation
+    - React-Core/Default
+    - React-cxxreact
+    - React-featureflags
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-jsinspector
+    - React-jsinspectorcdp
+    - React-jsitooling
+    - React-perflogger
+    - React-runtimescheduler
+    - React-utils
+    - SocketRocket
+    - Yoga
+  - React-Core/RCTWebSocket (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTDeprecation
+    - React-Core/Default (= 0.80.1)
+    - React-cxxreact
+    - React-featureflags
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-jsinspector
+    - React-jsinspectorcdp
+    - React-jsitooling
+    - React-perflogger
+    - React-runtimescheduler
+    - React-utils
+    - SocketRocket
+    - Yoga
+  - React-CoreModules (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTTypeSafety (= 0.80.1)
+    - React-Core/CoreModulesHeaders (= 0.80.1)
+    - React-jsi (= 0.80.1)
+    - React-jsinspector
+    - React-jsinspectorcdp
+    - React-jsinspectortracing
+    - React-NativeModulesApple
+    - React-RCTBlob
+    - React-RCTFBReactNativeSpec
+    - React-RCTImage (= 0.80.1)
+    - ReactCommon
+    - SocketRocket
+  - React-cxxreact (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-callinvoker (= 0.80.1)
+    - React-debug (= 0.80.1)
+    - React-jsi (= 0.80.1)
+    - React-jsinspector
+    - React-jsinspectorcdp
+    - React-jsinspectortracing
+    - React-logger (= 0.80.1)
+    - React-perflogger (= 0.80.1)
+    - React-runtimeexecutor (= 0.80.1)
+    - React-timing (= 0.80.1)
+    - SocketRocket
+  - React-debug (0.80.1)
+  - React-defaultsnativemodule (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-domnativemodule
+    - React-featureflagsnativemodule
+    - React-hermes
+    - React-idlecallbacksnativemodule
+    - React-jsi
+    - React-jsiexecutor
+    - React-microtasksnativemodule
+    - React-RCTFBReactNativeSpec
+    - SocketRocket
+  - React-domnativemodule (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-Fabric
+    - React-FabricComponents
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-RCTFBReactNativeSpec
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+    - Yoga
+  - React-Fabric (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-Fabric/animations (= 0.80.1)
+    - React-Fabric/attributedstring (= 0.80.1)
+    - React-Fabric/componentregistry (= 0.80.1)
+    - React-Fabric/componentregistrynative (= 0.80.1)
+    - React-Fabric/components (= 0.80.1)
+    - React-Fabric/consistency (= 0.80.1)
+    - React-Fabric/core (= 0.80.1)
+    - React-Fabric/dom (= 0.80.1)
+    - React-Fabric/imagemanager (= 0.80.1)
+    - React-Fabric/leakchecker (= 0.80.1)
+    - React-Fabric/mounting (= 0.80.1)
+    - React-Fabric/observers (= 0.80.1)
+    - React-Fabric/scheduler (= 0.80.1)
+    - React-Fabric/telemetry (= 0.80.1)
+    - React-Fabric/templateprocessor (= 0.80.1)
+    - React-Fabric/uimanager (= 0.80.1)
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-Fabric/animations (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-Fabric/attributedstring (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-Fabric/componentregistry (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-Fabric/componentregistrynative (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-Fabric/components (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-Fabric/components/legacyviewmanagerinterop (= 0.80.1)
+    - React-Fabric/components/root (= 0.80.1)
+    - React-Fabric/components/scrollview (= 0.80.1)
+    - React-Fabric/components/view (= 0.80.1)
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-Fabric/components/legacyviewmanagerinterop (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-Fabric/components/root (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-Fabric/components/scrollview (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-Fabric/components/view (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-renderercss
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+    - Yoga
+  - React-Fabric/consistency (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-Fabric/core (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-Fabric/dom (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-Fabric/imagemanager (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-Fabric/leakchecker (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-Fabric/mounting (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-Fabric/observers (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-Fabric/observers/events (= 0.80.1)
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-Fabric/observers/events (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-Fabric/scheduler (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-Fabric/observers/events
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-performancetimeline
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-Fabric/telemetry (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-Fabric/templateprocessor (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-Fabric/uimanager (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-Fabric/uimanager/consistency (= 0.80.1)
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererconsistency
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-Fabric/uimanager/consistency (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererconsistency
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-FabricComponents (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-Fabric
+    - React-FabricComponents/components (= 0.80.1)
+    - React-FabricComponents/textlayoutmanager (= 0.80.1)
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+    - Yoga
+  - React-FabricComponents/components (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-Fabric
+    - React-FabricComponents/components/inputaccessory (= 0.80.1)
+    - React-FabricComponents/components/iostextinput (= 0.80.1)
+    - React-FabricComponents/components/modal (= 0.80.1)
+    - React-FabricComponents/components/rncore (= 0.80.1)
+    - React-FabricComponents/components/safeareaview (= 0.80.1)
+    - React-FabricComponents/components/scrollview (= 0.80.1)
+    - React-FabricComponents/components/text (= 0.80.1)
+    - React-FabricComponents/components/textinput (= 0.80.1)
+    - React-FabricComponents/components/unimplementedview (= 0.80.1)
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+    - Yoga
+  - React-FabricComponents/components/inputaccessory (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-Fabric
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+    - Yoga
+  - React-FabricComponents/components/iostextinput (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-Fabric
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+    - Yoga
+  - React-FabricComponents/components/modal (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-Fabric
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+    - Yoga
+  - React-FabricComponents/components/rncore (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-Fabric
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+    - Yoga
+  - React-FabricComponents/components/safeareaview (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-Fabric
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+    - Yoga
+  - React-FabricComponents/components/scrollview (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-Fabric
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+    - Yoga
+  - React-FabricComponents/components/text (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-Fabric
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+    - Yoga
+  - React-FabricComponents/components/textinput (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-Fabric
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+    - Yoga
+  - React-FabricComponents/components/unimplementedview (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-Fabric
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+    - Yoga
+  - React-FabricComponents/textlayoutmanager (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-cxxreact
+    - React-debug
+    - React-Fabric
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-logger
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+    - Yoga
+  - React-FabricImage (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired (= 0.80.1)
+    - RCTTypeSafety (= 0.80.1)
+    - React-Fabric
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-ImageManager
+    - React-jsi
+    - React-jsiexecutor (= 0.80.1)
+    - React-logger
+    - React-rendererdebug
+    - React-utils
+    - ReactCommon
+    - SocketRocket
+    - Yoga
+  - React-featureflags (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - SocketRocket
+  - React-featureflagsnativemodule (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-featureflags
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-RCTFBReactNativeSpec
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-graphics (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-utils
+    - SocketRocket
+  - React-hermes (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-cxxreact (= 0.80.1)
+    - React-jsi
+    - React-jsiexecutor (= 0.80.1)
+    - React-jsinspector
+    - React-jsinspectorcdp
+    - React-jsinspectortracing
+    - React-perflogger (= 0.80.1)
+    - React-runtimeexecutor
+    - SocketRocket
+  - React-idlecallbacksnativemodule (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-RCTFBReactNativeSpec
+    - React-runtimescheduler
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-ImageManager (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-Core/Default
+    - React-debug
+    - React-Fabric
+    - React-graphics
+    - React-rendererdebug
+    - React-utils
+    - SocketRocket
+  - React-jserrorhandler (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-cxxreact
+    - React-debug
+    - React-featureflags
+    - React-jsi
+    - ReactCommon/turbomodule/bridging
+    - SocketRocket
+  - React-jsi (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - SocketRocket
+  - React-jsiexecutor (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-cxxreact (= 0.80.1)
+    - React-jsi (= 0.80.1)
+    - React-jsinspector
+    - React-jsinspectorcdp
+    - React-jsinspectortracing
+    - React-perflogger (= 0.80.1)
+    - SocketRocket
+  - React-jsinspector (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-featureflags
+    - React-jsi
+    - React-jsinspectorcdp
+    - React-jsinspectornetwork
+    - React-jsinspectortracing
+    - React-perflogger (= 0.80.1)
+    - React-runtimeexecutor (= 0.80.1)
+    - SocketRocket
+  - React-jsinspectorcdp (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - SocketRocket
+  - React-jsinspectornetwork (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-jsinspectorcdp
+    - SocketRocket
+  - React-jsinspectortracing (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-oscompat
+    - SocketRocket
+  - React-jsitooling (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-cxxreact (= 0.80.1)
+    - React-jsi (= 0.80.1)
+    - React-jsinspector
+    - React-jsinspectorcdp
+    - React-jsinspectortracing
+    - SocketRocket
+  - React-jsitracing (0.80.1):
+    - React-jsi
+  - React-logger (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - SocketRocket
+  - React-Mapbuffer (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-debug
+    - SocketRocket
+  - React-microtasksnativemodule (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-RCTFBReactNativeSpec
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-NativeModulesApple (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-callinvoker
+    - React-Core
+    - React-cxxreact
+    - React-featureflags
+    - React-hermes
+    - React-jsi
+    - React-jsinspector
+    - React-jsinspectorcdp
+    - React-runtimeexecutor
+    - ReactCommon/turbomodule/bridging
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - React-oscompat (0.80.1)
+  - React-perflogger (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - SocketRocket
+  - React-performancetimeline (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-featureflags
+    - React-jsinspectortracing
+    - React-perflogger
+    - React-timing
+    - SocketRocket
+  - React-RCTActionSheet (0.80.1):
+    - React-Core/RCTActionSheetHeaders (= 0.80.1)
+  - React-RCTAnimation (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTTypeSafety
+    - React-Core/RCTAnimationHeaders
+    - React-featureflags
+    - React-jsi
+    - React-NativeModulesApple
+    - React-RCTFBReactNativeSpec
+    - ReactCommon
+    - SocketRocket
+  - React-RCTAppDelegate (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-CoreModules
+    - React-debug
+    - React-defaultsnativemodule
+    - React-Fabric
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsitooling
+    - React-NativeModulesApple
+    - React-RCTFabric
+    - React-RCTFBReactNativeSpec
+    - React-RCTImage
+    - React-RCTNetwork
+    - React-RCTRuntime
+    - React-rendererdebug
+    - React-RuntimeApple
+    - React-RuntimeCore
+    - React-runtimescheduler
+    - React-utils
+    - ReactCommon
+    - SocketRocket
+  - React-RCTBlob (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-Core/RCTBlobHeaders
+    - React-Core/RCTWebSocket
+    - React-jsi
+    - React-jsinspector
+    - React-jsinspectorcdp
+    - React-NativeModulesApple
+    - React-RCTFBReactNativeSpec
+    - React-RCTNetwork
+    - ReactCommon
+    - SocketRocket
+  - React-RCTFabric (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-Core
+    - React-debug
+    - React-Fabric
+    - React-FabricComponents
+    - React-FabricImage
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-ImageManager
+    - React-jsi
+    - React-jsinspector
+    - React-jsinspectorcdp
+    - React-jsinspectornetwork
+    - React-jsinspectortracing
+    - React-performancetimeline
+    - React-RCTAnimation
+    - React-RCTImage
+    - React-RCTText
+    - React-rendererconsistency
+    - React-renderercss
+    - React-rendererdebug
+    - React-runtimescheduler
+    - React-utils
+    - SocketRocket
+    - Yoga
+  - React-RCTFBReactNativeSpec (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-NativeModulesApple
+    - ReactCommon
+    - SocketRocket
+  - React-RCTImage (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTTypeSafety
+    - React-Core/RCTImageHeaders
+    - React-jsi
+    - React-NativeModulesApple
+    - React-RCTFBReactNativeSpec
+    - React-RCTNetwork
+    - ReactCommon
+    - SocketRocket
+  - React-RCTLinking (0.80.1):
+    - React-Core/RCTLinkingHeaders (= 0.80.1)
+    - React-jsi (= 0.80.1)
+    - React-NativeModulesApple
+    - React-RCTFBReactNativeSpec
+    - ReactCommon
+    - ReactCommon/turbomodule/core (= 0.80.1)
+  - React-RCTNetwork (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTTypeSafety
+    - React-Core/RCTNetworkHeaders
+    - React-featureflags
+    - React-jsi
+    - React-jsinspectorcdp
+    - React-jsinspectornetwork
+    - React-NativeModulesApple
+    - React-RCTFBReactNativeSpec
+    - ReactCommon
+    - SocketRocket
+  - React-RCTRuntime (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-Core
+    - React-hermes
+    - React-jsi
+    - React-jsinspector
+    - React-jsinspectorcdp
+    - React-jsinspectortracing
+    - React-jsitooling
+    - React-RuntimeApple
+    - React-RuntimeCore
+    - React-RuntimeHermes
+    - SocketRocket
+  - React-RCTSettings (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTTypeSafety
+    - React-Core/RCTSettingsHeaders
+    - React-jsi
+    - React-NativeModulesApple
+    - React-RCTFBReactNativeSpec
+    - ReactCommon
+    - SocketRocket
+  - React-RCTText (0.80.1):
+    - React-Core/RCTTextHeaders (= 0.80.1)
+    - Yoga
+  - React-RCTVibration (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-Core/RCTVibrationHeaders
+    - React-jsi
+    - React-NativeModulesApple
+    - React-RCTFBReactNativeSpec
+    - ReactCommon
+    - SocketRocket
+  - React-rendererconsistency (0.80.1)
+  - React-renderercss (0.80.1):
+    - React-debug
+    - React-utils
+  - React-rendererdebug (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-debug
+    - SocketRocket
+  - React-rncore (0.80.1)
+  - React-RuntimeApple (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-callinvoker
+    - React-Core/Default
+    - React-CoreModules
+    - React-cxxreact
+    - React-featureflags
+    - React-jserrorhandler
+    - React-jsi
+    - React-jsiexecutor
+    - React-jsinspector
+    - React-jsitooling
+    - React-Mapbuffer
+    - React-NativeModulesApple
+    - React-RCTFabric
+    - React-RCTFBReactNativeSpec
+    - React-RuntimeCore
+    - React-runtimeexecutor
+    - React-RuntimeHermes
+    - React-runtimescheduler
+    - React-utils
+    - SocketRocket
+  - React-RuntimeCore (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-cxxreact
+    - React-Fabric
+    - React-featureflags
+    - React-hermes
+    - React-jserrorhandler
+    - React-jsi
+    - React-jsiexecutor
+    - React-jsinspector
+    - React-jsitooling
+    - React-performancetimeline
+    - React-runtimeexecutor
+    - React-runtimescheduler
+    - React-utils
+    - SocketRocket
+  - React-runtimeexecutor (0.80.1):
+    - React-jsi (= 0.80.1)
+  - React-RuntimeHermes (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-featureflags
+    - React-hermes
+    - React-jsi
+    - React-jsinspector
+    - React-jsinspectorcdp
+    - React-jsinspectortracing
+    - React-jsitooling
+    - React-jsitracing
+    - React-RuntimeCore
+    - React-utils
+    - SocketRocket
+  - React-runtimescheduler (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-callinvoker
+    - React-cxxreact
+    - React-debug
+    - React-featureflags
+    - React-hermes
+    - React-jsi
+    - React-jsinspectortracing
+    - React-performancetimeline
+    - React-rendererconsistency
+    - React-rendererdebug
+    - React-runtimeexecutor
+    - React-timing
+    - React-utils
+    - SocketRocket
+  - React-Sandbox (0.6.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-debug
+    - React-Fabric
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-ImageManager
+    - React-jsi
+    - React-NativeModulesApple
+    - React-RCTFabric
+    - React-renderercss
+    - React-rendererdebug
+    - React-utils
+    - ReactCodegen
+    - ReactCommon/turbomodule/bridging
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+    - Yoga
+  - React-timing (0.80.1)
+  - React-utils (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-debug
+    - React-hermes
+    - React-jsi (= 0.80.1)
+    - SocketRocket
+  - ReactAppDependencyProvider (0.80.1):
+    - ReactCodegen
+  - ReactCodegen (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
+    - React-Core
+    - React-debug
+    - React-Fabric
+    - React-FabricImage
+    - React-featureflags
+    - React-graphics
+    - React-hermes
+    - React-jsi
+    - React-jsiexecutor
+    - React-NativeModulesApple
+    - React-RCTAppDelegate
+    - React-rendererdebug
+    - React-utils
+    - ReactCommon/turbomodule/bridging
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+  - ReactCommon (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - ReactCommon/turbomodule (= 0.80.1)
+    - SocketRocket
+  - ReactCommon/turbomodule (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-callinvoker (= 0.80.1)
+    - React-cxxreact (= 0.80.1)
+    - React-jsi (= 0.80.1)
+    - React-logger (= 0.80.1)
+    - React-perflogger (= 0.80.1)
+    - ReactCommon/turbomodule/bridging (= 0.80.1)
+    - ReactCommon/turbomodule/core (= 0.80.1)
+    - SocketRocket
+  - ReactCommon/turbomodule/bridging (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-callinvoker (= 0.80.1)
+    - React-cxxreact (= 0.80.1)
+    - React-jsi (= 0.80.1)
+    - React-logger (= 0.80.1)
+    - React-perflogger (= 0.80.1)
+    - SocketRocket
+  - ReactCommon/turbomodule/core (0.80.1):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - React-callinvoker (= 0.80.1)
+    - React-cxxreact (= 0.80.1)
+    - React-debug (= 0.80.1)
+    - React-featureflags (= 0.80.1)
+    - React-jsi (= 0.80.1)
+    - React-logger (= 0.80.1)
+    - React-perflogger (= 0.80.1)
+    - React-utils (= 0.80.1)
+    - SocketRocket
+  - SocketRocket (0.7.1)
+  - Yoga (0.0.0)
+
+DEPENDENCIES:
+  - boost (from `../../../node_modules/react-native/third-party-podspecs/boost.podspec`)
+  - DoubleConversion (from `../../../node_modules/react-native/third-party-podspecs/DoubleConversion.podspec`)
+  - fast_float (from `../../../node_modules/react-native/third-party-podspecs/fast_float.podspec`)
+  - FBLazyVector (from `../../../node_modules/react-native/Libraries/FBLazyVector`)
+  - fmt (from `../../../node_modules/react-native/third-party-podspecs/fmt.podspec`)
+  - glog (from `../../../node_modules/react-native/third-party-podspecs/glog.podspec`)
+  - hermes-engine (from `../../../node_modules/react-native/sdks/hermes-engine/hermes-engine.podspec`)
+  - RCT-Folly (from `../../../node_modules/react-native/third-party-podspecs/RCT-Folly.podspec`)
+  - RCTDeprecation (from `../../../node_modules/react-native/ReactApple/Libraries/RCTFoundation/RCTDeprecation`)
+  - RCTRequired (from `../../../node_modules/react-native/Libraries/Required`)
+  - RCTTypeSafety (from `../../../node_modules/react-native/Libraries/TypeSafety`)
+  - React (from `../../../node_modules/react-native/`)
+  - React-callinvoker (from `../../../node_modules/react-native/ReactCommon/callinvoker`)
+  - React-Core (from `../../../node_modules/react-native/`)
+  - React-Core/RCTWebSocket (from `../../../node_modules/react-native/`)
+  - React-CoreModules (from `../../../node_modules/react-native/React/CoreModules`)
+  - React-cxxreact (from `../../../node_modules/react-native/ReactCommon/cxxreact`)
+  - React-debug (from `../../../node_modules/react-native/ReactCommon/react/debug`)
+  - React-defaultsnativemodule (from `../../../node_modules/react-native/ReactCommon/react/nativemodule/defaults`)
+  - React-domnativemodule (from `../../../node_modules/react-native/ReactCommon/react/nativemodule/dom`)
+  - React-Fabric (from `../../../node_modules/react-native/ReactCommon`)
+  - React-FabricComponents (from `../../../node_modules/react-native/ReactCommon`)
+  - React-FabricImage (from `../../../node_modules/react-native/ReactCommon`)
+  - React-featureflags (from `../../../node_modules/react-native/ReactCommon/react/featureflags`)
+  - React-featureflagsnativemodule (from `../../../node_modules/react-native/ReactCommon/react/nativemodule/featureflags`)
+  - React-graphics (from `../../../node_modules/react-native/ReactCommon/react/renderer/graphics`)
+  - React-hermes (from `../../../node_modules/react-native/ReactCommon/hermes`)
+  - React-idlecallbacksnativemodule (from `../../../node_modules/react-native/ReactCommon/react/nativemodule/idlecallbacks`)
+  - React-ImageManager (from `../../../node_modules/react-native/ReactCommon/react/renderer/imagemanager/platform/ios`)
+  - React-jserrorhandler (from `../../../node_modules/react-native/ReactCommon/jserrorhandler`)
+  - React-jsi (from `../../../node_modules/react-native/ReactCommon/jsi`)
+  - React-jsiexecutor (from `../../../node_modules/react-native/ReactCommon/jsiexecutor`)
+  - React-jsinspector (from `../../../node_modules/react-native/ReactCommon/jsinspector-modern`)
+  - React-jsinspectorcdp (from `../../../node_modules/react-native/ReactCommon/jsinspector-modern/cdp`)
+  - React-jsinspectornetwork (from `../../../node_modules/react-native/ReactCommon/jsinspector-modern/network`)
+  - React-jsinspectortracing (from `../../../node_modules/react-native/ReactCommon/jsinspector-modern/tracing`)
+  - React-jsitooling (from `../../../node_modules/react-native/ReactCommon/jsitooling`)
+  - React-jsitracing (from `../../../node_modules/react-native/ReactCommon/hermes/executor/`)
+  - React-logger (from `../../../node_modules/react-native/ReactCommon/logger`)
+  - React-Mapbuffer (from `../../../node_modules/react-native/ReactCommon`)
+  - React-microtasksnativemodule (from `../../../node_modules/react-native/ReactCommon/react/nativemodule/microtasks`)
+  - React-NativeModulesApple (from `../../../node_modules/react-native/ReactCommon/react/nativemodule/core/platform/ios`)
+  - React-oscompat (from `../../../node_modules/react-native/ReactCommon/oscompat`)
+  - React-perflogger (from `../../../node_modules/react-native/ReactCommon/reactperflogger`)
+  - React-performancetimeline (from `../../../node_modules/react-native/ReactCommon/react/performance/timeline`)
+  - React-RCTActionSheet (from `../../../node_modules/react-native/Libraries/ActionSheetIOS`)
+  - React-RCTAnimation (from `../../../node_modules/react-native/Libraries/NativeAnimation`)
+  - React-RCTAppDelegate (from `../../../node_modules/react-native/Libraries/AppDelegate`)
+  - React-RCTBlob (from `../../../node_modules/react-native/Libraries/Blob`)
+  - React-RCTFabric (from `../../../node_modules/react-native/React`)
+  - React-RCTFBReactNativeSpec (from `../../../node_modules/react-native/React`)
+  - React-RCTImage (from `../../../node_modules/react-native/Libraries/Image`)
+  - React-RCTLinking (from `../../../node_modules/react-native/Libraries/LinkingIOS`)
+  - React-RCTNetwork (from `../../../node_modules/react-native/Libraries/Network`)
+  - React-RCTRuntime (from `../../../node_modules/react-native/React/Runtime`)
+  - React-RCTSettings (from `../../../node_modules/react-native/Libraries/Settings`)
+  - React-RCTText (from `../../../node_modules/react-native/Libraries/Text`)
+  - React-RCTVibration (from `../../../node_modules/react-native/Libraries/Vibration`)
+  - React-rendererconsistency (from `../../../node_modules/react-native/ReactCommon/react/renderer/consistency`)
+  - React-renderercss (from `../../../node_modules/react-native/ReactCommon/react/renderer/css`)
+  - React-rendererdebug (from `../../../node_modules/react-native/ReactCommon/react/renderer/debug`)
+  - React-rncore (from `../../../node_modules/react-native/ReactCommon`)
+  - React-RuntimeApple (from `../../../node_modules/react-native/ReactCommon/react/runtime/platform/ios`)
+  - React-RuntimeCore (from `../../../node_modules/react-native/ReactCommon/react/runtime`)
+  - React-runtimeexecutor (from `../../../node_modules/react-native/ReactCommon/runtimeexecutor`)
+  - React-RuntimeHermes (from `../../../node_modules/react-native/ReactCommon/react/runtime`)
+  - React-runtimescheduler (from `../../../node_modules/react-native/ReactCommon/react/renderer/runtimescheduler`)
+  - "React-Sandbox (from `../../../node_modules/@callstack/react-native-sandbox`)"
+  - React-timing (from `../../../node_modules/react-native/ReactCommon/react/timing`)
+  - React-utils (from `../../../node_modules/react-native/ReactCommon/react/utils`)
+  - ReactAppDependencyProvider (from `build/generated/ios`)
+  - ReactCodegen (from `build/generated/ios`)
+  - ReactCommon/turbomodule/core (from `../../../node_modules/react-native/ReactCommon`)
+  - SocketRocket (~> 0.7.1)
+  - Yoga (from `../../../node_modules/react-native/ReactCommon/yoga`)
+
+SPEC REPOS:
+  trunk:
+    - SocketRocket
+
+EXTERNAL SOURCES:
+  boost:
+    :podspec: "../../../node_modules/react-native/third-party-podspecs/boost.podspec"
+  DoubleConversion:
+    :podspec: "../../../node_modules/react-native/third-party-podspecs/DoubleConversion.podspec"
+  fast_float:
+    :podspec: "../../../node_modules/react-native/third-party-podspecs/fast_float.podspec"
+  FBLazyVector:
+    :path: "../../../node_modules/react-native/Libraries/FBLazyVector"
+  fmt:
+    :podspec: "../../../node_modules/react-native/third-party-podspecs/fmt.podspec"
+  glog:
+    :podspec: "../../../node_modules/react-native/third-party-podspecs/glog.podspec"
+  hermes-engine:
+    :podspec: "../../../node_modules/react-native/sdks/hermes-engine/hermes-engine.podspec"
+    :tag: hermes-2025-05-06-RNv0.80.0-4eb6132a5bf0450bf4c6c91987675381d7ac8bca
+  RCT-Folly:
+    :podspec: "../../../node_modules/react-native/third-party-podspecs/RCT-Folly.podspec"
+  RCTDeprecation:
+    :path: "../../../node_modules/react-native/ReactApple/Libraries/RCTFoundation/RCTDeprecation"
+  RCTRequired:
+    :path: "../../../node_modules/react-native/Libraries/Required"
+  RCTTypeSafety:
+    :path: "../../../node_modules/react-native/Libraries/TypeSafety"
+  React:
+    :path: "../../../node_modules/react-native/"
+  React-callinvoker:
+    :path: "../../../node_modules/react-native/ReactCommon/callinvoker"
+  React-Core:
+    :path: "../../../node_modules/react-native/"
+  React-CoreModules:
+    :path: "../../../node_modules/react-native/React/CoreModules"
+  React-cxxreact:
+    :path: "../../../node_modules/react-native/ReactCommon/cxxreact"
+  React-debug:
+    :path: "../../../node_modules/react-native/ReactCommon/react/debug"
+  React-defaultsnativemodule:
+    :path: "../../../node_modules/react-native/ReactCommon/react/nativemodule/defaults"
+  React-domnativemodule:
+    :path: "../../../node_modules/react-native/ReactCommon/react/nativemodule/dom"
+  React-Fabric:
+    :path: "../../../node_modules/react-native/ReactCommon"
+  React-FabricComponents:
+    :path: "../../../node_modules/react-native/ReactCommon"
+  React-FabricImage:
+    :path: "../../../node_modules/react-native/ReactCommon"
+  React-featureflags:
+    :path: "../../../node_modules/react-native/ReactCommon/react/featureflags"
+  React-featureflagsnativemodule:
+    :path: "../../../node_modules/react-native/ReactCommon/react/nativemodule/featureflags"
+  React-graphics:
+    :path: "../../../node_modules/react-native/ReactCommon/react/renderer/graphics"
+  React-hermes:
+    :path: "../../../node_modules/react-native/ReactCommon/hermes"
+  React-idlecallbacksnativemodule:
+    :path: "../../../node_modules/react-native/ReactCommon/react/nativemodule/idlecallbacks"
+  React-ImageManager:
+    :path: "../../../node_modules/react-native/ReactCommon/react/renderer/imagemanager/platform/ios"
+  React-jserrorhandler:
+    :path: "../../../node_modules/react-native/ReactCommon/jserrorhandler"
+  React-jsi:
+    :path: "../../../node_modules/react-native/ReactCommon/jsi"
+  React-jsiexecutor:
+    :path: "../../../node_modules/react-native/ReactCommon/jsiexecutor"
+  React-jsinspector:
+    :path: "../../../node_modules/react-native/ReactCommon/jsinspector-modern"
+  React-jsinspectorcdp:
+    :path: "../../../node_modules/react-native/ReactCommon/jsinspector-modern/cdp"
+  React-jsinspectornetwork:
+    :path: "../../../node_modules/react-native/ReactCommon/jsinspector-modern/network"
+  React-jsinspectortracing:
+    :path: "../../../node_modules/react-native/ReactCommon/jsinspector-modern/tracing"
+  React-jsitooling:
+    :path: "../../../node_modules/react-native/ReactCommon/jsitooling"
+  React-jsitracing:
+    :path: "../../../node_modules/react-native/ReactCommon/hermes/executor/"
+  React-logger:
+    :path: "../../../node_modules/react-native/ReactCommon/logger"
+  React-Mapbuffer:
+    :path: "../../../node_modules/react-native/ReactCommon"
+  React-microtasksnativemodule:
+    :path: "../../../node_modules/react-native/ReactCommon/react/nativemodule/microtasks"
+  React-NativeModulesApple:
+    :path: "../../../node_modules/react-native/ReactCommon/react/nativemodule/core/platform/ios"
+  React-oscompat:
+    :path: "../../../node_modules/react-native/ReactCommon/oscompat"
+  React-perflogger:
+    :path: "../../../node_modules/react-native/ReactCommon/reactperflogger"
+  React-performancetimeline:
+    :path: "../../../node_modules/react-native/ReactCommon/react/performance/timeline"
+  React-RCTActionSheet:
+    :path: "../../../node_modules/react-native/Libraries/ActionSheetIOS"
+  React-RCTAnimation:
+    :path: "../../../node_modules/react-native/Libraries/NativeAnimation"
+  React-RCTAppDelegate:
+    :path: "../../../node_modules/react-native/Libraries/AppDelegate"
+  React-RCTBlob:
+    :path: "../../../node_modules/react-native/Libraries/Blob"
+  React-RCTFabric:
+    :path: "../../../node_modules/react-native/React"
+  React-RCTFBReactNativeSpec:
+    :path: "../../../node_modules/react-native/React"
+  React-RCTImage:
+    :path: "../../../node_modules/react-native/Libraries/Image"
+  React-RCTLinking:
+    :path: "../../../node_modules/react-native/Libraries/LinkingIOS"
+  React-RCTNetwork:
+    :path: "../../../node_modules/react-native/Libraries/Network"
+  React-RCTRuntime:
+    :path: "../../../node_modules/react-native/React/Runtime"
+  React-RCTSettings:
+    :path: "../../../node_modules/react-native/Libraries/Settings"
+  React-RCTText:
+    :path: "../../../node_modules/react-native/Libraries/Text"
+  React-RCTVibration:
+    :path: "../../../node_modules/react-native/Libraries/Vibration"
+  React-rendererconsistency:
+    :path: "../../../node_modules/react-native/ReactCommon/react/renderer/consistency"
+  React-renderercss:
+    :path: "../../../node_modules/react-native/ReactCommon/react/renderer/css"
+  React-rendererdebug:
+    :path: "../../../node_modules/react-native/ReactCommon/react/renderer/debug"
+  React-rncore:
+    :path: "../../../node_modules/react-native/ReactCommon"
+  React-RuntimeApple:
+    :path: "../../../node_modules/react-native/ReactCommon/react/runtime/platform/ios"
+  React-RuntimeCore:
+    :path: "../../../node_modules/react-native/ReactCommon/react/runtime"
+  React-runtimeexecutor:
+    :path: "../../../node_modules/react-native/ReactCommon/runtimeexecutor"
+  React-RuntimeHermes:
+    :path: "../../../node_modules/react-native/ReactCommon/react/runtime"
+  React-runtimescheduler:
+    :path: "../../../node_modules/react-native/ReactCommon/react/renderer/runtimescheduler"
+  React-Sandbox:
+    :path: "../../../node_modules/@callstack/react-native-sandbox"
+  React-timing:
+    :path: "../../../node_modules/react-native/ReactCommon/react/timing"
+  React-utils:
+    :path: "../../../node_modules/react-native/ReactCommon/react/utils"
+  ReactAppDependencyProvider:
+    :path: build/generated/ios
+  ReactCodegen:
+    :path: build/generated/ios
+  ReactCommon:
+    :path: "../../../node_modules/react-native/ReactCommon"
+  Yoga:
+    :path: "../../../node_modules/react-native/ReactCommon/yoga"
+
+SPEC CHECKSUMS:
+  boost: 7e761d76ca2ce687f7cc98e698152abd03a18f90
+  DoubleConversion: cb417026b2400c8f53ae97020b2be961b59470cb
+  fast_float: b32c788ed9c6a8c584d114d0047beda9664e7cc6
+  FBLazyVector: 09f03e4b6f42f955734b64a118f86509cc719427
+  fmt: a40bb5bd0294ea969aaaba240a927bd33d878cdd
+  glog: 5683914934d5b6e4240e497e0f4a3b42d1854183
+  hermes-engine: 4f07404533b808de66cf48ac4200463068d0e95a
+  RCT-Folly: 846fda9475e61ec7bcbf8a3fe81edfcaeb090669
+  RCTDeprecation: efa5010912100e944a7ac9a93a157e1def1988fe
+  RCTRequired: bbc4cf999ddc4a4b076e076c74dd1d39d0254630
+  RCTTypeSafety: d877728097547d0a37786cc9130c43ad71739ac3
+  React: 4b0b9cb962e694611e5e8a697c1b0300a2510c21
+  React-callinvoker: 70f125c17c7132811a6b473946ac5e7ae93b5e57
+  React-Core: bab40f5b1f46fe0c5896895a6f333e861a821a81
+  React-CoreModules: 05647d952e521113c128360633896ba7ba652e82
+  React-cxxreact: 2b4bac1ec6eecc6288ac8a6caea6afb42585740e
+  React-debug: deb3a146ef717fa3e8f4c23e0288369fe53199b7
+  React-defaultsnativemodule: 11e2948787a15d3cf1b66d7f29f13770a177bff7
+  React-domnativemodule: 2f4b279acdb2963736fb5de2f585811dd90070b5
+  React-Fabric: 6f8d1a303c96f1d078c14d74c4005bf457e5b782
+  React-FabricComponents: b106410970e9a0c4e592da656c7a7e0947306c23
+  React-FabricImage: 1abaf230dfce9b58fdf53c4128f3f40c6e64af6a
+  React-featureflags: f7ef58d91079efde3ad223bcca6d197e845d5bcf
+  React-featureflagsnativemodule: ae5abc9849d1696f4f8f11ee3744bf5715e032cf
+  React-graphics: b306856c6ed9aac32f717a229550406a53b28a6d
+  React-hermes: b6edce8fa19388654b1aea30844497cbeade83bc
+  React-idlecallbacksnativemodule: cb386712842cb9e479c89311edb234d529b64db4
+  React-ImageManager: 8ce94417853eaa22faaad1f4cc1952dd3f8e2275
+  React-jserrorhandler: ab827d67dc270a9c8703eef524230baeafaf6876
+  React-jsi: 545342ec5c78ab1277af5f0dbe8d489e7e73db14
+  React-jsiexecutor: 20210891c7c77255c16dec6762faf68b373f9f74
+  React-jsinspector: 4e73460e488132d70d2b4894e5578cc856f2cb74
+  React-jsinspectorcdp: 8b2bcb5779289cb2b9ca517f2965ed23eb2fd3e0
+  React-jsinspectornetwork: b5e0cb9e488d294eed2d8209dc3dc0f9587210c1
+  React-jsinspectortracing: f3c4036e7b984405ac910f878576d325dd9f2834
+  React-jsitooling: 75bbfd221b6173a5e848ca5a6680506bac064a56
+  React-jsitracing: 11ed7d821864dd988c159d4943e0a1e0937c11b1
+  React-logger: 984ebd897afad067555d081deaf03f57c4315723
+  React-Mapbuffer: 0c045c844ce6d85cde53e85ab163294c6adad349
+  React-microtasksnativemodule: d9499269ad1f484ae71319bac1d9231447f2094e
+  React-NativeModulesApple: 983f3483ef0a3446b56d490f09d579fba2442e17
+  React-oscompat: 114036cd8f064558c9c1a0c04fc9ae5e1453706a
+  React-perflogger: e7287fee27c16e3c8bd4d470f2361572b63be16b
+  React-performancetimeline: 8ebbaa31d2d0cea680b0a2a567500d3cab8954fc
+  React-RCTActionSheet: 68c68b0a7a5d2b0cfc255c64889b6e485974e988
+  React-RCTAnimation: d6c5c728b888a967ce9aff1ff71a8ed71a68d069
+  React-RCTAppDelegate: 0fc048666bda159cd469a6fb9befb04b3fa62be4
+  React-RCTBlob: 12d8c699a1f906840113ee8d8bb575e69a05509f
+  React-RCTFabric: 01e815845ebc185f44205dcbf50eeb712fec23fe
+  React-RCTFBReactNativeSpec: f57927fb0af6ce2f25c19f8b894e2986138aa89f
+  React-RCTImage: a82518168f4ee407913b23ca749ca79ef51959f3
+  React-RCTLinking: 7f343b584c36f024f390fea563483568fe763ef6
+  React-RCTNetwork: 3165eb757ceb62a7cde4cdad043d63314122e8a3
+  React-RCTRuntime: feee590c459c4cb6aaa7a00f3abc8c04709b536f
+  React-RCTSettings: 6bad0ae45d8d872c873059f332f586f99875621f
+  React-RCTText: 657d60f35983062de8f0cea67c279aa7a3ea9858
+  React-RCTVibration: 78f4770515141efb7f55f9b27c49dda95319c3a8
+  React-rendererconsistency: f7baab26c6d0cd5b2eb7afcecfd2d8b957017b18
+  React-renderercss: bdd2f83a4a054c3e4321fd61305c202b848e471b
+  React-rendererdebug: 9f8865ee038127a9d99d4b034c9da4935d204993
+  React-rncore: f7438473c4c71ee1963fb06a8635bb96013c9e1c
+  React-RuntimeApple: 4d2ab9f72b9193da86eceded128a67254fc18aeb
+  React-RuntimeCore: 5fd73030438d094975ca0f549d162dd97746ae38
+  React-runtimeexecutor: 17c70842d5e611130cb66f91e247bc4a609c3508
+  React-RuntimeHermes: 3c88e6e1ea7ea0899dcffc77c10d61ea46688cfd
+  React-runtimescheduler: 024500621c7c93d65371498abb4ee26d34f5d47d
+  React-Sandbox: 52c91938b8a96d84d633e13421b2ad41582f7ab7
+  React-timing: c3c923df2b86194e1682e01167717481232f1dc7
+  React-utils: 9154a037543147e1c24098f1a48fc8472602c092
+  ReactAppDependencyProvider: afd905e84ee36e1678016ae04d7370c75ed539be
+  ReactCodegen: 06bf9ae2e01a2416250cf5e44e4a06b1c9ea201b
+  ReactCommon: 17fd88849a174bf9ce45461912291aca711410fc
+  SocketRocket: d4aabe649be1e368d1318fdf28a022d714d65748
+  Yoga: daa1e4de4b971b977b23bc842aaa3e135324f1f3
+
+PODFILE CHECKSUM: 0ae52ad1aca2e34243c918aa814fe9d62521d813
+
+COCOAPODS: 1.16.2
diff --git a/apps/origin-pooling/ios/assets/__node_modules/react-native/Libraries/LogBox/UI/LogBoxImages/alert-triangle.png b/apps/origin-pooling/ios/assets/__node_modules/react-native/Libraries/LogBox/UI/LogBoxImages/alert-triangle.png
new file mode 100644
index 0000000000000000000000000000000000000000..48e05d7be96a213ecabde05d139b4300fd994a0b
GIT binary patch
literal 609
zcmV-n0-pVeP)<h;3K|Lk000e1NJLTq001xm001fo1ONa4Uq%q|0006gNkl<Zc-qaD
zC6F9Z6h+UVUS=1L4KovYu{!J)y*DevOypLD^)iDGGs|#p-B1s9Pt~5`|KGc>>YpKI
z7Aa;kixefHfs=gVD_{A<2^xr)#XRRLzVMvIL`XFcQM4})sU|W`JN5-H{QNW#v4Ss(
z>>@^tF1`A~3L+rRpaRE80+3`(D}%%d&0!zOIuPr;b~wD=*NVCTU@mC&by(G>6!e~Y
z08`I<?VKV6%dNKsVOp$udGUG&6f!QoLaN8LJ5a3ZLsq$-Al7^TAVpARy_Z1j-~kWV
z0pgNXS5Yu0thWKggP$u8Kr~qO2?}JH^|oSsB$!sKURIdiel<>z$~qv$gx2~CQGLKs
z8zAcd*x=Oz<Vhv3)N&cJ4G@>L`ie^O;<y?<(3sbNMm}i$IC-$tdfOnc0nl#MOLOb(
zQ}HCJya%M1)J|V6)%zW?5%L}Yo4mI_yWW>7yGj85papSNoiDSgJ{qXk_^Tp_CO)eB
zC<L>F&noGl7&_GbnI*w`dsQ$+iegAHrG(xf)qAaJGsUvm8GHGM3hTW_7_M1$1%Giw
z8y{)H1WJC$9!wV1M*y?fdOHzW-lk8<MyFLTLd59N;xy^d1JX<@t%n!@?6R6Ih+>Y&
zY;oT1zr|c9DsKFpIIfqgiHcQ9952;?)qfAT?mtiqh=PR-{Cz~b`C5{TCCBJ4Nqjdk
vL>V_DkH1M7VB$1$pO=wDzu+Ft==<~=mc%HM{zOvz00000NkvXXu0mjf|6voF

literal 0
HcmV?d00001

diff --git a/apps/origin-pooling/ios/assets/__node_modules/react-native/Libraries/LogBox/UI/LogBoxImages/chevron-left.png b/apps/origin-pooling/ios/assets/__node_modules/react-native/Libraries/LogBox/UI/LogBoxImages/chevron-left.png
new file mode 100644
index 0000000000000000000000000000000000000000..6b07c51b4a0187d8cc4d99bce95eb3d2d121f790
GIT binary patch
literal 126
zcmeAS@N?(olHy`uVBq!ia0vp^0zfRo!2%=?S$v-eq+C5+978H@B_H5ql8|FwsIK?2
zpv|7=f8z&3xy%lxJ(nD;81|R^;F!ecF!dNq|HY-8+6p<W%aq-x3ixbcnQVKo$JyXD
aBg5utlO{jdpe+tGkipZ{&t;ucLK6UPxhFLM

literal 0
HcmV?d00001

diff --git a/apps/origin-pooling/ios/assets/__node_modules/react-native/Libraries/LogBox/UI/LogBoxImages/chevron-right.png b/apps/origin-pooling/ios/assets/__node_modules/react-native/Libraries/LogBox/UI/LogBoxImages/chevron-right.png
new file mode 100644
index 0000000000000000000000000000000000000000..251bb7283d07510d8c12dd2e63085156e9ff93c2
GIT binary patch
literal 123
zcmeAS@N?(olHy`uVBq!ia0vp^0zfRo!2%=?S$v-eq?|lm978H@B`17Hso-g0<k`Ux
z@X21_Un0lx#SHr=F)R>aRDH-YwMUCnVaXFiM^=`#3J*?9RP3FZ!KqTc$%yaZ8g_<f
XFDFelah<mgXc~j3tDnm{r-UW|3v4Ed

literal 0
HcmV?d00001

diff --git a/apps/origin-pooling/ios/assets/__node_modules/react-native/Libraries/LogBox/UI/LogBoxImages/close.png b/apps/origin-pooling/ios/assets/__node_modules/react-native/Libraries/LogBox/UI/LogBoxImages/close.png
new file mode 100644
index 0000000000000000000000000000000000000000..43471b9cf2f732c8375bf09c1f1fc2ba275fe25b
GIT binary patch
literal 187
zcmeAS@N?(olHy`uVBq!ia0vp^G9b*s0wiy+h|2@1CQlc~kcwM#ueS0sIC8jL%*<cx
zvi<*sV>?f~)LATIet#w`>(o}KlJ44lo+~TYI?8TbmpK1C_dAizvTbecPG%b47y{;h
znqcU#)_e9n$1A}uwvJaM7cX{8?vY|H*>jUavi(oUYxCtlEDS!g7(4v*?weU|`S`y5
m!l&~?e}0enr#O9j1M8}6ag7_*YkmM-!{F)a=d#Wzp$PzAgiBoj

literal 0
HcmV?d00001

diff --git a/apps/origin-pooling/ios/assets/__node_modules/react-native/Libraries/LogBox/UI/LogBoxImages/loader.png b/apps/origin-pooling/ios/assets/__node_modules/react-native/Libraries/LogBox/UI/LogBoxImages/loader.png
new file mode 100644
index 0000000000000000000000000000000000000000..7647edab864eb39fa180e86132d9e56d7a3fcdc5
GIT binary patch
literal 282
zcmV+#0p<RQP)<h;3K|Lk000e1NJLTq001li001lq1ONa4w2hLA0002tNkl<Zc-rlk
zwP8dt5CtbxdaamxP<~X3;%ikMC>5-k{SN<{N7;uF(Jp%v$z&pvlQE3U<k)@rJK`DP
zC~;s0nhk@({9y5%!eFCYJ1~sK>LBrohG7iV>OjGs)Iuz^Mj;@W(}em-EVb?35Xui%
zYJ=#n4^ZnZy<NLqT{%N>M%}L6u1+YD)^1l<jLsE`D>_D1TFn{hNvqU}GyeHPA{l#A
zGV$d9-#<R+Zj=AJiT#G+9|ykp5L){jn`@tge(i8IIb5a=*S|x+;t*na1%-ZLtbgGB
gpWOH-kZvjOH3!;Y)6++d+W-In07*qoM6N<$f-ru5)c^nh

literal 0
HcmV?d00001

diff --git a/apps/origin-pooling/ios/sandbox.jsbundle b/apps/origin-pooling/ios/sandbox.jsbundle
new file mode 100644
index 0000000..a5051de
--- /dev/null
+++ b/apps/origin-pooling/ios/sandbox.jsbundle
@@ -0,0 +1,99314 @@
+var __BUNDLE_START_TIME__=globalThis.nativePerformanceNow?nativePerformanceNow():Date.now(),__DEV__=true,process=globalThis.process||{},__METRO_GLOBAL_PREFIX__='',__requireCycleIgnorePatterns=[/(^|\/|\\)node_modules($|\/|\\)/];process.env=process.env||{};process.env.NODE_ENV=process.env.NODE_ENV||"development";
+(function (global) {
+  "use strict";
+
+  global.__r = metroRequire;
+  global[`${__METRO_GLOBAL_PREFIX__}__d`] = define;
+  global.__c = clear;
+  global.__registerSegment = registerSegment;
+  var modules = clear();
+  var EMPTY = {};
+  var CYCLE_DETECTED = {};
+  var _ref = {},
+    hasOwnProperty = _ref.hasOwnProperty;
+  if (__DEV__) {
+    var _global$$RefreshReg$, _global$$RefreshSig$;
+    global.$RefreshReg$ = (_global$$RefreshReg$ = global.$RefreshReg$) != null ? _global$$RefreshReg$ : function () {};
+    global.$RefreshSig$ = (_global$$RefreshSig$ = global.$RefreshSig$) != null ? _global$$RefreshSig$ : function () {
+      return function (type) {
+        return type;
+      };
+    };
+  }
+  function clear() {
+    modules = new Map();
+    return modules;
+  }
+  if (__DEV__) {
+    var verboseNamesToModuleIds = new Map();
+    var getModuleIdForVerboseName = function getModuleIdForVerboseName(verboseName) {
+      var moduleId = verboseNamesToModuleIds.get(verboseName);
+      if (moduleId == null) {
+        throw new Error(`Unknown named module: "${verboseName}"`);
+      }
+      return moduleId;
+    };
+    var initializingModuleIds = [];
+  }
+  function define(factory, moduleId, dependencyMap) {
+    if (modules.has(moduleId)) {
+      if (__DEV__) {
+        var inverseDependencies = arguments[4];
+        if (inverseDependencies) {
+          global.__accept(moduleId, factory, dependencyMap, inverseDependencies);
+        }
+      }
+      return;
+    }
+    var mod = {
+      dependencyMap: dependencyMap,
+      factory: factory,
+      hasError: false,
+      importedAll: EMPTY,
+      importedDefault: EMPTY,
+      isInitialized: false,
+      publicModule: {
+        exports: {}
+      }
+    };
+    modules.set(moduleId, mod);
+    if (__DEV__) {
+      mod.hot = createHotReloadingObject();
+      var verboseName = arguments[3];
+      if (verboseName) {
+        mod.verboseName = verboseName;
+        verboseNamesToModuleIds.set(verboseName, moduleId);
+      }
+    }
+  }
+  function metroRequire(moduleId, maybeNameForDev) {
+    if (moduleId === null) {
+      if (__DEV__ && typeof maybeNameForDev === "string") {
+        throw new Error("Cannot find module '" + maybeNameForDev + "'");
+      }
+      throw new Error("Cannot find module");
+    }
+    if (__DEV__ && typeof moduleId === "string") {
+      var verboseName = moduleId;
+      moduleId = getModuleIdForVerboseName(verboseName);
+      console.warn(`Requiring module "${verboseName}" by name is only supported for ` + "debugging purposes and will BREAK IN PRODUCTION!");
+    }
+    var moduleIdReallyIsNumber = moduleId;
+    if (__DEV__) {
+      var initializingIndex = initializingModuleIds.indexOf(moduleIdReallyIsNumber);
+      if (initializingIndex !== -1) {
+        var cycle = initializingModuleIds.slice(initializingIndex).map(function (id) {
+          var _modules$get$verboseN, _modules$get;
+          return (_modules$get$verboseN = (_modules$get = modules.get(id)) == null ? void 0 : _modules$get.verboseName) != null ? _modules$get$verboseN : "[unknown]";
+        });
+        if (shouldPrintRequireCycle(cycle)) {
+          cycle.push(cycle[0]);
+          console.warn(`Require cycle: ${cycle.join(" -> ")}\n\n` + "Require cycles are allowed, but can result in uninitialized values. " + "Consider refactoring to remove the need for a cycle.");
+        }
+      }
+    }
+    var module = modules.get(moduleIdReallyIsNumber);
+    return module && module.isInitialized ? module.publicModule.exports : guardedLoadModule(moduleIdReallyIsNumber, module);
+  }
+  function shouldPrintRequireCycle(modules) {
+    var regExps = global[__METRO_GLOBAL_PREFIX__ + "__requireCycleIgnorePatterns"];
+    if (!Array.isArray(regExps)) {
+      return true;
+    }
+    var isIgnored = function isIgnored(module) {
+      return module != null && regExps.some(function (regExp) {
+        return regExp.test(module);
+      });
+    };
+    return modules.every(function (module) {
+      return !isIgnored(module);
+    });
+  }
+  function metroImportDefault(moduleId) {
+    if (__DEV__ && typeof moduleId === "string") {
+      var verboseName = moduleId;
+      moduleId = getModuleIdForVerboseName(verboseName);
+    }
+    var moduleIdReallyIsNumber = moduleId;
+    var maybeInitializedModule = modules.get(moduleIdReallyIsNumber);
+    if (maybeInitializedModule && maybeInitializedModule.importedDefault !== EMPTY) {
+      return maybeInitializedModule.importedDefault;
+    }
+    var exports = metroRequire(moduleIdReallyIsNumber);
+    var importedDefault = exports && exports.__esModule ? exports.default : exports;
+    var initializedModule = modules.get(moduleIdReallyIsNumber);
+    return initializedModule.importedDefault = importedDefault;
+  }
+  metroRequire.importDefault = metroImportDefault;
+  function metroImportAll(moduleId) {
+    if (__DEV__ && typeof moduleId === "string") {
+      var verboseName = moduleId;
+      moduleId = getModuleIdForVerboseName(verboseName);
+    }
+    var moduleIdReallyIsNumber = moduleId;
+    var maybeInitializedModule = modules.get(moduleIdReallyIsNumber);
+    if (maybeInitializedModule && maybeInitializedModule.importedAll !== EMPTY) {
+      return maybeInitializedModule.importedAll;
+    }
+    var exports = metroRequire(moduleIdReallyIsNumber);
+    var importedAll;
+    if (exports && exports.__esModule) {
+      importedAll = exports;
+    } else {
+      importedAll = {};
+      if (exports) {
+        for (var key in exports) {
+          if (hasOwnProperty.call(exports, key)) {
+            importedAll[key] = exports[key];
+          }
+        }
+      }
+      importedAll.default = exports;
+    }
+    var initializedModule = modules.get(moduleIdReallyIsNumber);
+    return initializedModule.importedAll = importedAll;
+  }
+  metroRequire.importAll = metroImportAll;
+  metroRequire.context = function fallbackRequireContext() {
+    if (__DEV__) {
+      throw new Error("The experimental Metro feature `require.context` is not enabled in your project.\nThis can be enabled by setting the `transformer.unstable_allowRequireContext` property to `true` in your Metro configuration.");
+    }
+    throw new Error("The experimental Metro feature `require.context` is not enabled in your project.");
+  };
+  metroRequire.resolveWeak = function fallbackRequireResolveWeak() {
+    if (__DEV__) {
+      throw new Error("require.resolveWeak cannot be called dynamically. Ensure you are using the same version of `metro` and `metro-runtime`.");
+    }
+    throw new Error("require.resolveWeak cannot be called dynamically.");
+  };
+  var inGuard = false;
+  function guardedLoadModule(moduleId, module) {
+    if (!inGuard && global.ErrorUtils) {
+      inGuard = true;
+      var returnValue;
+      try {
+        returnValue = loadModuleImplementation(moduleId, module);
+      } catch (e) {
+        global.ErrorUtils.reportFatalError(e);
+      }
+      inGuard = false;
+      return returnValue;
+    } else {
+      return loadModuleImplementation(moduleId, module);
+    }
+  }
+  var ID_MASK_SHIFT = 16;
+  var LOCAL_ID_MASK = ~0 >>> ID_MASK_SHIFT;
+  function unpackModuleId(moduleId) {
+    var segmentId = moduleId >>> ID_MASK_SHIFT;
+    var localId = moduleId & LOCAL_ID_MASK;
+    return {
+      segmentId: segmentId,
+      localId: localId
+    };
+  }
+  metroRequire.unpackModuleId = unpackModuleId;
+  function packModuleId(value) {
+    return (value.segmentId << ID_MASK_SHIFT) + value.localId;
+  }
+  metroRequire.packModuleId = packModuleId;
+  var moduleDefinersBySegmentID = [];
+  var definingSegmentByModuleID = new Map();
+  function registerSegment(segmentId, moduleDefiner, moduleIds) {
+    moduleDefinersBySegmentID[segmentId] = moduleDefiner;
+    if (__DEV__) {
+      if (segmentId === 0 && moduleIds) {
+        throw new Error("registerSegment: Expected moduleIds to be null for main segment");
+      }
+      if (segmentId !== 0 && !moduleIds) {
+        throw new Error("registerSegment: Expected moduleIds to be passed for segment #" + segmentId);
+      }
+    }
+    if (moduleIds) {
+      moduleIds.forEach(function (moduleId) {
+        if (!modules.has(moduleId) && !definingSegmentByModuleID.has(moduleId)) {
+          definingSegmentByModuleID.set(moduleId, segmentId);
+        }
+      });
+    }
+  }
+  function loadModuleImplementation(moduleId, module) {
+    if (!module && moduleDefinersBySegmentID.length > 0) {
+      var _definingSegmentByMod;
+      var segmentId = (_definingSegmentByMod = definingSegmentByModuleID.get(moduleId)) != null ? _definingSegmentByMod : 0;
+      var definer = moduleDefinersBySegmentID[segmentId];
+      if (definer != null) {
+        definer(moduleId);
+        module = modules.get(moduleId);
+        definingSegmentByModuleID.delete(moduleId);
+      }
+    }
+    var nativeRequire = global.nativeRequire;
+    if (!module && nativeRequire) {
+      var _unpackModuleId = unpackModuleId(moduleId),
+        _segmentId = _unpackModuleId.segmentId,
+        localId = _unpackModuleId.localId;
+      nativeRequire(localId, _segmentId);
+      module = modules.get(moduleId);
+    }
+    if (!module) {
+      throw unknownModuleError(moduleId);
+    }
+    if (module.hasError) {
+      throw module.error;
+    }
+    if (__DEV__) {
+      var Systrace = requireSystrace();
+      var Refresh = requireRefresh();
+    }
+    module.isInitialized = true;
+    var _module = module,
+      factory = _module.factory,
+      dependencyMap = _module.dependencyMap;
+    if (__DEV__) {
+      initializingModuleIds.push(moduleId);
+    }
+    try {
+      if (__DEV__) {
+        Systrace.beginEvent("JS_require_" + (module.verboseName || moduleId));
+      }
+      var moduleObject = module.publicModule;
+      if (__DEV__) {
+        moduleObject.hot = module.hot;
+        var prevRefreshReg = global.$RefreshReg$;
+        var prevRefreshSig = global.$RefreshSig$;
+        if (Refresh != null) {
+          var RefreshRuntime = Refresh;
+          global.$RefreshReg$ = function (type, id) {
+            var prefixedModuleId = __METRO_GLOBAL_PREFIX__ + " " + moduleId + " " + id;
+            RefreshRuntime.register(type, prefixedModuleId);
+          };
+          global.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
+        }
+      }
+      moduleObject.id = moduleId;
+      factory(global, metroRequire, metroImportDefault, metroImportAll, moduleObject, moduleObject.exports, dependencyMap);
+      if (!__DEV__) {
+        module.factory = undefined;
+        module.dependencyMap = undefined;
+      }
+      if (__DEV__) {
+        Systrace.endEvent();
+        if (Refresh != null) {
+          var prefixedModuleId = __METRO_GLOBAL_PREFIX__ + " " + moduleId;
+          registerExportsForReactRefresh(Refresh, moduleObject.exports, prefixedModuleId);
+        }
+      }
+      return moduleObject.exports;
+    } catch (e) {
+      module.hasError = true;
+      module.error = e;
+      module.isInitialized = false;
+      module.publicModule.exports = undefined;
+      throw e;
+    } finally {
+      if (__DEV__) {
+        if (initializingModuleIds.pop() !== moduleId) {
+          throw new Error("initializingModuleIds is corrupt; something is terribly wrong");
+        }
+        global.$RefreshReg$ = prevRefreshReg;
+        global.$RefreshSig$ = prevRefreshSig;
+      }
+    }
+  }
+  function unknownModuleError(id) {
+    var message = 'Requiring unknown module "' + id + '".';
+    if (__DEV__) {
+      message += " If you are sure the module exists, try restarting Metro. " + "You may also want to run `yarn` or `npm install`.";
+    }
+    return Error(message);
+  }
+  if (__DEV__) {
+    metroRequire.Systrace = {
+      beginEvent: function beginEvent() {},
+      endEvent: function endEvent() {}
+    };
+    metroRequire.getModules = function () {
+      return modules;
+    };
+    var createHotReloadingObject = function createHotReloadingObject() {
+      var hot = {
+        _acceptCallback: null,
+        _disposeCallback: null,
+        _didAccept: false,
+        accept: function accept(callback) {
+          hot._didAccept = true;
+          hot._acceptCallback = callback;
+        },
+        dispose: function dispose(callback) {
+          hot._disposeCallback = callback;
+        }
+      };
+      return hot;
+    };
+    var reactRefreshTimeout = null;
+    var metroHotUpdateModule = function metroHotUpdateModule(id, factory, dependencyMap, inverseDependencies) {
+      var mod = modules.get(id);
+      if (!mod) {
+        if (factory) {
+          return;
+        }
+        throw unknownModuleError(id);
+      }
+      if (!mod.hasError && !mod.isInitialized) {
+        mod.factory = factory;
+        mod.dependencyMap = dependencyMap;
+        return;
+      }
+      var Refresh = requireRefresh();
+      var refreshBoundaryIDs = new Set();
+      var didBailOut = false;
+      var updatedModuleIDs;
+      try {
+        updatedModuleIDs = topologicalSort([id], function (pendingID) {
+          var pendingModule = modules.get(pendingID);
+          if (pendingModule == null) {
+            return [];
+          }
+          var pendingHot = pendingModule.hot;
+          if (pendingHot == null) {
+            throw new Error("[Refresh] Expected module.hot to always exist in DEV.");
+          }
+          var canAccept = pendingHot._didAccept;
+          if (!canAccept && Refresh != null) {
+            var isBoundary = isReactRefreshBoundary(Refresh, pendingModule.publicModule.exports);
+            if (isBoundary) {
+              canAccept = true;
+              refreshBoundaryIDs.add(pendingID);
+            }
+          }
+          if (canAccept) {
+            return [];
+          }
+          var parentIDs = inverseDependencies[pendingID];
+          if (parentIDs.length === 0) {
+            performFullRefresh("No root boundary", {
+              source: mod,
+              failed: pendingModule
+            });
+            didBailOut = true;
+            return [];
+          }
+          return parentIDs;
+        }, function () {
+          return didBailOut;
+        }).reverse();
+      } catch (e) {
+        if (e === CYCLE_DETECTED) {
+          performFullRefresh("Dependency cycle", {
+            source: mod
+          });
+          return;
+        }
+        throw e;
+      }
+      if (didBailOut) {
+        return;
+      }
+      var seenModuleIDs = new Set();
+      for (var i = 0; i < updatedModuleIDs.length; i++) {
+        var updatedID = updatedModuleIDs[i];
+        if (seenModuleIDs.has(updatedID)) {
+          continue;
+        }
+        seenModuleIDs.add(updatedID);
+        var updatedMod = modules.get(updatedID);
+        if (updatedMod == null) {
+          throw new Error("[Refresh] Expected to find the updated module.");
+        }
+        var prevExports = updatedMod.publicModule.exports;
+        var didError = runUpdatedModule(updatedID, updatedID === id ? factory : undefined, updatedID === id ? dependencyMap : undefined);
+        var nextExports = updatedMod.publicModule.exports;
+        if (didError) {
+          return;
+        }
+        if (refreshBoundaryIDs.has(updatedID)) {
+          var isNoLongerABoundary = !isReactRefreshBoundary(Refresh, nextExports);
+          var didInvalidate = shouldInvalidateReactRefreshBoundary(Refresh, prevExports, nextExports);
+          if (isNoLongerABoundary || didInvalidate) {
+            var parentIDs = inverseDependencies[updatedID];
+            if (parentIDs.length === 0) {
+              performFullRefresh(isNoLongerABoundary ? "No longer a boundary" : "Invalidated boundary", {
+                source: mod,
+                failed: updatedMod
+              });
+              return;
+            }
+            for (var j = 0; j < parentIDs.length; j++) {
+              var parentID = parentIDs[j];
+              var parentMod = modules.get(parentID);
+              if (parentMod == null) {
+                throw new Error("[Refresh] Expected to find parent module.");
+              }
+              var canAcceptParent = isReactRefreshBoundary(Refresh, parentMod.publicModule.exports);
+              if (canAcceptParent) {
+                refreshBoundaryIDs.add(parentID);
+                updatedModuleIDs.push(parentID);
+              } else {
+                performFullRefresh("Invalidated boundary", {
+                  source: mod,
+                  failed: parentMod
+                });
+                return;
+              }
+            }
+          }
+        }
+      }
+      if (Refresh != null) {
+        if (reactRefreshTimeout == null) {
+          reactRefreshTimeout = setTimeout(function () {
+            reactRefreshTimeout = null;
+            Refresh.performReactRefresh();
+          }, 30);
+        }
+      }
+    };
+    var topologicalSort = function topologicalSort(roots, getEdges, earlyStop) {
+      var result = [];
+      var visited = new Set();
+      var stack = new Set();
+      function traverseDependentNodes(node) {
+        if (stack.has(node)) {
+          throw CYCLE_DETECTED;
+        }
+        if (visited.has(node)) {
+          return;
+        }
+        visited.add(node);
+        stack.add(node);
+        var dependentNodes = getEdges(node);
+        if (earlyStop(node)) {
+          stack.delete(node);
+          return;
+        }
+        dependentNodes.forEach(function (dependent) {
+          traverseDependentNodes(dependent);
+        });
+        stack.delete(node);
+        result.push(node);
+      }
+      roots.forEach(function (root) {
+        traverseDependentNodes(root);
+      });
+      return result;
+    };
+    var runUpdatedModule = function runUpdatedModule(id, factory, dependencyMap) {
+      var mod = modules.get(id);
+      if (mod == null) {
+        throw new Error("[Refresh] Expected to find the module.");
+      }
+      var hot = mod.hot;
+      if (!hot) {
+        throw new Error("[Refresh] Expected module.hot to always exist in DEV.");
+      }
+      if (hot._disposeCallback) {
+        try {
+          hot._disposeCallback();
+        } catch (error) {
+          console.error(`Error while calling dispose handler for module ${id}: `, error);
+        }
+      }
+      if (factory) {
+        mod.factory = factory;
+      }
+      if (dependencyMap) {
+        mod.dependencyMap = dependencyMap;
+      }
+      mod.hasError = false;
+      mod.error = undefined;
+      mod.importedAll = EMPTY;
+      mod.importedDefault = EMPTY;
+      mod.isInitialized = false;
+      var prevExports = mod.publicModule.exports;
+      mod.publicModule.exports = {};
+      hot._didAccept = false;
+      hot._acceptCallback = null;
+      hot._disposeCallback = null;
+      metroRequire(id);
+      if (mod.hasError) {
+        mod.hasError = false;
+        mod.isInitialized = true;
+        mod.error = null;
+        mod.publicModule.exports = prevExports;
+        return true;
+      }
+      if (hot._acceptCallback) {
+        try {
+          hot._acceptCallback();
+        } catch (error) {
+          console.error(`Error while calling accept handler for module ${id}: `, error);
+        }
+      }
+      return false;
+    };
+    var performFullRefresh = function performFullRefresh(reason, modules) {
+      if (typeof window !== "undefined" && window.location != null && typeof window.location.reload === "function") {
+        window.location.reload();
+      } else {
+        var Refresh = requireRefresh();
+        if (Refresh != null) {
+          var _modules$source$verbo, _modules$source, _modules$failed$verbo, _modules$failed;
+          var sourceName = (_modules$source$verbo = (_modules$source = modules.source) == null ? void 0 : _modules$source.verboseName) != null ? _modules$source$verbo : "unknown";
+          var failedName = (_modules$failed$verbo = (_modules$failed = modules.failed) == null ? void 0 : _modules$failed.verboseName) != null ? _modules$failed$verbo : "unknown";
+          Refresh.performFullRefresh(`Fast Refresh - ${reason} <${sourceName}> <${failedName}>`);
+        } else {
+          console.warn("Could not reload the application after an edit.");
+        }
+      }
+    };
+    var isReactRefreshBoundary = function isReactRefreshBoundary(Refresh, moduleExports) {
+      if (Refresh.isLikelyComponentType(moduleExports)) {
+        return true;
+      }
+      if (moduleExports == null || typeof moduleExports !== "object") {
+        return false;
+      }
+      var hasExports = false;
+      var areAllExportsComponents = true;
+      for (var key in moduleExports) {
+        hasExports = true;
+        if (key === "__esModule") {
+          continue;
+        }
+        var desc = Object.getOwnPropertyDescriptor(moduleExports, key);
+        if (desc && desc.get) {
+          return false;
+        }
+        var exportValue = moduleExports[key];
+        if (!Refresh.isLikelyComponentType(exportValue)) {
+          areAllExportsComponents = false;
+        }
+      }
+      return hasExports && areAllExportsComponents;
+    };
+    var shouldInvalidateReactRefreshBoundary = function shouldInvalidateReactRefreshBoundary(Refresh, prevExports, nextExports) {
+      var prevSignature = getRefreshBoundarySignature(Refresh, prevExports);
+      var nextSignature = getRefreshBoundarySignature(Refresh, nextExports);
+      if (prevSignature.length !== nextSignature.length) {
+        return true;
+      }
+      for (var i = 0; i < nextSignature.length; i++) {
+        if (prevSignature[i] !== nextSignature[i]) {
+          return true;
+        }
+      }
+      return false;
+    };
+    var getRefreshBoundarySignature = function getRefreshBoundarySignature(Refresh, moduleExports) {
+      var signature = [];
+      signature.push(Refresh.getFamilyByType(moduleExports));
+      if (moduleExports == null || typeof moduleExports !== "object") {
+        return signature;
+      }
+      for (var key in moduleExports) {
+        if (key === "__esModule") {
+          continue;
+        }
+        var desc = Object.getOwnPropertyDescriptor(moduleExports, key);
+        if (desc && desc.get) {
+          continue;
+        }
+        var exportValue = moduleExports[key];
+        signature.push(key);
+        signature.push(Refresh.getFamilyByType(exportValue));
+      }
+      return signature;
+    };
+    var registerExportsForReactRefresh = function registerExportsForReactRefresh(Refresh, moduleExports, moduleID) {
+      Refresh.register(moduleExports, moduleID + " %exports%");
+      if (moduleExports == null || typeof moduleExports !== "object") {
+        return;
+      }
+      for (var key in moduleExports) {
+        var desc = Object.getOwnPropertyDescriptor(moduleExports, key);
+        if (desc && desc.get) {
+          continue;
+        }
+        var exportValue = moduleExports[key];
+        var typeID = moduleID + " %exports% " + key;
+        Refresh.register(exportValue, typeID);
+      }
+    };
+    global.__accept = metroHotUpdateModule;
+  }
+  if (__DEV__) {
+    var requireSystrace = function requireSystrace() {
+      return global[__METRO_GLOBAL_PREFIX__ + "__SYSTRACE"] || metroRequire.Systrace;
+    };
+    var requireRefresh = function requireRefresh() {
+      return global[__METRO_GLOBAL_PREFIX__ + "__ReactRefresh"] || global[global.__METRO_GLOBAL_PREFIX__ + "__ReactRefresh"] || metroRequire.Refresh;
+    };
+  }
+})(typeof globalThis !== 'undefined' ? globalThis : typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : this);
+(function (global) {
+  /**
+   * 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.
+   *
+   * @polyfill
+   * @nolint
+   * @format
+   */
+
+  'use client';
+
+  /* eslint-disable no-shadow, eqeqeq, no-unused-vars, no-void, no-control-regex  */
+
+  /**
+   * This pipes all of our console logging functions to native logging so that
+   * JavaScript errors in required modules show up in Xcode via NSLog.
+   */
+  var inspect = function () {
+    // Copyright Joyent, Inc. and other Node contributors.
+    //
+    // 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.
+    //
+    // https://github.com/joyent/node/blob/master/lib/util.js
+
+    function inspect(obj, opts) {
+      var ctx = {
+        seen: [],
+        formatValueCalls: 0,
+        stylize: stylizeNoColor
+      };
+      return formatValue(ctx, obj, opts.depth);
+    }
+    function stylizeNoColor(str, styleType) {
+      return str;
+    }
+    function arrayToHash(array) {
+      var hash = {};
+      array.forEach(function (val, idx) {
+        hash[val] = true;
+      });
+      return hash;
+    }
+    function formatValue(ctx, value, recurseTimes) {
+      ctx.formatValueCalls++;
+      if (ctx.formatValueCalls > 200) {
+        return `[TOO BIG formatValueCalls ${ctx.formatValueCalls} exceeded limit of 200]`;
+      }
+
+      // Primitive types cannot have properties
+      var primitive = formatPrimitive(ctx, value);
+      if (primitive) {
+        return primitive;
+      }
+
+      // Look up the keys of the object.
+      var keys = Object.keys(value);
+      var visibleKeys = arrayToHash(keys);
+
+      // IE doesn't make error fields non-enumerable
+      // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
+      if (isError(value) && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
+        return formatError(value);
+      }
+
+      // Some type of object without properties can be shortcutted.
+      if (keys.length === 0) {
+        if (isFunction(value)) {
+          var name = value.name ? ': ' + value.name : '';
+          return ctx.stylize('[Function' + name + ']', 'special');
+        }
+        if (isRegExp(value)) {
+          return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+        }
+        if (isDate(value)) {
+          return ctx.stylize(Date.prototype.toString.call(value), 'date');
+        }
+        if (isError(value)) {
+          return formatError(value);
+        }
+      }
+      var base = '',
+        array = false,
+        braces = ['{', '}'];
+
+      // Make Array say that they are Array
+      if (isArray(value)) {
+        array = true;
+        braces = ['[', ']'];
+      }
+
+      // Make functions say that they are functions
+      if (isFunction(value)) {
+        var n = value.name ? ': ' + value.name : '';
+        base = ' [Function' + n + ']';
+      }
+
+      // Make RegExps say that they are RegExps
+      if (isRegExp(value)) {
+        base = ' ' + RegExp.prototype.toString.call(value);
+      }
+
+      // Make dates with properties first say the date
+      if (isDate(value)) {
+        base = ' ' + Date.prototype.toUTCString.call(value);
+      }
+
+      // Make error with message first say the error
+      if (isError(value)) {
+        base = ' ' + formatError(value);
+      }
+      if (keys.length === 0 && (!array || value.length == 0)) {
+        return braces[0] + base + braces[1];
+      }
+      if (recurseTimes < 0) {
+        if (isRegExp(value)) {
+          return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+        } else {
+          return ctx.stylize('[Object]', 'special');
+        }
+      }
+      ctx.seen.push(value);
+      var output;
+      if (array) {
+        output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+      } else {
+        output = keys.map(function (key) {
+          return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+        });
+      }
+      ctx.seen.pop();
+      return reduceToSingleString(output, base, braces);
+    }
+    function formatPrimitive(ctx, value) {
+      if (isUndefined(value)) return ctx.stylize('undefined', 'undefined');
+      if (isString(value)) {
+        var simple = "'" + JSON.stringify(value).replace(/^"|"$/g, '').replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
+        return ctx.stylize(simple, 'string');
+      }
+      if (isNumber(value)) return ctx.stylize('' + value, 'number');
+      if (isBoolean(value)) return ctx.stylize('' + value, 'boolean');
+      // For some reason typeof null is "object", so special case here.
+      if (isNull(value)) return ctx.stylize('null', 'null');
+    }
+    function formatError(value) {
+      return '[' + Error.prototype.toString.call(value) + ']';
+    }
+    function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+      var output = [];
+      for (var i = 0, l = value.length; i < l; ++i) {
+        if (hasOwnProperty(value, String(i))) {
+          output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true));
+        } else {
+          output.push('');
+        }
+      }
+      keys.forEach(function (key) {
+        if (!key.match(/^\d+$/)) {
+          output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, key, true));
+        }
+      });
+      return output;
+    }
+    function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+      var name, str, desc;
+      desc = Object.getOwnPropertyDescriptor(value, key) || {
+        value: value[key]
+      };
+      if (desc.get) {
+        if (desc.set) {
+          str = ctx.stylize('[Getter/Setter]', 'special');
+        } else {
+          str = ctx.stylize('[Getter]', 'special');
+        }
+      } else {
+        if (desc.set) {
+          str = ctx.stylize('[Setter]', 'special');
+        }
+      }
+      if (!hasOwnProperty(visibleKeys, key)) {
+        name = '[' + key + ']';
+      }
+      if (!str) {
+        if (ctx.seen.indexOf(desc.value) < 0) {
+          if (isNull(recurseTimes)) {
+            str = formatValue(ctx, desc.value, null);
+          } else {
+            str = formatValue(ctx, desc.value, recurseTimes - 1);
+          }
+          if (str.indexOf('\n') > -1) {
+            if (array) {
+              str = str.split('\n').map(function (line) {
+                return '  ' + line;
+              }).join('\n').slice(2);
+            } else {
+              str = '\n' + str.split('\n').map(function (line) {
+                return '   ' + line;
+              }).join('\n');
+            }
+          }
+        } else {
+          str = ctx.stylize('[Circular]', 'special');
+        }
+      }
+      if (isUndefined(name)) {
+        if (array && key.match(/^\d+$/)) {
+          return str;
+        }
+        name = JSON.stringify('' + key);
+        if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+          name = name.slice(1, name.length - 1);
+          name = ctx.stylize(name, 'name');
+        } else {
+          name = name.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
+          name = ctx.stylize(name, 'string');
+        }
+      }
+      return name + ': ' + str;
+    }
+    function reduceToSingleString(output, base, braces) {
+      var numLinesEst = 0;
+      var length = output.reduce(function (prev, cur) {
+        numLinesEst++;
+        if (cur.indexOf('\n') >= 0) numLinesEst++;
+        return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
+      }, 0);
+      if (length > 60) {
+        return braces[0] + (base === '' ? '' : base + '\n ') + ' ' + output.join(',\n  ') + ' ' + braces[1];
+      }
+      return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+    }
+
+    // NOTE: These type checking functions intentionally don't use `instanceof`
+    // because it is fragile and can be easily faked with `Object.create()`.
+    function isArray(ar) {
+      return Array.isArray(ar);
+    }
+    function isBoolean(arg) {
+      return typeof arg === 'boolean';
+    }
+    function isNull(arg) {
+      return arg === null;
+    }
+    function isNullOrUndefined(arg) {
+      return arg == null;
+    }
+    function isNumber(arg) {
+      return typeof arg === 'number';
+    }
+    function isString(arg) {
+      return typeof arg === 'string';
+    }
+    function isSymbol(arg) {
+      return typeof arg === 'symbol';
+    }
+    function isUndefined(arg) {
+      return arg === void 0;
+    }
+    function isRegExp(re) {
+      return isObject(re) && objectToString(re) === '[object RegExp]';
+    }
+    function isObject(arg) {
+      return typeof arg === 'object' && arg !== null;
+    }
+    function isDate(d) {
+      return isObject(d) && objectToString(d) === '[object Date]';
+    }
+    function isError(e) {
+      return isObject(e) && (objectToString(e) === '[object Error]' || e instanceof Error);
+    }
+    function isFunction(arg) {
+      return typeof arg === 'function';
+    }
+    function objectToString(o) {
+      return Object.prototype.toString.call(o);
+    }
+    function hasOwnProperty(obj, prop) {
+      return Object.prototype.hasOwnProperty.call(obj, prop);
+    }
+    return inspect;
+  }();
+  var INDEX_COLUMN_NAME = '(index)';
+  var LOG_LEVELS = {
+    trace: 0,
+    info: 1,
+    warn: 2,
+    error: 3
+  };
+  function getNativeLogFunction(level) {
+    return function () {
+      var str;
+      if (arguments.length === 1 && typeof arguments[0] === 'string') {
+        str = arguments[0];
+      } else {
+        str = Array.prototype.map.call(arguments, function (arg) {
+          return inspect(arg, {
+            depth: 10
+          });
+        }).join(', ');
+      }
+
+      // TRICKY
+      // If more than one argument is provided, the code above collapses them all
+      // into a single formatted string. This transform wraps string arguments in
+      // single quotes (e.g. "foo" -> "'foo'") which then breaks the "Warning:"
+      // check below. So it's important that we look at the first argument, rather
+      // than the formatted argument string.
+      var firstArg = arguments[0];
+      var logLevel = level;
+      if (typeof firstArg === 'string' && firstArg.slice(0, 9) === 'Warning: ' && logLevel >= LOG_LEVELS.error) {
+        // React warnings use console.error so that a stack trace is shown,
+        // but we don't (currently) want these to show a redbox
+        // (Note: Logic duplicated in ExceptionsManager.js.)
+        logLevel = LOG_LEVELS.warn;
+      }
+      if (groupStack.length) {
+        str = groupFormat('', str);
+      }
+      global.nativeLoggingHook(str, logLevel);
+    };
+  }
+  function repeat(element, n) {
+    return Array.apply(null, Array(n)).map(function () {
+      return element;
+    });
+  }
+  function formatCellValue(cell, key) {
+    if (key === INDEX_COLUMN_NAME) {
+      return cell[key];
+    }
+    if (cell.hasOwnProperty(key)) {
+      var cellValue = cell[key];
+      switch (typeof cellValue) {
+        case 'function':
+          return 'ƒ';
+        case 'string':
+          return "'" + cellValue + "'";
+        case 'object':
+          return cellValue == null ? 'null' : '{…}';
+      }
+      return String(cellValue);
+    }
+    return '';
+  }
+  function consoleTablePolyfill(data, columns) {
+    var rows;
+
+    // convert object -> array
+    if (Array.isArray(data)) {
+      rows = data.map(function (row, index) {
+        var processedRow = {};
+        processedRow[INDEX_COLUMN_NAME] = String(index);
+        Object.assign(processedRow, row);
+        return processedRow;
+      });
+    } else {
+      rows = [];
+      for (var key in data) {
+        if (data.hasOwnProperty(key)) {
+          var processedRow = {};
+          processedRow[INDEX_COLUMN_NAME] = key;
+          Object.assign(processedRow, data[key]);
+          rows.push(processedRow);
+        }
+      }
+    }
+    if (rows.length === 0) {
+      global.nativeLoggingHook('', LOG_LEVELS.info);
+      return;
+    }
+    if (Array.isArray(columns)) {
+      columns = [INDEX_COLUMN_NAME].concat(columns);
+    } else {
+      columns = Array.from(rows.reduce(function (columnSet, row) {
+        Object.keys(row).forEach(function (key) {
+          return columnSet.add(key);
+        });
+        return columnSet;
+      }, new Set()));
+    }
+    var stringRows = [];
+    var columnWidths = [];
+
+    // Convert each cell to a string. Also
+    // figure out max cell width for each column
+    columns.forEach(function (k, i) {
+      columnWidths[i] = k.length;
+      for (var j = 0; j < rows.length; j++) {
+        var cellStr = formatCellValue(rows[j], k);
+        stringRows[j] = stringRows[j] || [];
+        stringRows[j][i] = cellStr;
+        columnWidths[i] = Math.max(columnWidths[i], cellStr.length);
+      }
+    });
+
+    // Join all elements in the row into a single string with | separators
+    // (appends extra spaces to each cell to make separators  | aligned)
+    function joinRow(row, space) {
+      var cells = row.map(function (cell, i) {
+        var extraSpaces = repeat(' ', columnWidths[i] - cell.length).join('');
+        return cell + extraSpaces;
+      });
+      space = space || ' ';
+      return '| ' + cells.join(space + '|' + space) + ' |';
+    }
+    var separators = columnWidths.map(function (columnWidth) {
+      return repeat('-', columnWidth).join('');
+    });
+    var separatorRow = joinRow(separators);
+    var header = joinRow(columns);
+    var table = [header, separatorRow];
+    for (var i = 0; i < rows.length; i++) {
+      table.push(joinRow(stringRows[i]));
+    }
+
+    // Notice extra empty line at the beginning.
+    // Native logging hook adds "RCTLog >" at the front of every
+    // logged string, which would shift the header and screw up
+    // the table
+    global.nativeLoggingHook('\n' + table.join('\n'), LOG_LEVELS.info);
+  }
+  var GROUP_PAD = "\u2502"; // Box light vertical
+  var GROUP_OPEN = "\u2510"; // Box light down+left
+  var GROUP_CLOSE = "\u2518"; // Box light up+left
+
+  var groupStack = [];
+  function groupFormat(prefix, msg) {
+    // Insert group formatting before the console message
+    return groupStack.join('') + prefix + ' ' + (msg || '');
+  }
+  function consoleGroupPolyfill(label) {
+    global.nativeLoggingHook(groupFormat(GROUP_OPEN, label), LOG_LEVELS.info);
+    groupStack.push(GROUP_PAD);
+  }
+  function consoleGroupCollapsedPolyfill(label) {
+    global.nativeLoggingHook(groupFormat(GROUP_CLOSE, label), LOG_LEVELS.info);
+    groupStack.push(GROUP_PAD);
+  }
+  function consoleGroupEndPolyfill() {
+    groupStack.pop();
+    global.nativeLoggingHook(groupFormat(GROUP_CLOSE), LOG_LEVELS.info);
+  }
+  function consoleAssertPolyfill(expression, label) {
+    if (!expression) {
+      global.nativeLoggingHook('Assertion failed: ' + label, LOG_LEVELS.error);
+    }
+  }
+  if (global.nativeLoggingHook) {
+    var originalConsole = global.console;
+    // Preserve the original `console` as `originalConsole`
+    if (__DEV__ && originalConsole) {
+      var descriptor = Object.getOwnPropertyDescriptor(global, 'console');
+      if (descriptor) {
+        Object.defineProperty(global, 'originalConsole', descriptor);
+      }
+    }
+    global.console = Object.assign({}, originalConsole != null ? originalConsole : {}, {
+      error: getNativeLogFunction(LOG_LEVELS.error),
+      info: getNativeLogFunction(LOG_LEVELS.info),
+      log: getNativeLogFunction(LOG_LEVELS.info),
+      warn: getNativeLogFunction(LOG_LEVELS.warn),
+      trace: getNativeLogFunction(LOG_LEVELS.trace),
+      debug: getNativeLogFunction(LOG_LEVELS.trace),
+      table: consoleTablePolyfill,
+      group: consoleGroupPolyfill,
+      groupEnd: consoleGroupEndPolyfill,
+      groupCollapsed: consoleGroupCollapsedPolyfill,
+      assert: consoleAssertPolyfill
+    });
+
+    // TODO(T206796580): This was copy-pasted from ExceptionsManager.js
+    // Delete the copy there after the c++ pipeline is rolled out everywhere.
+    if (global.RN$useAlwaysAvailableJSErrorHandling === true) {
+      var stringifySafe = function stringifySafe(arg) {
+        return inspect(arg, {
+          depth: 10
+        }).replace(/\n\s*/g, ' ');
+      };
+      var originalConsoleError = console.error;
+      console.reportErrorsAsExceptions = true;
+      console.error = function () {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        originalConsoleError.apply(this, args);
+        if (!console.reportErrorsAsExceptions) {
+          return;
+        }
+        if (global.RN$inExceptionHandler != null && global.RN$inExceptionHandler()) {
+          return;
+        }
+        var error;
+        var firstArg = args[0];
+        if (firstArg != null && firstArg.stack) {
+          // RN$handleException will console.error this with high enough fidelity.
+          error = firstArg;
+        } else {
+          if (typeof firstArg === 'string' && firstArg.startsWith('Warning: ')) {
+            // React warnings use console.error so that a stack trace is shown, but
+            // we don't (currently) want these to show a redbox
+            return;
+          }
+          var message = args.map(function (arg) {
+            return typeof arg === 'string' ? arg : stringifySafe(arg);
+          }).join(' ');
+          error = new Error(message);
+          error.name = 'console.error';
+        }
+        var isFatal = false;
+        var reportToConsole = false;
+        global.RN$handleException(error, isFatal, reportToConsole);
+      };
+    }
+    Object.defineProperty(console, '_isPolyfilled', {
+      value: true,
+      enumerable: false
+    });
+
+    // If available, also call the original `console` method since that is
+    // sometimes useful. Ex: on OS X, this will let you see rich output in
+    // the Safari Web Inspector console.
+    if (__DEV__ && originalConsole) {
+      Object.keys(console).forEach(function (methodName) {
+        var reactNativeMethod = console[methodName];
+        if (originalConsole[methodName] && reactNativeMethod !== originalConsole[methodName]) {
+          console[methodName] = function () {
+            originalConsole[methodName].apply(originalConsole, arguments);
+            reactNativeMethod.apply(console, arguments);
+          };
+        }
+      });
+
+      // The following methods are not supported by this polyfill but
+      // we still should pass them to original console if they are
+      // supported by it.
+      ['clear', 'dir', 'dirxml', 'profile', 'profileEnd'].forEach(function (methodName) {
+        if (typeof originalConsole[methodName] === 'function') {
+          console[methodName] = function () {
+            originalConsole[methodName].apply(originalConsole, arguments);
+          };
+        }
+      });
+    }
+  } else if (!global.console) {
+    var stub = function stub() {};
+    var log = global.print || stub;
+    global.console = {
+      debug: log,
+      error: log,
+      info: log,
+      log: log,
+      trace: log,
+      warn: log,
+      assert: function assert(expression, label) {
+        if (!expression) {
+          log('Assertion failed: ' + label);
+        }
+      },
+      clear: stub,
+      dir: stub,
+      dirxml: stub,
+      group: stub,
+      groupCollapsed: stub,
+      groupEnd: stub,
+      profile: stub,
+      profileEnd: stub,
+      table: stub
+    };
+    Object.defineProperty(console, '_isPolyfilled', {
+      value: true,
+      enumerable: false
+    });
+  }
+})(typeof globalThis !== 'undefined' ? globalThis : typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : this);
+(function (global) {
+  var _inGuard = 0;
+  var _globalHandler = global.RN$useAlwaysAvailableJSErrorHandling === true ? global.RN$handleException : function (e, isFatal) {
+    throw e;
+  };
+  var ErrorUtils = {
+    setGlobalHandler: function setGlobalHandler(fun) {
+      _globalHandler = fun;
+    },
+    getGlobalHandler: function getGlobalHandler() {
+      return _globalHandler;
+    },
+    reportError: function reportError(error) {
+      _globalHandler && _globalHandler(error, false);
+    },
+    reportFatalError: function reportFatalError(error) {
+      _globalHandler && _globalHandler(error, true);
+    },
+    applyWithGuard: function applyWithGuard(fun, context, args, unused_onError, unused_name) {
+      try {
+        _inGuard++;
+        return fun.apply(context, args);
+      } catch (e) {
+        ErrorUtils.reportError(e);
+      } finally {
+        _inGuard--;
+      }
+      return null;
+    },
+    applyWithGuardIfNeeded: function applyWithGuardIfNeeded(fun, context, args) {
+      if (ErrorUtils.inGuard()) {
+        return fun.apply(context, args);
+      } else {
+        ErrorUtils.applyWithGuard(fun, context, args);
+      }
+      return null;
+    },
+    inGuard: function inGuard() {
+      return !!_inGuard;
+    },
+    guard: function guard(fun, name, context) {
+      var _ref;
+      if (typeof fun !== 'function') {
+        console.warn('A function must be passed to ErrorUtils.guard, got ', fun);
+        return null;
+      }
+      var guardName = (_ref = name != null ? name : fun.name) != null ? _ref : '<generated guard>';
+      function guarded() {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        return ErrorUtils.applyWithGuard(fun, context != null ? context : this, args, null, guardName);
+      }
+      return guarded;
+    }
+  };
+  global.ErrorUtils = ErrorUtils;
+})(typeof globalThis !== 'undefined' ? globalThis : typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : this);
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  var _reactNative = _$$_REQUIRE(_dependencyMap[1], "react-native");
+  var _SandboxApp = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./SandboxApp"));
+  var _SandboxAppConvention = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./SandboxAppConvention"));
+  _reactNative.AppRegistry.registerComponent('SandboxApp', function () {
+    return _SandboxApp.default;
+  });
+  _reactNative.AppRegistry.registerComponent('SandboxAppConvention', function () {
+    return _SandboxAppConvention.default;
+  });
+},0,[1,2,597,601],"sandbox.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _interopRequireDefault(e) {
+    return e && e.__esModule ? e : {
+      "default": e
+    };
+  }
+  module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},1,[],"../../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+  'use client';
+
+  module.exports = {
+    get ActivityIndicator() {
+      return _$$_REQUIRE(_dependencyMap[0], "./Libraries/Components/ActivityIndicator/ActivityIndicator").default;
+    },
+    get Button() {
+      return _$$_REQUIRE(_dependencyMap[1], "./Libraries/Components/Button").default;
+    },
+    get DrawerLayoutAndroid() {
+      return _$$_REQUIRE(_dependencyMap[2], "./Libraries/Components/DrawerAndroid/DrawerLayoutAndroid").default;
+    },
+    get FlatList() {
+      return _$$_REQUIRE(_dependencyMap[3], "./Libraries/Lists/FlatList").default;
+    },
+    get Image() {
+      return _$$_REQUIRE(_dependencyMap[4], "./Libraries/Image/Image").default;
+    },
+    get ImageBackground() {
+      return _$$_REQUIRE(_dependencyMap[5], "./Libraries/Image/ImageBackground").default;
+    },
+    get InputAccessoryView() {
+      return _$$_REQUIRE(_dependencyMap[6], "./Libraries/Components/TextInput/InputAccessoryView").default;
+    },
+    get KeyboardAvoidingView() {
+      return _$$_REQUIRE(_dependencyMap[7], "./Libraries/Components/Keyboard/KeyboardAvoidingView").default;
+    },
+    get experimental_LayoutConformance() {
+      return _$$_REQUIRE(_dependencyMap[8], "./Libraries/Components/LayoutConformance/LayoutConformance").default;
+    },
+    get Modal() {
+      return _$$_REQUIRE(_dependencyMap[9], "./Libraries/Modal/Modal").default;
+    },
+    get Pressable() {
+      return _$$_REQUIRE(_dependencyMap[10], "./Libraries/Components/Pressable/Pressable").default;
+    },
+    get ProgressBarAndroid() {
+      _$$_REQUIRE(_dependencyMap[11], "./Libraries/Utilities/warnOnce").default('progress-bar-android-moved', 'ProgressBarAndroid has been extracted from react-native core and will be removed in a future release. ' + "It can now be installed and imported from '@react-native-community/progress-bar-android' instead of 'react-native'. " + 'See https://github.com/react-native-progress-view/progress-bar-android');
+      return _$$_REQUIRE(_dependencyMap[12], "./Libraries/Components/ProgressBarAndroid/ProgressBarAndroid").default;
+    },
+    get RefreshControl() {
+      return _$$_REQUIRE(_dependencyMap[13], "./Libraries/Components/RefreshControl/RefreshControl").default;
+    },
+    get SafeAreaView() {
+      return _$$_REQUIRE(_dependencyMap[14], "./Libraries/Components/SafeAreaView/SafeAreaView").default;
+    },
+    get ScrollView() {
+      return _$$_REQUIRE(_dependencyMap[15], "./Libraries/Components/ScrollView/ScrollView").default;
+    },
+    get SectionList() {
+      return _$$_REQUIRE(_dependencyMap[16], "./Libraries/Lists/SectionList").default;
+    },
+    get StatusBar() {
+      return _$$_REQUIRE(_dependencyMap[17], "./Libraries/Components/StatusBar/StatusBar").default;
+    },
+    get Switch() {
+      return _$$_REQUIRE(_dependencyMap[18], "./Libraries/Components/Switch/Switch").default;
+    },
+    get Text() {
+      return _$$_REQUIRE(_dependencyMap[19], "./Libraries/Text/Text").default;
+    },
+    get TextInput() {
+      return _$$_REQUIRE(_dependencyMap[20], "./Libraries/Components/TextInput/TextInput").default;
+    },
+    get Touchable() {
+      return _$$_REQUIRE(_dependencyMap[21], "./Libraries/Components/Touchable/Touchable").default;
+    },
+    get TouchableHighlight() {
+      return _$$_REQUIRE(_dependencyMap[22], "./Libraries/Components/Touchable/TouchableHighlight").default;
+    },
+    get TouchableNativeFeedback() {
+      return _$$_REQUIRE(_dependencyMap[23], "./Libraries/Components/Touchable/TouchableNativeFeedback").default;
+    },
+    get TouchableOpacity() {
+      return _$$_REQUIRE(_dependencyMap[24], "./Libraries/Components/Touchable/TouchableOpacity").default;
+    },
+    get TouchableWithoutFeedback() {
+      return _$$_REQUIRE(_dependencyMap[25], "./Libraries/Components/Touchable/TouchableWithoutFeedback").default;
+    },
+    get View() {
+      return _$$_REQUIRE(_dependencyMap[26], "./Libraries/Components/View/View").default;
+    },
+    get VirtualizedList() {
+      return _$$_REQUIRE(_dependencyMap[27], "./Libraries/Lists/VirtualizedList").default;
+    },
+    get VirtualizedSectionList() {
+      return _$$_REQUIRE(_dependencyMap[28], "./Libraries/Lists/VirtualizedSectionList").default;
+    },
+    get AccessibilityInfo() {
+      return _$$_REQUIRE(_dependencyMap[29], "./Libraries/Components/AccessibilityInfo/AccessibilityInfo").default;
+    },
+    get ActionSheetIOS() {
+      return _$$_REQUIRE(_dependencyMap[30], "./Libraries/ActionSheetIOS/ActionSheetIOS").default;
+    },
+    get Alert() {
+      return _$$_REQUIRE(_dependencyMap[31], "./Libraries/Alert/Alert").default;
+    },
+    get Animated() {
+      return _$$_REQUIRE(_dependencyMap[32], "./Libraries/Animated/Animated").default;
+    },
+    get Appearance() {
+      return _$$_REQUIRE(_dependencyMap[33], "./Libraries/Utilities/Appearance");
+    },
+    get AppRegistry() {
+      return _$$_REQUIRE(_dependencyMap[34], "./Libraries/ReactNative/AppRegistry").AppRegistry;
+    },
+    get AppState() {
+      return _$$_REQUIRE(_dependencyMap[35], "./Libraries/AppState/AppState").default;
+    },
+    get BackHandler() {
+      return _$$_REQUIRE(_dependencyMap[36], "./Libraries/Utilities/BackHandler").default;
+    },
+    get Clipboard() {
+      _$$_REQUIRE(_dependencyMap[11], "./Libraries/Utilities/warnOnce").default('clipboard-moved', 'Clipboard has been extracted from react-native core and will be removed in a future release. ' + "It can now be installed and imported from '@react-native-clipboard/clipboard' instead of 'react-native'. " + 'See https://github.com/react-native-clipboard/clipboard');
+      return _$$_REQUIRE(_dependencyMap[37], "./Libraries/Components/Clipboard/Clipboard").default;
+    },
+    get codegenNativeCommands() {
+      return _$$_REQUIRE(_dependencyMap[38], "./Libraries/Utilities/codegenNativeCommands").default;
+    },
+    get codegenNativeComponent() {
+      return _$$_REQUIRE(_dependencyMap[39], "./Libraries/Utilities/codegenNativeComponent").default;
+    },
+    get DeviceEventEmitter() {
+      return _$$_REQUIRE(_dependencyMap[40], "./Libraries/EventEmitter/RCTDeviceEventEmitter").default;
+    },
+    get DeviceInfo() {
+      return _$$_REQUIRE(_dependencyMap[41], "./Libraries/Utilities/DeviceInfo").default;
+    },
+    get DevMenu() {
+      return _$$_REQUIRE(_dependencyMap[42], "./src/private/devsupport/devmenu/DevMenu").default;
+    },
+    get DevSettings() {
+      return _$$_REQUIRE(_dependencyMap[43], "./Libraries/Utilities/DevSettings").default;
+    },
+    get Dimensions() {
+      return _$$_REQUIRE(_dependencyMap[44], "./Libraries/Utilities/Dimensions").default;
+    },
+    get DynamicColorIOS() {
+      return _$$_REQUIRE(_dependencyMap[45], "./Libraries/StyleSheet/PlatformColorValueTypesIOS").DynamicColorIOS;
+    },
+    get Easing() {
+      return _$$_REQUIRE(_dependencyMap[46], "./Libraries/Animated/Easing").default;
+    },
+    get findNodeHandle() {
+      return _$$_REQUIRE(_dependencyMap[47], "./Libraries/ReactNative/RendererProxy").findNodeHandle;
+    },
+    get I18nManager() {
+      return _$$_REQUIRE(_dependencyMap[48], "./Libraries/ReactNative/I18nManager").default;
+    },
+    get InteractionManager() {
+      return _$$_REQUIRE(_dependencyMap[49], "./Libraries/Interaction/InteractionManager").default;
+    },
+    get Keyboard() {
+      return _$$_REQUIRE(_dependencyMap[50], "./Libraries/Components/Keyboard/Keyboard").default;
+    },
+    get LayoutAnimation() {
+      return _$$_REQUIRE(_dependencyMap[51], "./Libraries/LayoutAnimation/LayoutAnimation").default;
+    },
+    get Linking() {
+      return _$$_REQUIRE(_dependencyMap[52], "./Libraries/Linking/Linking").default;
+    },
+    get LogBox() {
+      return _$$_REQUIRE(_dependencyMap[53], "./Libraries/LogBox/LogBox").default;
+    },
+    get NativeAppEventEmitter() {
+      return _$$_REQUIRE(_dependencyMap[54], "./Libraries/EventEmitter/RCTNativeAppEventEmitter").default;
+    },
+    get NativeDialogManagerAndroid() {
+      return _$$_REQUIRE(_dependencyMap[55], "./Libraries/NativeModules/specs/NativeDialogManagerAndroid").default;
+    },
+    get NativeEventEmitter() {
+      return _$$_REQUIRE(_dependencyMap[56], "./Libraries/EventEmitter/NativeEventEmitter").default;
+    },
+    get NativeModules() {
+      return _$$_REQUIRE(_dependencyMap[57], "./Libraries/BatchedBridge/NativeModules").default;
+    },
+    get Networking() {
+      return _$$_REQUIRE(_dependencyMap[58], "./Libraries/Network/RCTNetworking").default;
+    },
+    get PanResponder() {
+      return _$$_REQUIRE(_dependencyMap[59], "./Libraries/Interaction/PanResponder").default;
+    },
+    get PermissionsAndroid() {
+      return _$$_REQUIRE(_dependencyMap[60], "./Libraries/PermissionsAndroid/PermissionsAndroid").default;
+    },
+    get PixelRatio() {
+      return _$$_REQUIRE(_dependencyMap[61], "./Libraries/Utilities/PixelRatio").default;
+    },
+    get Platform() {
+      return _$$_REQUIRE(_dependencyMap[62], "./Libraries/Utilities/Platform").default;
+    },
+    get PlatformColor() {
+      return _$$_REQUIRE(_dependencyMap[63], "./Libraries/StyleSheet/PlatformColorValueTypes").PlatformColor;
+    },
+    get PushNotificationIOS() {
+      _$$_REQUIRE(_dependencyMap[11], "./Libraries/Utilities/warnOnce").default('pushNotificationIOS-moved', 'PushNotificationIOS has been extracted from react-native core and will be removed in a future release. ' + "It can now be installed and imported from '@react-native-community/push-notification-ios' instead of 'react-native'. " + 'See https://github.com/react-native-push-notification/ios');
+      return _$$_REQUIRE(_dependencyMap[64], "./Libraries/PushNotificationIOS/PushNotificationIOS").default;
+    },
+    get processColor() {
+      return _$$_REQUIRE(_dependencyMap[65], "./Libraries/StyleSheet/processColor").default;
+    },
+    get registerCallableModule() {
+      return _$$_REQUIRE(_dependencyMap[66], "./Libraries/Core/registerCallableModule").default;
+    },
+    get requireNativeComponent() {
+      return _$$_REQUIRE(_dependencyMap[67], "./Libraries/ReactNative/requireNativeComponent").default;
+    },
+    get RootTagContext() {
+      return _$$_REQUIRE(_dependencyMap[68], "./Libraries/ReactNative/RootTag").RootTagContext;
+    },
+    get Settings() {
+      return _$$_REQUIRE(_dependencyMap[69], "./Libraries/Settings/Settings").default;
+    },
+    get Share() {
+      return _$$_REQUIRE(_dependencyMap[70], "./Libraries/Share/Share").default;
+    },
+    get StyleSheet() {
+      return _$$_REQUIRE(_dependencyMap[71], "./Libraries/StyleSheet/StyleSheet").default;
+    },
+    get Systrace() {
+      return _$$_REQUIRE(_dependencyMap[72], "./Libraries/Performance/Systrace");
+    },
+    get ToastAndroid() {
+      return _$$_REQUIRE(_dependencyMap[73], "./Libraries/Components/ToastAndroid/ToastAndroid").default;
+    },
+    get TurboModuleRegistry() {
+      return _$$_REQUIRE(_dependencyMap[74], "./Libraries/TurboModule/TurboModuleRegistry");
+    },
+    get UIManager() {
+      return _$$_REQUIRE(_dependencyMap[75], "./Libraries/ReactNative/UIManager").default;
+    },
+    get unstable_batchedUpdates() {
+      return _$$_REQUIRE(_dependencyMap[47], "./Libraries/ReactNative/RendererProxy").unstable_batchedUpdates;
+    },
+    get useAnimatedValue() {
+      return _$$_REQUIRE(_dependencyMap[76], "./Libraries/Animated/useAnimatedValue").default;
+    },
+    get useColorScheme() {
+      return _$$_REQUIRE(_dependencyMap[77], "./Libraries/Utilities/useColorScheme").default;
+    },
+    get useWindowDimensions() {
+      return _$$_REQUIRE(_dependencyMap[78], "./Libraries/Utilities/useWindowDimensions").default;
+    },
+    get UTFSequence() {
+      return _$$_REQUIRE(_dependencyMap[79], "./Libraries/UTFSequence").default;
+    },
+    get Vibration() {
+      return _$$_REQUIRE(_dependencyMap[80], "./Libraries/Vibration/Vibration").default;
+    }
+  };
+  if (__DEV__) {
+    Object.defineProperty(module.exports, 'AsyncStorage', {
+      configurable: true,
+      get: function get() {
+        _$$_REQUIRE(_dependencyMap[81], "invariant")(false, 'AsyncStorage has been removed from react-native core. ' + "It can now be installed and imported from '@react-native-async-storage/async-storage' instead of 'react-native'. " + 'See https://github.com/react-native-async-storage/async-storage');
+      }
+    });
+    Object.defineProperty(module.exports, 'ImagePickerIOS', {
+      configurable: true,
+      get: function get() {
+        _$$_REQUIRE(_dependencyMap[81], "invariant")(false, 'ImagePickerIOS has been removed from React Native. ' + "Please upgrade to use either 'react-native-image-picker' or 'expo-image-picker'. " + "If you cannot upgrade to a different library, please install the deprecated '@react-native-community/image-picker-ios' package. " + 'See https://github.com/rnc-archive/react-native-image-picker-ios');
+      }
+    });
+    Object.defineProperty(module.exports, 'ProgressViewIOS', {
+      configurable: true,
+      get: function get() {
+        _$$_REQUIRE(_dependencyMap[81], "invariant")(false, 'ProgressViewIOS has been removed from react-native core. ' + "It can now be installed and imported from '@react-native-community/progress-view' instead of 'react-native'. " + 'See https://github.com/react-native-progress-view/progress-view');
+      }
+    });
+    Object.defineProperty(module.exports, 'DatePickerIOS', {
+      configurable: true,
+      get: function get() {
+        _$$_REQUIRE(_dependencyMap[81], "invariant")(false, 'DatePickerIOS has been removed from react-native core. ' + "It can now be installed and imported from '@react-native-community/datetimepicker' instead of 'react-native'. " + 'See https://github.com/react-native-datetimepicker/datetimepicker');
+      }
+    });
+    Object.defineProperty(module.exports, 'Slider', {
+      configurable: true,
+      get: function get() {
+        _$$_REQUIRE(_dependencyMap[81], "invariant")(false, 'Slider has been removed from react-native core. ' + "It can now be installed and imported from '@react-native-community/slider' instead of 'react-native'. " + 'See https://github.com/callstack/react-native-slider');
+      }
+    });
+  }
+},2,[3,528,531,446,355,533,534,538,542,544,549,46,524,465,385,387,472,551,556,352,561,563,483,529,530,339,71,567,568,539,569,268,442,283,302,220,494,572,105,319,17,575,576,288,16,578,411,106,380,407,434,435,370,153,242,272,221,33,253,579,581,10,68,60,584,57,276,320,360,216,587,6,28,590,31,79,592,593,535,182,594,32],"../../node_modules/react-native/index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../StyleSheet/StyleSheet"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../Utilities/Platform"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../View/View"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[5], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[6], "react/jsx-runtime");
+  var _excluded = ["animating", "color", "hidesWhenStopped", "onLayout", "size", "style"];
+  var _this = this,
+    _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Components/ActivityIndicator/ActivityIndicator.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var PlatformActivityIndicator = _Platform.default.OS === 'android' ? _$$_REQUIRE(_dependencyMap[7], "../ProgressBarAndroid/ProgressBarAndroid").default : _$$_REQUIRE(_dependencyMap[8], "./ActivityIndicatorViewNativeComponent").default;
+  var GRAY = '#999999';
+  var ActivityIndicator = function ActivityIndicator(_ref, forwardedRef) {
+    var _ref$animating = _ref.animating,
+      animating = _ref$animating === void 0 ? true : _ref$animating,
+      _ref$color = _ref.color,
+      color = _ref$color === void 0 ? _Platform.default.OS === 'ios' ? GRAY : null : _ref$color,
+      _ref$hidesWhenStopped = _ref.hidesWhenStopped,
+      hidesWhenStopped = _ref$hidesWhenStopped === void 0 ? true : _ref$hidesWhenStopped,
+      onLayout = _ref.onLayout,
+      _ref$size = _ref.size,
+      size = _ref$size === void 0 ? 'small' : _ref$size,
+      style = _ref.style,
+      restProps = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+    var sizeStyle;
+    var sizeProp;
+    switch (size) {
+      case 'small':
+        sizeStyle = styles.sizeSmall;
+        sizeProp = 'small';
+        break;
+      case 'large':
+        sizeStyle = styles.sizeLarge;
+        sizeProp = 'large';
+        break;
+      default:
+        sizeStyle = {
+          height: size,
+          width: size
+        };
+        break;
+    }
+    var nativeProps = Object.assign({
+      animating: animating,
+      color: color,
+      hidesWhenStopped: hidesWhenStopped
+    }, restProps, {
+      ref: forwardedRef,
+      style: sizeStyle,
+      size: sizeProp
+    });
+    var androidProps = {
+      styleAttr: 'Normal',
+      indeterminate: true
+    };
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+      onLayout: onLayout,
+      style: _StyleSheet.default.compose(styles.container, style),
+      children: _Platform.default.OS === 'android' ? /*#__PURE__*/(0, _jsxRuntime.jsx)(PlatformActivityIndicator, Object.assign({}, nativeProps, androidProps)) : /*#__PURE__*/(0, _jsxRuntime.jsx)(PlatformActivityIndicator, Object.assign({}, nativeProps))
+    });
+  };
+  var ActivityIndicatorWithRef = React.forwardRef(ActivityIndicator);
+  ActivityIndicatorWithRef.displayName = 'ActivityIndicator';
+  var styles = _StyleSheet.default.create({
+    container: {
+      alignItems: 'center',
+      justifyContent: 'center'
+    },
+    sizeSmall: {
+      width: 20,
+      height: 20
+    },
+    sizeLarge: {
+      width: 36,
+      height: 36
+    }
+  });
+  var _default = exports.default = ActivityIndicatorWithRef;
+},3,[1,4,6,68,71,73,171,524,526],"../../node_modules/react-native/Libraries/Components/ActivityIndicator/ActivityIndicator.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _objectWithoutProperties(e, t) {
+    if (null == e) return {};
+    var o,
+      r,
+      i = _$$_REQUIRE(_dependencyMap[0], "./objectWithoutPropertiesLoose.js")(e, t);
+    if (Object.getOwnPropertySymbols) {
+      var n = Object.getOwnPropertySymbols(e);
+      for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+    }
+    return i;
+  }
+  module.exports = _objectWithoutProperties, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},4,[5],"../../node_modules/@babel/runtime/helpers/objectWithoutProperties.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _objectWithoutPropertiesLoose(r, e) {
+    if (null == r) return {};
+    var t = {};
+    for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+      if (-1 !== e.indexOf(n)) continue;
+      t[n] = r[n];
+    }
+    return t;
+  }
+  module.exports = _objectWithoutPropertiesLoose, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},5,[],"../../node_modules/@babel/runtime/helpers/objectWithoutPropertiesLoose.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _default = exports.default = _$$_REQUIRE(_dependencyMap[0], "./StyleSheetExports").default;
+},6,[7],"../../node_modules/react-native/Libraries/StyleSheet/StyleSheet.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _composeStyles = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../src/private/styles/composeStyles"));
+  var _flattenStyle = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./flattenStyle"));
+  var hairlineWidth = _$$_REQUIRE(_dependencyMap[3], "../Utilities/PixelRatio").default.roundToNearestPixel(0.4);
+  if (hairlineWidth === 0) {
+    hairlineWidth = 1 / _$$_REQUIRE(_dependencyMap[3], "../Utilities/PixelRatio").default.get();
+  }
+  var absoluteFill = {
+    position: 'absolute',
+    left: 0,
+    right: 0,
+    top: 0,
+    bottom: 0
+  };
+  if (__DEV__) {
+    Object.freeze(absoluteFill);
+  }
+  var _default = exports.default = {
+    hairlineWidth: hairlineWidth,
+    absoluteFill: absoluteFill,
+    absoluteFillObject: absoluteFill,
+    compose: _composeStyles.default,
+    flatten: _flattenStyle.default,
+    setStyleAttributePreprocessor: function setStyleAttributePreprocessor(property, process) {
+      var _ReactNativeStyleAttr, _ReactNativeStyleAttr2;
+      var value;
+      if (_$$_REQUIRE(_dependencyMap[4], "../Components/View/ReactNativeStyleAttributes").default[property] === true) {
+        value = {
+          process: process
+        };
+      } else if (typeof _$$_REQUIRE(_dependencyMap[4], "../Components/View/ReactNativeStyleAttributes").default[property] === 'object') {
+        value = Object.assign({}, _$$_REQUIRE(_dependencyMap[4], "../Components/View/ReactNativeStyleAttributes").default[property], {
+          process: process
+        });
+      } else {
+        console.error(`${property} is not a valid style attribute`);
+        return;
+      }
+      if (__DEV__ && typeof value.process === 'function' && typeof ((_ReactNativeStyleAttr = _$$_REQUIRE(_dependencyMap[4], "../Components/View/ReactNativeStyleAttributes").default[property]) == null ? void 0 : _ReactNativeStyleAttr.process) === 'function' && value.process !== ((_ReactNativeStyleAttr2 = _$$_REQUIRE(_dependencyMap[4], "../Components/View/ReactNativeStyleAttributes").default[property]) == null ? void 0 : _ReactNativeStyleAttr2.process)) {
+        console.warn(`Overwriting ${property} style attribute preprocessor`);
+      }
+      _$$_REQUIRE(_dependencyMap[4], "../Components/View/ReactNativeStyleAttributes").default[property] = value;
+    },
+    create: function create(obj) {
+      if (__DEV__) {
+        for (var key in obj) {
+          if (obj[key]) {
+            Object.freeze(obj[key]);
+          }
+        }
+      }
+      return obj;
+    }
+  };
+},7,[1,8,9,10,51],"../../node_modules/react-native/Libraries/StyleSheet/StyleSheetExports.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = composeStyles;
+  /**
+   * 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.
+   *
+   * @format
+   */
+
+  /**
+   * Combines two styles such that `style2` will override any styles in `style1`.
+   * If either style is null or undefined, the other one is returned without
+   * allocating an array, saving allocations and enabling memoization.
+   */
+  function composeStyles(style1, style2) {
+    if (style1 == null) {
+      return style2;
+    }
+    if (style2 == null) {
+      return style1;
+    }
+    return [style1, style2];
+  }
+},8,[],"../../node_modules/react-native/src/private/styles/composeStyles.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  function flattenStyle(style) {
+    if (style === null || typeof style !== 'object') {
+      return undefined;
+    }
+    if (!Array.isArray(style)) {
+      return style;
+    }
+    var result = {};
+    for (var i = 0, styleLength = style.length; i < styleLength; ++i) {
+      var computedStyle = flattenStyle(style[i]);
+      if (computedStyle) {
+        for (var key in computedStyle) {
+          result[key] = computedStyle[key];
+        }
+      }
+    }
+    return result;
+  }
+  var _default = exports.default = flattenStyle;
+},9,[],"../../node_modules/react-native/Libraries/StyleSheet/flattenStyle.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var PixelRatio = /*#__PURE__*/function () {
+    function PixelRatio() {
+      (0, _classCallCheck2.default)(this, PixelRatio);
+    }
+    return (0, _createClass2.default)(PixelRatio, null, [{
+      key: "get",
+      value: function get() {
+        return _$$_REQUIRE(_dependencyMap[3], "./Dimensions").default.get('window').scale;
+      }
+    }, {
+      key: "getFontScale",
+      value: function getFontScale() {
+        return _$$_REQUIRE(_dependencyMap[3], "./Dimensions").default.get('window').fontScale || PixelRatio.get();
+      }
+    }, {
+      key: "getPixelSizeForLayoutSize",
+      value: function getPixelSizeForLayoutSize(layoutSize) {
+        return Math.round(layoutSize * PixelRatio.get());
+      }
+    }, {
+      key: "roundToNearestPixel",
+      value: function roundToNearestPixel(layoutSize) {
+        var ratio = PixelRatio.get();
+        return Math.round(layoutSize * ratio) / ratio;
+      }
+    }, {
+      key: "startDetecting",
+      value: function startDetecting() {}
+    }]);
+  }();
+  var _default = exports.default = PixelRatio;
+},10,[1,11,12,16],"../../node_modules/react-native/Libraries/Utilities/PixelRatio.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _classCallCheck(a, n) {
+    if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+  }
+  module.exports = _classCallCheck, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},11,[],"../../node_modules/@babel/runtime/helpers/classCallCheck.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _defineProperties(e, r) {
+    for (var t = 0; t < r.length; t++) {
+      var o = r[t];
+      o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _$$_REQUIRE(_dependencyMap[0], "./toPropertyKey.js")(o.key), o);
+    }
+  }
+  function _createClass(e, r, t) {
+    return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
+      writable: !1
+    }), e;
+  }
+  module.exports = _createClass, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},12,[13],"../../node_modules/@babel/runtime/helpers/createClass.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function toPropertyKey(t) {
+    var i = _$$_REQUIRE(_dependencyMap[0], "./toPrimitive.js")(t, "string");
+    return "symbol" == _$$_REQUIRE(_dependencyMap[1], "./typeof.js")["default"](i) ? i : i + "";
+  }
+  module.exports = toPropertyKey, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},13,[14,15],"../../node_modules/@babel/runtime/helpers/toPropertyKey.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function toPrimitive(t, r) {
+    if ("object" != _$$_REQUIRE(_dependencyMap[0], "./typeof.js")["default"](t) || !t) return t;
+    var e = t[Symbol.toPrimitive];
+    if (void 0 !== e) {
+      var i = e.call(t, r || "default");
+      if ("object" != _$$_REQUIRE(_dependencyMap[0], "./typeof.js")["default"](i)) return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === r ? String : Number)(t);
+  }
+  module.exports = toPrimitive, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},14,[15],"../../node_modules/@babel/runtime/helpers/toPrimitive.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _typeof(o) {
+    "@babel/helpers - typeof";
+
+    return module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+      return typeof o;
+    } : function (o) {
+      return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+    }, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof(o);
+  }
+  module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},15,[],"../../node_modules/@babel/runtime/helpers/typeof.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _RCTDeviceEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../EventEmitter/RCTDeviceEventEmitter"));
+  var _EventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../vendor/emitter/EventEmitter"));
+  var _NativeDeviceInfo = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./NativeDeviceInfo"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "invariant"));
+  var eventEmitter = new _EventEmitter.default();
+  var dimensionsInitialized = false;
+  var dimensions;
+  var Dimensions = /*#__PURE__*/function () {
+    function Dimensions() {
+      (0, _classCallCheck2.default)(this, Dimensions);
+    }
+    return (0, _createClass2.default)(Dimensions, null, [{
+      key: "get",
+      value: function get(dim) {
+        (0, _invariant.default)(dimensions[dim], 'No dimension set for key ' + dim);
+        return dimensions[dim];
+      }
+    }, {
+      key: "set",
+      value: function set(dims) {
+        var screen = dims.screen,
+          window = dims.window;
+        var windowPhysicalPixels = dims.windowPhysicalPixels;
+        if (windowPhysicalPixels) {
+          window = {
+            width: windowPhysicalPixels.width / windowPhysicalPixels.scale,
+            height: windowPhysicalPixels.height / windowPhysicalPixels.scale,
+            scale: windowPhysicalPixels.scale,
+            fontScale: windowPhysicalPixels.fontScale
+          };
+        }
+        var screenPhysicalPixels = dims.screenPhysicalPixels;
+        if (screenPhysicalPixels) {
+          screen = {
+            width: screenPhysicalPixels.width / screenPhysicalPixels.scale,
+            height: screenPhysicalPixels.height / screenPhysicalPixels.scale,
+            scale: screenPhysicalPixels.scale,
+            fontScale: screenPhysicalPixels.fontScale
+          };
+        } else if (screen == null) {
+          screen = window;
+        }
+        dimensions = {
+          window: window,
+          screen: screen
+        };
+        if (dimensionsInitialized) {
+          eventEmitter.emit('change', dimensions);
+        } else {
+          dimensionsInitialized = true;
+        }
+      }
+    }, {
+      key: "addEventListener",
+      value: function addEventListener(type, handler) {
+        (0, _invariant.default)(type === 'change', 'Trying to subscribe to unknown event: "%s"', type);
+        return eventEmitter.addListener(type, handler);
+      }
+    }]);
+  }();
+  _RCTDeviceEventEmitter.default.addListener('didUpdateDimensions', function (update) {
+    Dimensions.set(update);
+  });
+  Dimensions.set(_NativeDeviceInfo.default.getConstants().Dimensions);
+  var _default = exports.default = Dimensions;
+},16,[1,11,12,17,25,29,32],"../../node_modules/react-native/Libraries/Utilities/Dimensions.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _EventEmitter2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../vendor/emitter/EventEmitter"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  var RCTDeviceEventEmitterImpl = /*#__PURE__*/function (_EventEmitter) {
+    function RCTDeviceEventEmitterImpl() {
+      (0, _classCallCheck2.default)(this, RCTDeviceEventEmitterImpl);
+      return _callSuper(this, RCTDeviceEventEmitterImpl, arguments);
+    }
+    (0, _inherits2.default)(RCTDeviceEventEmitterImpl, _EventEmitter);
+    return (0, _createClass2.default)(RCTDeviceEventEmitterImpl, [{
+      key: "emit",
+      value: function emit(eventType) {
+        (0, _$$_REQUIRE(_dependencyMap[8], "../Performance/Systrace").beginEvent)(function () {
+          return `RCTDeviceEventEmitter.emit#${eventType}`;
+        });
+        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+          args[_key - 1] = arguments[_key];
+        }
+        _superPropGet(RCTDeviceEventEmitterImpl, "emit", this, 3)([eventType].concat(args));
+        (0, _$$_REQUIRE(_dependencyMap[8], "../Performance/Systrace").endEvent)();
+      }
+    }]);
+  }(_EventEmitter2.default);
+  var RCTDeviceEventEmitter = new RCTDeviceEventEmitterImpl();
+  Object.defineProperty(global, '__rctDeviceEventEmitter', {
+    configurable: true,
+    value: RCTDeviceEventEmitter
+  });
+  var _default = exports.default = RCTDeviceEventEmitter;
+},17,[1,11,12,18,20,21,23,25,28],"../../node_modules/react-native/Libraries/EventEmitter/RCTDeviceEventEmitter.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _possibleConstructorReturn(t, e) {
+    if (e && ("object" == _$$_REQUIRE(_dependencyMap[0], "./typeof.js")["default"](e) || "function" == typeof e)) return e;
+    if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
+    return _$$_REQUIRE(_dependencyMap[1], "./assertThisInitialized.js")(t);
+  }
+  module.exports = _possibleConstructorReturn, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},18,[15,19],"../../node_modules/@babel/runtime/helpers/possibleConstructorReturn.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _assertThisInitialized(e) {
+    if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    return e;
+  }
+  module.exports = _assertThisInitialized, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},19,[],"../../node_modules/@babel/runtime/helpers/assertThisInitialized.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _getPrototypeOf(t) {
+    return module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
+      return t.__proto__ || Object.getPrototypeOf(t);
+    }, module.exports.__esModule = true, module.exports["default"] = module.exports, _getPrototypeOf(t);
+  }
+  module.exports = _getPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},20,[],"../../node_modules/@babel/runtime/helpers/getPrototypeOf.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _get() {
+    return module.exports = _get = "undefined" != typeof Reflect && Reflect.get ? Reflect.get.bind() : function (e, t, r) {
+      var p = _$$_REQUIRE(_dependencyMap[0], "./superPropBase.js")(e, t);
+      if (p) {
+        var n = Object.getOwnPropertyDescriptor(p, t);
+        return n.get ? n.get.call(arguments.length < 3 ? e : r) : n.value;
+      }
+    }, module.exports.__esModule = true, module.exports["default"] = module.exports, _get.apply(null, arguments);
+  }
+  module.exports = _get, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},21,[22],"../../node_modules/@babel/runtime/helpers/get.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _superPropBase(t, o) {
+    for (; !{}.hasOwnProperty.call(t, o) && null !== (t = _$$_REQUIRE(_dependencyMap[0], "./getPrototypeOf.js")(t)););
+    return t;
+  }
+  module.exports = _superPropBase, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},22,[20],"../../node_modules/@babel/runtime/helpers/superPropBase.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _inherits(t, e) {
+    if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
+    t.prototype = Object.create(e && e.prototype, {
+      constructor: {
+        value: t,
+        writable: !0,
+        configurable: !0
+      }
+    }), Object.defineProperty(t, "prototype", {
+      writable: !1
+    }), e && _$$_REQUIRE(_dependencyMap[0], "./setPrototypeOf.js")(t, e);
+  }
+  module.exports = _inherits, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},23,[24],"../../node_modules/@babel/runtime/helpers/inherits.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _setPrototypeOf(t, e) {
+    return module.exports = _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+      return t.__proto__ = e, t;
+    }, module.exports.__esModule = true, module.exports["default"] = module.exports, _setPrototypeOf(t, e);
+  }
+  module.exports = _setPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},24,[],"../../node_modules/@babel/runtime/helpers/setPrototypeOf.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _classPrivateFieldLooseBase2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classPrivateFieldLooseBase"));
+  var _classPrivateFieldLooseKey2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classPrivateFieldLooseKey"));
+  var _registry = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("registry");
+  var EventEmitter = exports.default = /*#__PURE__*/function () {
+    function EventEmitter() {
+      (0, _classCallCheck2.default)(this, EventEmitter);
+      Object.defineProperty(this, _registry, {
+        writable: true,
+        value: void 0
+      });
+      (0, _classPrivateFieldLooseBase2.default)(this, _registry)[_registry] = {};
+    }
+    return (0, _createClass2.default)(EventEmitter, [{
+      key: "addListener",
+      value: function addListener(eventType, listener, context) {
+        if (typeof listener !== 'function') {
+          throw new TypeError('EventEmitter.addListener(...): 2nd argument must be a function.');
+        }
+        var registrations = allocate((0, _classPrivateFieldLooseBase2.default)(this, _registry)[_registry], eventType);
+        var registration = {
+          context: context,
+          listener: listener,
+          remove: function remove() {
+            registrations.delete(registration);
+          }
+        };
+        registrations.add(registration);
+        return registration;
+      }
+    }, {
+      key: "emit",
+      value: function emit(eventType) {
+        var registrations = (0, _classPrivateFieldLooseBase2.default)(this, _registry)[_registry][eventType];
+        if (registrations != null) {
+          for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+            args[_key - 1] = arguments[_key];
+          }
+          for (var registration of Array.from(registrations)) {
+            registration.listener.apply(registration.context, args);
+          }
+        }
+      }
+    }, {
+      key: "removeAllListeners",
+      value: function removeAllListeners(eventType) {
+        if (eventType == null) {
+          (0, _classPrivateFieldLooseBase2.default)(this, _registry)[_registry] = {};
+        } else {
+          delete (0, _classPrivateFieldLooseBase2.default)(this, _registry)[_registry][eventType];
+        }
+      }
+    }, {
+      key: "listenerCount",
+      value: function listenerCount(eventType) {
+        var registrations = (0, _classPrivateFieldLooseBase2.default)(this, _registry)[_registry][eventType];
+        return registrations == null ? 0 : registrations.size;
+      }
+    }]);
+  }();
+  function allocate(registry, eventType) {
+    var registrations = registry[eventType];
+    if (registrations == null) {
+      registrations = new Set();
+      registry[eventType] = registrations;
+    }
+    return registrations;
+  }
+},25,[1,11,12,26,27],"../../node_modules/react-native/Libraries/vendor/emitter/EventEmitter.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _classPrivateFieldBase(e, t) {
+    if (!{}.hasOwnProperty.call(e, t)) throw new TypeError("attempted to use private field on non-instance");
+    return e;
+  }
+  module.exports = _classPrivateFieldBase, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},26,[],"../../node_modules/@babel/runtime/helpers/classPrivateFieldLooseBase.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var id = 0;
+  function _classPrivateFieldKey(e) {
+    return "__private_" + id++ + "_" + e;
+  }
+  module.exports = _classPrivateFieldKey, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},27,[],"../../node_modules/@babel/runtime/helpers/classPrivateFieldLooseKey.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.beginAsyncEvent = beginAsyncEvent;
+  exports.beginEvent = beginEvent;
+  exports.counterEvent = counterEvent;
+  exports.endAsyncEvent = endAsyncEvent;
+  exports.endEvent = endEvent;
+  exports.isEnabled = isEnabled;
+  exports.setEnabled = setEnabled;
+  var TRACE_TAG_REACT = 1 << 13;
+  var _asyncCookie = 0;
+  function isEnabled() {
+    return global.nativeTraceIsTracing ? global.nativeTraceIsTracing(TRACE_TAG_REACT) : Boolean(global.__RCTProfileIsProfiling);
+  }
+  function setEnabled(_doEnable) {}
+  function beginEvent(eventName, args) {
+    if (isEnabled()) {
+      var eventNameString = typeof eventName === 'function' ? eventName() : eventName;
+      global.nativeTraceBeginSection(TRACE_TAG_REACT, eventNameString, args);
+    }
+  }
+  function endEvent(args) {
+    if (isEnabled()) {
+      global.nativeTraceEndSection(TRACE_TAG_REACT, args);
+    }
+  }
+  function beginAsyncEvent(eventName, args) {
+    var cookie = _asyncCookie;
+    if (isEnabled()) {
+      _asyncCookie++;
+      var eventNameString = typeof eventName === 'function' ? eventName() : eventName;
+      global.nativeTraceBeginAsyncSection(TRACE_TAG_REACT, eventNameString, cookie, args);
+    }
+    return cookie;
+  }
+  function endAsyncEvent(eventName, cookie, args) {
+    if (isEnabled()) {
+      var eventNameString = typeof eventName === 'function' ? eventName() : eventName;
+      global.nativeTraceEndAsyncSection(TRACE_TAG_REACT, eventNameString, cookie, args);
+    }
+  }
+  function counterEvent(eventName, value) {
+    if (isEnabled()) {
+      var eventNameString = typeof eventName === 'function' ? eventName() : eventName;
+      global.nativeTraceCounter && global.nativeTraceCounter(TRACE_TAG_REACT, eventNameString, value);
+    }
+  }
+  if (__DEV__) {
+    var Systrace = {
+      isEnabled: isEnabled,
+      setEnabled: setEnabled,
+      beginEvent: beginEvent,
+      endEvent: endEvent,
+      beginAsyncEvent: beginAsyncEvent,
+      endAsyncEvent: endAsyncEvent,
+      counterEvent: counterEvent
+    };
+    global[(global.__METRO_GLOBAL_PREFIX__ || '') + '__SYSTRACE'] = Systrace;
+  }
+},28,[],"../../node_modules/react-native/Libraries/Performance/Systrace.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeDeviceInfo = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativeDeviceInfo"));
+  Object.keys(_NativeDeviceInfo).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeDeviceInfo[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeDeviceInfo[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeDeviceInfo.default;
+},29,[30],"../../node_modules/react-native/Libraries/Utilities/NativeDeviceInfo.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var NativeModule = TurboModuleRegistry.getEnforcing('DeviceInfo');
+  var constants = null;
+  var NativeDeviceInfo = {
+    getConstants: function getConstants() {
+      if (constants == null) {
+        constants = NativeModule.getConstants();
+      }
+      return constants;
+    }
+  };
+  var _default = exports.default = NativeDeviceInfo;
+},30,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeDeviceInfo.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.get = get;
+  exports.getEnforcing = getEnforcing;
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "invariant"));
+  var turboModuleProxy = global.__turboModuleProxy;
+  function requireModule(name) {
+    if (turboModuleProxy != null) {
+      var module = turboModuleProxy(name);
+      if (module != null) {
+        return module;
+      }
+    }
+    if (global.RN$Bridgeless !== true || global.RN$TurboInterop === true || global.RN$UnifiedNativeModuleProxy === true) {
+      var legacyModule = _$$_REQUIRE(_dependencyMap[2], "../BatchedBridge/NativeModules").default[name];
+      if (legacyModule != null) {
+        return legacyModule;
+      }
+    }
+    return null;
+  }
+  function get(name) {
+    return requireModule(name);
+  }
+  function getEnforcing(name) {
+    var module = requireModule(name);
+    (0, _invariant.default)(module != null, `TurboModuleRegistry.getEnforcing(...): '${name}' could not be found. ` + 'Verify that a module by this name is registered in the native binary.');
+    return module;
+  }
+},31,[1,32,33],"../../node_modules/react-native/Libraries/TurboModule/TurboModuleRegistry.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  /**
+   * Copyright (c) 2013-present, Facebook, Inc.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+
+  'use strict';
+
+  /**
+   * Use invariant() to assert state which your program assumes to be true.
+   *
+   * Provide sprintf-style format (only %s is supported) and arguments
+   * to provide information about what broke and what you were
+   * expecting.
+   *
+   * The invariant message will be stripped in production, but the invariant
+   * will remain to ensure logic does not differ in production.
+   */
+  var invariant = function invariant(condition, format, a, b, c, d, e, f) {
+    if (process.env.NODE_ENV !== 'production') {
+      if (format === undefined) {
+        throw new Error('invariant requires an error message argument');
+      }
+    }
+    if (!condition) {
+      var error;
+      if (format === undefined) {
+        error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
+      } else {
+        var args = [a, b, c, d, e, f];
+        var argIndex = 0;
+        error = new Error(format.replace(/%s/g, function () {
+          return args[argIndex++];
+        }));
+        error.name = 'Invariant Violation';
+      }
+      error.framesToPop = 1; // we don't care about invariant's own frame
+      throw error;
+    }
+  };
+  module.exports = invariant;
+},32,[],"../../node_modules/invariant/browser.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  function genModule(config, moduleID) {
+    if (!config) {
+      return null;
+    }
+    var _config = (0, _slicedToArray2.default)(config, 5),
+      moduleName = _config[0],
+      constants = _config[1],
+      methods = _config[2],
+      promiseMethods = _config[3],
+      syncMethods = _config[4];
+    _$$_REQUIRE(_dependencyMap[2], "invariant")(!moduleName.startsWith('RCT') && !moduleName.startsWith('RK'), "Module name prefixes should've been stripped by the native side " + "but wasn't for " + moduleName);
+    if (!constants && !methods) {
+      return {
+        name: moduleName
+      };
+    }
+    var module = {};
+    methods && methods.forEach(function (methodName, methodID) {
+      var isPromise = promiseMethods && arrayContains(promiseMethods, methodID) || false;
+      var isSync = syncMethods && arrayContains(syncMethods, methodID) || false;
+      _$$_REQUIRE(_dependencyMap[2], "invariant")(!isPromise || !isSync, 'Cannot have a method that is both async and a sync hook');
+      var methodType = isPromise ? 'promise' : isSync ? 'sync' : 'async';
+      module[methodName] = genMethod(moduleID, methodID, methodType);
+    });
+    Object.assign(module, constants);
+    if (module.getConstants == null) {
+      module.getConstants = function () {
+        return constants || Object.freeze({});
+      };
+    } else {
+      console.warn(`Unable to define method 'getConstants()' on NativeModule '${moduleName}'. NativeModule '${moduleName}' already has a constant or method called 'getConstants'. Please remove it.`);
+    }
+    if (__DEV__) {
+      _$$_REQUIRE(_dependencyMap[3], "./BatchedBridge").default.createDebugLookup(moduleID, moduleName, methods);
+    }
+    return {
+      name: moduleName,
+      module: module
+    };
+  }
+  global.__fbGenNativeModule = genModule;
+  function loadModule(name, moduleID) {
+    _$$_REQUIRE(_dependencyMap[2], "invariant")(global.nativeRequireModuleConfig, "Can't lazily create module without nativeRequireModuleConfig");
+    var config = global.nativeRequireModuleConfig(name);
+    var info = genModule(config, moduleID);
+    return info && info.module;
+  }
+  function genMethod(moduleID, methodID, type) {
+    var fn = null;
+    if (type === 'promise') {
+      fn = function promiseMethodWrapper() {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        var enqueueingFrameError = new Error();
+        return new Promise(function (resolve, reject) {
+          _$$_REQUIRE(_dependencyMap[3], "./BatchedBridge").default.enqueueNativeCall(moduleID, methodID, args, function (data) {
+            return resolve(data);
+          }, function (errorData) {
+            return reject(updateErrorWithErrorData(errorData, enqueueingFrameError));
+          });
+        });
+      };
+    } else {
+      fn = function nonPromiseMethodWrapper() {
+        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+          args[_key2] = arguments[_key2];
+        }
+        var lastArg = args.length > 0 ? args[args.length - 1] : null;
+        var secondLastArg = args.length > 1 ? args[args.length - 2] : null;
+        var hasSuccessCallback = typeof lastArg === 'function';
+        var hasErrorCallback = typeof secondLastArg === 'function';
+        hasErrorCallback && _$$_REQUIRE(_dependencyMap[2], "invariant")(hasSuccessCallback, 'Cannot have a non-function arg after a function arg.');
+        var onSuccess = hasSuccessCallback ? lastArg : null;
+        var onFail = hasErrorCallback ? secondLastArg : null;
+        var callbackCount = hasSuccessCallback + hasErrorCallback;
+        var newArgs = args.slice(0, args.length - callbackCount);
+        if (type === 'sync') {
+          return _$$_REQUIRE(_dependencyMap[3], "./BatchedBridge").default.callNativeSyncHook(moduleID, methodID, newArgs, onFail, onSuccess);
+        } else {
+          _$$_REQUIRE(_dependencyMap[3], "./BatchedBridge").default.enqueueNativeCall(moduleID, methodID, newArgs, onFail, onSuccess);
+        }
+      };
+    }
+    fn.type = type;
+    return fn;
+  }
+  function arrayContains(array, value) {
+    return array.indexOf(value) !== -1;
+  }
+  function updateErrorWithErrorData(errorData, error) {
+    return Object.assign(error, errorData || {});
+  }
+  var NativeModules = {};
+  if (global.nativeModuleProxy) {
+    NativeModules = global.nativeModuleProxy;
+  } else {
+    var bridgeConfig = global.__fbBatchedBridgeConfig;
+    _$$_REQUIRE(_dependencyMap[2], "invariant")(bridgeConfig, '__fbBatchedBridgeConfig is not set, cannot invoke native modules');
+    var defineLazyObjectProperty = _$$_REQUIRE(_dependencyMap[4], "../Utilities/defineLazyObjectProperty").default;
+    (bridgeConfig.remoteModuleConfig || []).forEach(function (config, moduleID) {
+      var info = genModule(config, moduleID);
+      if (!info) {
+        return;
+      }
+      if (info.module) {
+        NativeModules[info.name] = info.module;
+      } else {
+        defineLazyObjectProperty(NativeModules, info.name, {
+          get: function get() {
+            return loadModule(info.name, moduleID);
+          }
+        });
+      }
+    });
+  }
+  var _default = exports.default = NativeModules;
+},33,[1,34,32,40,50],"../../node_modules/react-native/Libraries/BatchedBridge/NativeModules.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _slicedToArray(r, e) {
+    return _$$_REQUIRE(_dependencyMap[0], "./arrayWithHoles.js")(r) || _$$_REQUIRE(_dependencyMap[1], "./iterableToArrayLimit.js")(r, e) || _$$_REQUIRE(_dependencyMap[2], "./unsupportedIterableToArray.js")(r, e) || _$$_REQUIRE(_dependencyMap[3], "./nonIterableRest.js")();
+  }
+  module.exports = _slicedToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},34,[35,36,37,39],"../../node_modules/@babel/runtime/helpers/slicedToArray.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _arrayWithHoles(r) {
+    if (Array.isArray(r)) return r;
+  }
+  module.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},35,[],"../../node_modules/@babel/runtime/helpers/arrayWithHoles.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _iterableToArrayLimit(r, l) {
+    var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+    if (null != t) {
+      var e,
+        n,
+        i,
+        u,
+        a = [],
+        f = !0,
+        o = !1;
+      try {
+        if (i = (t = t.call(r)).next, 0 === l) {
+          if (Object(t) !== t) return;
+          f = !1;
+        } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+      } catch (r) {
+        o = !0, n = r;
+      } finally {
+        try {
+          if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
+        } finally {
+          if (o) throw n;
+        }
+      }
+      return a;
+    }
+  }
+  module.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},36,[],"../../node_modules/@babel/runtime/helpers/iterableToArrayLimit.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _unsupportedIterableToArray(r, a) {
+    if (r) {
+      if ("string" == typeof r) return _$$_REQUIRE(_dependencyMap[0], "./arrayLikeToArray.js")(r, a);
+      var t = {}.toString.call(r).slice(8, -1);
+      return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _$$_REQUIRE(_dependencyMap[0], "./arrayLikeToArray.js")(r, a) : void 0;
+    }
+  }
+  module.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},37,[38],"../../node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _arrayLikeToArray(r, a) {
+    (null == a || a > r.length) && (a = r.length);
+    for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+    return n;
+  }
+  module.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},38,[],"../../node_modules/@babel/runtime/helpers/arrayLikeToArray.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  module.exports = _nonIterableRest, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},39,[],"../../node_modules/@babel/runtime/helpers/nonIterableRest.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var BatchedBridge = new (_$$_REQUIRE(_dependencyMap[0], "./MessageQueue").default)();
+  Object.defineProperty(global, '__fbBatchedBridge', {
+    configurable: true,
+    value: BatchedBridge
+  });
+  var _default = exports.default = BatchedBridge;
+},40,[41],"../../node_modules/react-native/Libraries/BatchedBridge/BatchedBridge.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _toConsumableArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/toConsumableArray"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+  var TO_JS = 0;
+  var TO_NATIVE = 1;
+  var MODULE_IDS = 0;
+  var METHOD_IDS = 1;
+  var PARAMS = 2;
+  var MIN_TIME_BETWEEN_FLUSHES_MS = 5;
+  var TRACE_TAG_REACT = 1 << 13;
+  var DEBUG_INFO_LIMIT = 32;
+  var MessageQueue = /*#__PURE__*/function () {
+    function MessageQueue() {
+      (0, _classCallCheck2.default)(this, MessageQueue);
+      this._lazyCallableModules = {};
+      this._queue = [[], [], [], 0];
+      this._successCallbacks = new Map();
+      this._failureCallbacks = new Map();
+      this._callID = 0;
+      this._lastFlush = 0;
+      this._eventLoopStartTime = Date.now();
+      this._reactNativeMicrotasksCallback = null;
+      if (__DEV__) {
+        this._debugInfo = {};
+        this._remoteModuleTable = {};
+        this._remoteMethodTable = {};
+      }
+      this.callFunctionReturnFlushedQueue = this.callFunctionReturnFlushedQueue.bind(this);
+      this.flushedQueue = this.flushedQueue.bind(this);
+      this.invokeCallbackAndReturnFlushedQueue = this.invokeCallbackAndReturnFlushedQueue.bind(this);
+    }
+    return (0, _createClass2.default)(MessageQueue, [{
+      key: "callFunctionReturnFlushedQueue",
+      value: function callFunctionReturnFlushedQueue(module, method, args) {
+        var _this = this;
+        this.__guard(function () {
+          _this.__callFunction(module, method, args);
+        });
+        return this.flushedQueue();
+      }
+    }, {
+      key: "invokeCallbackAndReturnFlushedQueue",
+      value: function invokeCallbackAndReturnFlushedQueue(cbID, args) {
+        var _this2 = this;
+        this.__guard(function () {
+          _this2.__invokeCallback(cbID, args);
+        });
+        return this.flushedQueue();
+      }
+    }, {
+      key: "flushedQueue",
+      value: function flushedQueue() {
+        var _this3 = this;
+        this.__guard(function () {
+          _this3.__callReactNativeMicrotasks();
+        });
+        var queue = this._queue;
+        this._queue = [[], [], [], this._callID];
+        return queue[0].length ? queue : null;
+      }
+    }, {
+      key: "getEventLoopRunningTime",
+      value: function getEventLoopRunningTime() {
+        return Date.now() - this._eventLoopStartTime;
+      }
+    }, {
+      key: "registerCallableModule",
+      value: function registerCallableModule(name, module) {
+        this._lazyCallableModules[name] = function () {
+          return module;
+        };
+      }
+    }, {
+      key: "registerLazyCallableModule",
+      value: function registerLazyCallableModule(name, factory) {
+        var module;
+        var getValue = factory;
+        this._lazyCallableModules[name] = function () {
+          if (getValue) {
+            module = getValue();
+            getValue = null;
+          }
+          return module;
+        };
+      }
+    }, {
+      key: "getCallableModule",
+      value: function getCallableModule(name) {
+        var getValue = this._lazyCallableModules[name];
+        return getValue ? getValue() : null;
+      }
+    }, {
+      key: "callNativeSyncHook",
+      value: function callNativeSyncHook(moduleID, methodID, params, onFail, onSucc) {
+        if (__DEV__) {
+          _$$_REQUIRE(_dependencyMap[4], "invariant")(global.nativeCallSyncHook, 'Calling synchronous methods on native ' + 'modules is not supported in Chrome.\n\n Consider providing alternative ' + 'methods to expose this method in debug mode, e.g. by exposing constants ' + 'ahead-of-time.');
+        }
+        this.processCallbacks(moduleID, methodID, params, onFail, onSucc);
+        return global.nativeCallSyncHook(moduleID, methodID, params);
+      }
+    }, {
+      key: "processCallbacks",
+      value: function processCallbacks(moduleID, methodID, params, onFail, onSucc) {
+        var _this4 = this;
+        if (onFail || onSucc) {
+          if (__DEV__) {
+            this._debugInfo[this._callID] = [moduleID, methodID];
+            if (this._callID > DEBUG_INFO_LIMIT) {
+              delete this._debugInfo[this._callID - DEBUG_INFO_LIMIT];
+            }
+            if (this._successCallbacks.size > 500) {
+              var info = {};
+              this._successCallbacks.forEach(function (_, callID) {
+                var debug = _this4._debugInfo[callID];
+                var module = debug && _this4._remoteModuleTable[debug[0]];
+                var method = debug && _this4._remoteMethodTable[debug[0]][debug[1]];
+                info[callID] = {
+                  module: module,
+                  method: method
+                };
+              });
+              _$$_REQUIRE(_dependencyMap[5], "../Utilities/warnOnce").default('excessive-number-of-pending-callbacks', `Excessive number of pending callbacks: ${this._successCallbacks.size}. Some pending callbacks that might have leaked by never being called from native code: ${_$$_REQUIRE(_dependencyMap[6], "../Utilities/stringifySafe").default(info)}`);
+            }
+          }
+          onFail && params.push(this._callID << 1);
+          onSucc && params.push(this._callID << 1 | 1);
+          this._successCallbacks.set(this._callID, onSucc);
+          this._failureCallbacks.set(this._callID, onFail);
+        }
+        if (__DEV__) {
+          global.nativeTraceBeginAsyncFlow && global.nativeTraceBeginAsyncFlow(TRACE_TAG_REACT, 'native', this._callID);
+        }
+        this._callID++;
+      }
+    }, {
+      key: "enqueueNativeCall",
+      value: function enqueueNativeCall(moduleID, methodID, params, onFail, onSucc) {
+        this.processCallbacks(moduleID, methodID, params, onFail, onSucc);
+        this._queue[MODULE_IDS].push(moduleID);
+        this._queue[METHOD_IDS].push(methodID);
+        if (__DEV__) {
+          var _isValidArgument = function isValidArgument(val) {
+            switch (typeof val) {
+              case 'undefined':
+              case 'boolean':
+              case 'string':
+                return true;
+              case 'number':
+                return isFinite(val);
+              case 'object':
+                if (val == null) {
+                  return true;
+                }
+                if (Array.isArray(val)) {
+                  return val.every(_isValidArgument);
+                }
+                for (var k in val) {
+                  if (typeof val[k] !== 'function' && !_isValidArgument(val[k])) {
+                    return false;
+                  }
+                }
+                return true;
+              case 'function':
+                return false;
+              default:
+                return false;
+            }
+          };
+          var replacer = function replacer(key, val) {
+            var t = typeof val;
+            if (t === 'function') {
+              return '<<Function ' + val.name + '>>';
+            } else if (t === 'number' && !isFinite(val)) {
+              return '<<' + val.toString() + '>>';
+            } else {
+              return val;
+            }
+          };
+          _$$_REQUIRE(_dependencyMap[4], "invariant")(_isValidArgument(params), '%s is not usable as a native method argument', JSON.stringify(params, replacer));
+          _$$_REQUIRE(_dependencyMap[7], "../Utilities/deepFreezeAndThrowOnMutationInDev").default(params);
+        }
+        this._queue[PARAMS].push(params);
+        var now = Date.now();
+        if (global.nativeFlushQueueImmediate && now - this._lastFlush >= MIN_TIME_BETWEEN_FLUSHES_MS) {
+          var queue = this._queue;
+          this._queue = [[], [], [], this._callID];
+          this._lastFlush = now;
+          global.nativeFlushQueueImmediate(queue);
+        }
+        _$$_REQUIRE(_dependencyMap[8], "../Performance/Systrace").counterEvent('pending_js_to_native_queue', this._queue[0].length);
+        if (__DEV__ && this.__spy && isFinite(moduleID)) {
+          this.__spy({
+            type: TO_NATIVE,
+            module: this._remoteModuleTable[moduleID],
+            method: this._remoteMethodTable[moduleID][methodID],
+            args: params
+          });
+        } else if (this.__spy) {
+          this.__spy({
+            type: TO_NATIVE,
+            module: moduleID + '',
+            method: methodID,
+            args: params
+          });
+        }
+      }
+    }, {
+      key: "createDebugLookup",
+      value: function createDebugLookup(moduleID, name, methods) {
+        if (__DEV__) {
+          this._remoteModuleTable[moduleID] = name;
+          this._remoteMethodTable[moduleID] = methods || [];
+        }
+      }
+    }, {
+      key: "setReactNativeMicrotasksCallback",
+      value: function setReactNativeMicrotasksCallback(fn) {
+        this._reactNativeMicrotasksCallback = fn;
+      }
+    }, {
+      key: "__guard",
+      value: function __guard(fn) {
+        if (this.__shouldPauseOnThrow()) {
+          fn();
+        } else {
+          try {
+            fn();
+          } catch (error) {
+            _$$_REQUIRE(_dependencyMap[9], "../vendor/core/ErrorUtils").default.reportFatalError(error);
+          }
+        }
+      }
+    }, {
+      key: "__shouldPauseOnThrow",
+      value: function __shouldPauseOnThrow() {
+        return typeof DebuggerInternal !== 'undefined' && DebuggerInternal.shouldPauseOnThrow === true;
+      }
+    }, {
+      key: "__callReactNativeMicrotasks",
+      value: function __callReactNativeMicrotasks() {
+        _$$_REQUIRE(_dependencyMap[8], "../Performance/Systrace").beginEvent('JSTimers.callReactNativeMicrotasks()');
+        try {
+          if (this._reactNativeMicrotasksCallback != null) {
+            this._reactNativeMicrotasksCallback();
+          }
+        } finally {
+          _$$_REQUIRE(_dependencyMap[8], "../Performance/Systrace").endEvent();
+        }
+      }
+    }, {
+      key: "__callFunction",
+      value: function __callFunction(module, method, args) {
+        this._lastFlush = Date.now();
+        this._eventLoopStartTime = this._lastFlush;
+        if (__DEV__ || this.__spy) {
+          _$$_REQUIRE(_dependencyMap[8], "../Performance/Systrace").beginEvent(`${module}.${method}(${_$$_REQUIRE(_dependencyMap[6], "../Utilities/stringifySafe").default(args)})`);
+        } else {
+          _$$_REQUIRE(_dependencyMap[8], "../Performance/Systrace").beginEvent(`${module}.${method}(...)`);
+        }
+        try {
+          if (this.__spy) {
+            this.__spy({
+              type: TO_JS,
+              module: module,
+              method: method,
+              args: args
+            });
+          }
+          var moduleMethods = this.getCallableModule(module);
+          if (!moduleMethods) {
+            var callableModuleNames = Object.keys(this._lazyCallableModules);
+            var n = callableModuleNames.length;
+            var callableModuleNameList = callableModuleNames.join(', ');
+            var isBridgelessMode = global.RN$Bridgeless === true ? 'true' : 'false';
+            _$$_REQUIRE(_dependencyMap[4], "invariant")(false, `Failed to call into JavaScript module method ${module}.${method}(). Module has not been registered as callable. Bridgeless Mode: ${isBridgelessMode}. Registered callable JavaScript modules (n = ${n}): ${callableModuleNameList}.
+          A frequent cause of the error is that the application entry file path is incorrect. This can also happen when the JS bundle is corrupt or there is an early initialization error when loading React Native.`);
+          }
+          if (!moduleMethods[method]) {
+            _$$_REQUIRE(_dependencyMap[4], "invariant")(false, `Failed to call into JavaScript module method ${module}.${method}(). Module exists, but the method is undefined.`);
+          }
+          moduleMethods[method].apply(moduleMethods, args);
+        } finally {
+          _$$_REQUIRE(_dependencyMap[8], "../Performance/Systrace").endEvent();
+        }
+      }
+    }, {
+      key: "__invokeCallback",
+      value: function __invokeCallback(cbID, args) {
+        this._lastFlush = Date.now();
+        this._eventLoopStartTime = this._lastFlush;
+        var callID = cbID >>> 1;
+        var isSuccess = cbID & 1;
+        var callback = isSuccess ? this._successCallbacks.get(callID) : this._failureCallbacks.get(callID);
+        if (__DEV__) {
+          var debug = this._debugInfo[callID];
+          var module = debug && this._remoteModuleTable[debug[0]];
+          var method = debug && this._remoteMethodTable[debug[0]][debug[1]];
+          _$$_REQUIRE(_dependencyMap[4], "invariant")(callback, `No callback found with cbID ${cbID} and callID ${callID} for ` + (method ? ` ${module}.${method} - most likely the callback was already invoked` : `module ${module || '<unknown>'}`) + `. Args: '${_$$_REQUIRE(_dependencyMap[6], "../Utilities/stringifySafe").default(args)}'`);
+          var profileName = debug ? '<callback for ' + module + '.' + method + '>' : cbID;
+          if (callback && this.__spy) {
+            this.__spy({
+              type: TO_JS,
+              module: null,
+              method: profileName,
+              args: args
+            });
+          }
+          _$$_REQUIRE(_dependencyMap[8], "../Performance/Systrace").beginEvent(`MessageQueue.invokeCallback(${profileName}, ${_$$_REQUIRE(_dependencyMap[6], "../Utilities/stringifySafe").default(args)})`);
+        }
+        try {
+          if (!callback) {
+            return;
+          }
+          this._successCallbacks.delete(callID);
+          this._failureCallbacks.delete(callID);
+          callback.apply(void 0, (0, _toConsumableArray2.default)(args));
+        } finally {
+          if (__DEV__) {
+            _$$_REQUIRE(_dependencyMap[8], "../Performance/Systrace").endEvent();
+          }
+        }
+      }
+    }], [{
+      key: "spy",
+      value: function spy(spyOrToggle) {
+        if (spyOrToggle === true) {
+          MessageQueue.prototype.__spy = function (info) {
+            console.log(`${info.type === TO_JS ? 'N->JS' : 'JS->N'} : ` + `${info.module != null ? info.module + '.' : ''}${info.method}` + `(${JSON.stringify(info.args)})`);
+          };
+        } else if (spyOrToggle === false) {
+          MessageQueue.prototype.__spy = null;
+        } else {
+          MessageQueue.prototype.__spy = spyOrToggle;
+        }
+      }
+    }]);
+  }();
+  var _default = exports.default = MessageQueue;
+},41,[1,42,11,12,32,46,47,48,28,49],"../../node_modules/react-native/Libraries/BatchedBridge/MessageQueue.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _toConsumableArray(r) {
+    return _$$_REQUIRE(_dependencyMap[0], "./arrayWithoutHoles.js")(r) || _$$_REQUIRE(_dependencyMap[1], "./iterableToArray.js")(r) || _$$_REQUIRE(_dependencyMap[2], "./unsupportedIterableToArray.js")(r) || _$$_REQUIRE(_dependencyMap[3], "./nonIterableSpread.js")();
+  }
+  module.exports = _toConsumableArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},42,[43,44,37,45],"../../node_modules/@babel/runtime/helpers/toConsumableArray.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _arrayWithoutHoles(r) {
+    if (Array.isArray(r)) return _$$_REQUIRE(_dependencyMap[0], "./arrayLikeToArray.js")(r);
+  }
+  module.exports = _arrayWithoutHoles, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},43,[38],"../../node_modules/@babel/runtime/helpers/arrayWithoutHoles.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _iterableToArray(r) {
+    if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+  }
+  module.exports = _iterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},44,[],"../../node_modules/@babel/runtime/helpers/iterableToArray.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  module.exports = _nonIterableSpread, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},45,[],"../../node_modules/@babel/runtime/helpers/nonIterableSpread.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var warnedKeys = {};
+  function warnOnce(key, message) {
+    if (warnedKeys[key]) {
+      return;
+    }
+    console.warn(message);
+    warnedKeys[key] = true;
+  }
+  var _default = exports.default = warnOnce;
+},46,[],"../../node_modules/react-native/Libraries/Utilities/warnOnce.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.createStringifySafeWithLimits = createStringifySafeWithLimits;
+  exports.default = void 0;
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "invariant"));
+  function createStringifySafeWithLimits(limits) {
+    var _limits$maxDepth = limits.maxDepth,
+      maxDepth = _limits$maxDepth === void 0 ? Number.POSITIVE_INFINITY : _limits$maxDepth,
+      _limits$maxStringLimi = limits.maxStringLimit,
+      maxStringLimit = _limits$maxStringLimi === void 0 ? Number.POSITIVE_INFINITY : _limits$maxStringLimi,
+      _limits$maxArrayLimit = limits.maxArrayLimit,
+      maxArrayLimit = _limits$maxArrayLimit === void 0 ? Number.POSITIVE_INFINITY : _limits$maxArrayLimit,
+      _limits$maxObjectKeys = limits.maxObjectKeysLimit,
+      maxObjectKeysLimit = _limits$maxObjectKeys === void 0 ? Number.POSITIVE_INFINITY : _limits$maxObjectKeys;
+    var stack = [];
+    function replacer(key, value) {
+      while (stack.length && this !== stack[0]) {
+        stack.shift();
+      }
+      if (typeof value === 'string') {
+        var truncatedString = '...(truncated)...';
+        if (value.length > maxStringLimit + truncatedString.length) {
+          return value.substring(0, maxStringLimit) + truncatedString;
+        }
+        return value;
+      }
+      if (typeof value !== 'object' || value === null) {
+        return value;
+      }
+      var retval = value;
+      if (Array.isArray(value)) {
+        if (stack.length >= maxDepth) {
+          retval = `[ ... array with ${value.length} values ... ]`;
+        } else if (value.length > maxArrayLimit) {
+          retval = value.slice(0, maxArrayLimit).concat([`... extra ${value.length - maxArrayLimit} values truncated ...`]);
+        }
+      } else {
+        (0, _invariant.default)(typeof value === 'object', 'This was already found earlier');
+        var keys = Object.keys(value);
+        if (stack.length >= maxDepth) {
+          retval = `{ ... object with ${keys.length} keys ... }`;
+        } else if (keys.length > maxObjectKeysLimit) {
+          retval = {};
+          for (var k of keys.slice(0, maxObjectKeysLimit)) {
+            retval[k] = value[k];
+          }
+          var truncatedKey = '...(truncated keys)...';
+          retval[truncatedKey] = keys.length - maxObjectKeysLimit;
+        }
+      }
+      stack.unshift(retval);
+      return retval;
+    }
+    return function stringifySafe(arg) {
+      if (arg === undefined) {
+        return 'undefined';
+      } else if (arg === null) {
+        return 'null';
+      } else if (typeof arg === 'function') {
+        try {
+          return arg.toString();
+        } catch (e) {
+          return '[function unknown]';
+        }
+      } else if (arg instanceof Error) {
+        return arg.name + ': ' + arg.message;
+      } else {
+        try {
+          var ret = JSON.stringify(arg, replacer);
+          if (ret === undefined) {
+            return '["' + typeof arg + '" failed to stringify]';
+          }
+          return ret;
+        } catch (e) {
+          if (typeof arg.toString === 'function') {
+            try {
+              return arg.toString();
+            } catch (E) {}
+          }
+        }
+      }
+      return '["' + typeof arg + '" failed to stringify]';
+    };
+  }
+  var stringifySafe = createStringifySafeWithLimits({
+    maxDepth: 10,
+    maxStringLimit: 100,
+    maxArrayLimit: 50,
+    maxObjectKeysLimit: 50
+  });
+  var _default = exports.default = stringifySafe;
+},47,[1,32],"../../node_modules/react-native/Libraries/Utilities/stringifySafe.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  function deepFreezeAndThrowOnMutationInDev(object) {
+    if (__DEV__) {
+      if (typeof object !== 'object' || object === null || Object.isFrozen(object) || Object.isSealed(object)) {
+        return object;
+      }
+      var keys = Object.keys(object);
+      var hasOwnProperty = Object.prototype.hasOwnProperty;
+      for (var i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        if (hasOwnProperty.call(object, key)) {
+          Object.defineProperty(object, key, {
+            get: identity.bind(null, object[key])
+          });
+          Object.defineProperty(object, key, {
+            set: throwOnImmutableMutation.bind(null, key)
+          });
+        }
+      }
+      Object.freeze(object);
+      Object.seal(object);
+      for (var _i = 0; _i < keys.length; _i++) {
+        var _key = keys[_i];
+        if (hasOwnProperty.call(object, _key)) {
+          deepFreezeAndThrowOnMutationInDev(object[_key]);
+        }
+      }
+    }
+    return object;
+  }
+  function throwOnImmutableMutation(key, value) {
+    throw Error('You attempted to set the key `' + key + '` with the value `' + JSON.stringify(value) + '` on an object that is meant to be immutable ' + 'and has been frozen.');
+  }
+  function identity(value) {
+    return value;
+  }
+  var _default = exports.default = deepFreezeAndThrowOnMutationInDev;
+},48,[],"../../node_modules/react-native/Libraries/Utilities/deepFreezeAndThrowOnMutationInDev.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _default = exports.default = global.ErrorUtils;
+},49,[],"../../node_modules/react-native/Libraries/vendor/core/ErrorUtils.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  function defineLazyObjectProperty(object, name, descriptor) {
+    var get = descriptor.get;
+    var enumerable = descriptor.enumerable !== false;
+    var writable = descriptor.writable !== false;
+    var value;
+    var valueSet = false;
+    function getValue() {
+      if (!valueSet) {
+        valueSet = true;
+        setValue(get());
+      }
+      return value;
+    }
+    function setValue(newValue) {
+      value = newValue;
+      valueSet = true;
+      Object.defineProperty(object, name, {
+        value: newValue,
+        configurable: true,
+        enumerable: enumerable,
+        writable: writable
+      });
+    }
+    Object.defineProperty(object, name, {
+      get: getValue,
+      set: setValue,
+      configurable: true,
+      enumerable: enumerable
+    });
+  }
+  var _default = exports.default = defineLazyObjectProperty;
+},50,[],"../../node_modules/react-native/Libraries/Utilities/defineLazyObjectProperty.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var ReactNativeFeatureFlags = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../../src/private/featureflags/ReactNativeFeatureFlags"));
+  var _NativeReactNativeFeatureFlags = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../../src/private/featureflags/specs/NativeReactNativeFeatureFlags"));
+  var _processAspectRatio = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processAspectRatio"));
+  var _processBackgroundImage = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../../StyleSheet/processBackgroundImage"));
+  var _processBoxShadow = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../../StyleSheet/processBoxShadow"));
+  var _processColor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../../StyleSheet/processColor"));
+  var _processFilter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../../StyleSheet/processFilter"));
+  var _processFontVariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../../StyleSheet/processFontVariant"));
+  var _processTransform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "../../StyleSheet/processTransform"));
+  var _processTransformOrigin = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "../../StyleSheet/processTransformOrigin"));
+  var _sizesDiffer = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "../../Utilities/differ/sizesDiffer"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var colorAttributes = {
+    process: _processColor.default
+  };
+  var ReactNativeStyleAttributes = {
+    alignContent: true,
+    alignItems: true,
+    alignSelf: true,
+    aspectRatio: {
+      process: _processAspectRatio.default
+    },
+    borderBottomWidth: true,
+    borderEndWidth: true,
+    borderLeftWidth: true,
+    borderRightWidth: true,
+    borderStartWidth: true,
+    borderTopWidth: true,
+    boxSizing: true,
+    columnGap: true,
+    borderWidth: true,
+    bottom: true,
+    direction: true,
+    display: true,
+    end: true,
+    flex: true,
+    flexBasis: true,
+    flexDirection: true,
+    flexGrow: true,
+    flexShrink: true,
+    flexWrap: true,
+    gap: true,
+    height: true,
+    inset: true,
+    insetBlock: true,
+    insetBlockEnd: true,
+    insetBlockStart: true,
+    insetInline: true,
+    insetInlineEnd: true,
+    insetInlineStart: true,
+    justifyContent: true,
+    left: true,
+    margin: true,
+    marginBlock: true,
+    marginBlockEnd: true,
+    marginBlockStart: true,
+    marginBottom: true,
+    marginEnd: true,
+    marginHorizontal: true,
+    marginInline: true,
+    marginInlineEnd: true,
+    marginInlineStart: true,
+    marginLeft: true,
+    marginRight: true,
+    marginStart: true,
+    marginTop: true,
+    marginVertical: true,
+    maxHeight: true,
+    maxWidth: true,
+    minHeight: true,
+    minWidth: true,
+    overflow: true,
+    padding: true,
+    paddingBlock: true,
+    paddingBlockEnd: true,
+    paddingBlockStart: true,
+    paddingBottom: true,
+    paddingEnd: true,
+    paddingHorizontal: true,
+    paddingInline: true,
+    paddingInlineEnd: true,
+    paddingInlineStart: true,
+    paddingLeft: true,
+    paddingRight: true,
+    paddingStart: true,
+    paddingTop: true,
+    paddingVertical: true,
+    position: true,
+    right: true,
+    rowGap: true,
+    start: true,
+    top: true,
+    width: true,
+    zIndex: true,
+    elevation: true,
+    shadowColor: colorAttributes,
+    shadowOffset: {
+      diff: _sizesDiffer.default
+    },
+    shadowOpacity: true,
+    shadowRadius: true,
+    transform: {
+      process: _processTransform.default
+    },
+    transformOrigin: {
+      process: _processTransformOrigin.default
+    },
+    filter: _NativeReactNativeFeatureFlags.default != null && ReactNativeFeatureFlags.enableNativeCSSParsing() ? true : {
+      process: _processFilter.default
+    },
+    mixBlendMode: true,
+    isolation: true,
+    boxShadow: _NativeReactNativeFeatureFlags.default != null && ReactNativeFeatureFlags.enableNativeCSSParsing() ? true : {
+      process: _processBoxShadow.default
+    },
+    experimental_backgroundImage: {
+      process: _processBackgroundImage.default
+    },
+    backfaceVisibility: true,
+    backgroundColor: colorAttributes,
+    borderBlockColor: colorAttributes,
+    borderBlockEndColor: colorAttributes,
+    borderBlockStartColor: colorAttributes,
+    borderBottomColor: colorAttributes,
+    borderBottomEndRadius: true,
+    borderBottomLeftRadius: true,
+    borderBottomRightRadius: true,
+    borderBottomStartRadius: true,
+    borderColor: colorAttributes,
+    borderCurve: true,
+    borderEndColor: colorAttributes,
+    borderEndEndRadius: true,
+    borderEndStartRadius: true,
+    borderLeftColor: colorAttributes,
+    borderRadius: true,
+    borderRightColor: colorAttributes,
+    borderStartColor: colorAttributes,
+    borderStartEndRadius: true,
+    borderStartStartRadius: true,
+    borderStyle: true,
+    borderTopColor: colorAttributes,
+    borderTopEndRadius: true,
+    borderTopLeftRadius: true,
+    borderTopRightRadius: true,
+    borderTopStartRadius: true,
+    cursor: true,
+    opacity: true,
+    outlineColor: colorAttributes,
+    outlineOffset: true,
+    outlineStyle: true,
+    outlineWidth: true,
+    pointerEvents: true,
+    color: colorAttributes,
+    fontFamily: true,
+    fontSize: true,
+    fontStyle: true,
+    fontVariant: {
+      process: _processFontVariant.default
+    },
+    fontWeight: true,
+    includeFontPadding: true,
+    letterSpacing: true,
+    lineHeight: true,
+    textAlign: true,
+    textAlignVertical: true,
+    textDecorationColor: colorAttributes,
+    textDecorationLine: true,
+    textDecorationStyle: true,
+    textShadowColor: colorAttributes,
+    textShadowOffset: true,
+    textShadowRadius: true,
+    textTransform: true,
+    userSelect: true,
+    verticalAlign: true,
+    writingDirection: true,
+    overlayColor: colorAttributes,
+    resizeMode: true,
+    tintColor: colorAttributes,
+    objectFit: true
+  };
+  var _default = exports.default = ReactNativeStyleAttributes;
+},51,[1,52,54,55,56,61,57,62,63,64,66,67],"../../node_modules/react-native/Libraries/Components/View/ReactNativeStyleAttributes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.useTurboModules = exports.useTurboModuleInterop = exports.useShadowNodeStateOnClone = exports.useRawPropsJsiValue = exports.useOptimizedEventBatchingOnAndroid = exports.useNativeViewConfigsInBridgelessMode = exports.useFabricInterop = exports.useAlwaysAvailableJSErrorHandling = exports.updateRuntimeShadowNodeReferencesOnCommit = exports.traceTurboModulePromiseRejectionsOnAndroid = exports.shouldUseSetNativePropsInFabric = exports.shouldUseRemoveClippedSubviewsAsDefaultOnIOS = exports.shouldUseAnimatedObjectForTransform = exports.scheduleAnimatedCleanupInMicrotask = exports.override = exports.jsOnlyTestFlag = exports.isLayoutAnimationEnabled = exports.incorporateMaxLinesDuringAndroidLayout = exports.fuseboxNetworkInspectionEnabled = exports.fuseboxEnabledRelease = exports.fixVirtualizeListCollapseWindowSize = exports.fixMappingOfEventPrioritiesBetweenFabricAndReact = exports.enableViewRecyclingForView = exports.enableViewRecyclingForText = exports.enableViewRecycling = exports.enableViewCulling = exports.enableSynchronousStateUpdates = exports.enableResourceTimingAPI = exports.enablePropsUpdateReconciliationAndroid = exports.enablePreparedTextLayout = exports.enableNewBackgroundAndBorderDrawables = exports.enableNetworkEventReporting = exports.enableNativeCSSParsing = exports.enableMainQueueModulesOnIOS = exports.enableLayoutAnimationsOnIOS = exports.enableLayoutAnimationsOnAndroid = exports.enableJSRuntimeGCOnMemoryPressureOnIOS = exports.enableIOSViewClipToPaddingBox = exports.enableFontScaleChangesUpdatingLayout = exports.enableFixForParentTagDuringReparenting = exports.enableFabricRenderer = exports.enableFabricLogs = exports.enableEagerRootViewAttachment = exports.enableDoubleMeasurementFixAndroid = exports.enableDestroyShadowTreeRevisionAsync = exports.enableCustomFocusSearchOnClippedElementsAndroid = exports.enableCppPropsIteratorSetter = exports.enableBridgelessArchitecture = exports.enableAccumulatedUpdatesInRawPropsAndroid = exports.enableAccessibilityOrder = exports.enableAccessToHostTreeInFabric = exports.disableMountItemReorderingAndroid = exports.disableMainQueueSyncDispatchIOS = exports.disableInteractionManager = exports.cxxNativeAnimatedEnabled = exports.commonTestFlagWithoutNativeImplementation = exports.commonTestFlag = exports.avoidStateUpdateInAnimatedPropsMemo = exports.animatedShouldUseSingleOp = exports.animatedShouldSignalBatch = exports.animatedShouldDebounceQueueFlush = void 0;
+  var jsOnlyTestFlag = exports.jsOnlyTestFlag = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createJavaScriptFlagGetter)('jsOnlyTestFlag', false);
+  var animatedShouldDebounceQueueFlush = exports.animatedShouldDebounceQueueFlush = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createJavaScriptFlagGetter)('animatedShouldDebounceQueueFlush', false);
+  var animatedShouldUseSingleOp = exports.animatedShouldUseSingleOp = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createJavaScriptFlagGetter)('animatedShouldUseSingleOp', false);
+  var avoidStateUpdateInAnimatedPropsMemo = exports.avoidStateUpdateInAnimatedPropsMemo = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createJavaScriptFlagGetter)('avoidStateUpdateInAnimatedPropsMemo', false);
+  var disableInteractionManager = exports.disableInteractionManager = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createJavaScriptFlagGetter)('disableInteractionManager', true);
+  var enableAccessToHostTreeInFabric = exports.enableAccessToHostTreeInFabric = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createJavaScriptFlagGetter)('enableAccessToHostTreeInFabric', false);
+  var fixVirtualizeListCollapseWindowSize = exports.fixVirtualizeListCollapseWindowSize = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createJavaScriptFlagGetter)('fixVirtualizeListCollapseWindowSize', false);
+  var isLayoutAnimationEnabled = exports.isLayoutAnimationEnabled = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createJavaScriptFlagGetter)('isLayoutAnimationEnabled', true);
+  var scheduleAnimatedCleanupInMicrotask = exports.scheduleAnimatedCleanupInMicrotask = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createJavaScriptFlagGetter)('scheduleAnimatedCleanupInMicrotask', true);
+  var shouldUseAnimatedObjectForTransform = exports.shouldUseAnimatedObjectForTransform = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createJavaScriptFlagGetter)('shouldUseAnimatedObjectForTransform', false);
+  var shouldUseRemoveClippedSubviewsAsDefaultOnIOS = exports.shouldUseRemoveClippedSubviewsAsDefaultOnIOS = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createJavaScriptFlagGetter)('shouldUseRemoveClippedSubviewsAsDefaultOnIOS', false);
+  var shouldUseSetNativePropsInFabric = exports.shouldUseSetNativePropsInFabric = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createJavaScriptFlagGetter)('shouldUseSetNativePropsInFabric', true);
+  var commonTestFlag = exports.commonTestFlag = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('commonTestFlag', false);
+  var commonTestFlagWithoutNativeImplementation = exports.commonTestFlagWithoutNativeImplementation = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('commonTestFlagWithoutNativeImplementation', false);
+  var animatedShouldSignalBatch = exports.animatedShouldSignalBatch = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('animatedShouldSignalBatch', false);
+  var cxxNativeAnimatedEnabled = exports.cxxNativeAnimatedEnabled = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('cxxNativeAnimatedEnabled', false);
+  var disableMainQueueSyncDispatchIOS = exports.disableMainQueueSyncDispatchIOS = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('disableMainQueueSyncDispatchIOS', false);
+  var disableMountItemReorderingAndroid = exports.disableMountItemReorderingAndroid = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('disableMountItemReorderingAndroid', false);
+  var enableAccessibilityOrder = exports.enableAccessibilityOrder = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableAccessibilityOrder', false);
+  var enableAccumulatedUpdatesInRawPropsAndroid = exports.enableAccumulatedUpdatesInRawPropsAndroid = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableAccumulatedUpdatesInRawPropsAndroid', false);
+  var enableBridgelessArchitecture = exports.enableBridgelessArchitecture = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableBridgelessArchitecture', false);
+  var enableCppPropsIteratorSetter = exports.enableCppPropsIteratorSetter = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableCppPropsIteratorSetter', false);
+  var enableCustomFocusSearchOnClippedElementsAndroid = exports.enableCustomFocusSearchOnClippedElementsAndroid = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableCustomFocusSearchOnClippedElementsAndroid', true);
+  var enableDestroyShadowTreeRevisionAsync = exports.enableDestroyShadowTreeRevisionAsync = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableDestroyShadowTreeRevisionAsync', false);
+  var enableDoubleMeasurementFixAndroid = exports.enableDoubleMeasurementFixAndroid = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableDoubleMeasurementFixAndroid', false);
+  var enableEagerRootViewAttachment = exports.enableEagerRootViewAttachment = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableEagerRootViewAttachment', false);
+  var enableFabricLogs = exports.enableFabricLogs = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableFabricLogs', false);
+  var enableFabricRenderer = exports.enableFabricRenderer = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableFabricRenderer', false);
+  var enableFixForParentTagDuringReparenting = exports.enableFixForParentTagDuringReparenting = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableFixForParentTagDuringReparenting', false);
+  var enableFontScaleChangesUpdatingLayout = exports.enableFontScaleChangesUpdatingLayout = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableFontScaleChangesUpdatingLayout', false);
+  var enableIOSViewClipToPaddingBox = exports.enableIOSViewClipToPaddingBox = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableIOSViewClipToPaddingBox', false);
+  var enableJSRuntimeGCOnMemoryPressureOnIOS = exports.enableJSRuntimeGCOnMemoryPressureOnIOS = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableJSRuntimeGCOnMemoryPressureOnIOS', false);
+  var enableLayoutAnimationsOnAndroid = exports.enableLayoutAnimationsOnAndroid = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableLayoutAnimationsOnAndroid', false);
+  var enableLayoutAnimationsOnIOS = exports.enableLayoutAnimationsOnIOS = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableLayoutAnimationsOnIOS', true);
+  var enableMainQueueModulesOnIOS = exports.enableMainQueueModulesOnIOS = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableMainQueueModulesOnIOS', false);
+  var enableNativeCSSParsing = exports.enableNativeCSSParsing = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableNativeCSSParsing', false);
+  var enableNetworkEventReporting = exports.enableNetworkEventReporting = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableNetworkEventReporting', false);
+  var enableNewBackgroundAndBorderDrawables = exports.enableNewBackgroundAndBorderDrawables = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableNewBackgroundAndBorderDrawables', true);
+  var enablePreparedTextLayout = exports.enablePreparedTextLayout = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enablePreparedTextLayout', false);
+  var enablePropsUpdateReconciliationAndroid = exports.enablePropsUpdateReconciliationAndroid = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enablePropsUpdateReconciliationAndroid', false);
+  var enableResourceTimingAPI = exports.enableResourceTimingAPI = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableResourceTimingAPI', false);
+  var enableSynchronousStateUpdates = exports.enableSynchronousStateUpdates = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableSynchronousStateUpdates', false);
+  var enableViewCulling = exports.enableViewCulling = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableViewCulling', false);
+  var enableViewRecycling = exports.enableViewRecycling = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableViewRecycling', false);
+  var enableViewRecyclingForText = exports.enableViewRecyclingForText = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableViewRecyclingForText', true);
+  var enableViewRecyclingForView = exports.enableViewRecyclingForView = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('enableViewRecyclingForView', true);
+  var fixMappingOfEventPrioritiesBetweenFabricAndReact = exports.fixMappingOfEventPrioritiesBetweenFabricAndReact = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('fixMappingOfEventPrioritiesBetweenFabricAndReact', false);
+  var fuseboxEnabledRelease = exports.fuseboxEnabledRelease = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('fuseboxEnabledRelease', false);
+  var fuseboxNetworkInspectionEnabled = exports.fuseboxNetworkInspectionEnabled = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('fuseboxNetworkInspectionEnabled', false);
+  var incorporateMaxLinesDuringAndroidLayout = exports.incorporateMaxLinesDuringAndroidLayout = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('incorporateMaxLinesDuringAndroidLayout', true);
+  var traceTurboModulePromiseRejectionsOnAndroid = exports.traceTurboModulePromiseRejectionsOnAndroid = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('traceTurboModulePromiseRejectionsOnAndroid', false);
+  var updateRuntimeShadowNodeReferencesOnCommit = exports.updateRuntimeShadowNodeReferencesOnCommit = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('updateRuntimeShadowNodeReferencesOnCommit', false);
+  var useAlwaysAvailableJSErrorHandling = exports.useAlwaysAvailableJSErrorHandling = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('useAlwaysAvailableJSErrorHandling', false);
+  var useFabricInterop = exports.useFabricInterop = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('useFabricInterop', true);
+  var useNativeViewConfigsInBridgelessMode = exports.useNativeViewConfigsInBridgelessMode = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('useNativeViewConfigsInBridgelessMode', false);
+  var useOptimizedEventBatchingOnAndroid = exports.useOptimizedEventBatchingOnAndroid = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('useOptimizedEventBatchingOnAndroid', false);
+  var useRawPropsJsiValue = exports.useRawPropsJsiValue = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('useRawPropsJsiValue', false);
+  var useShadowNodeStateOnClone = exports.useShadowNodeStateOnClone = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('useShadowNodeStateOnClone', false);
+  var useTurboModuleInterop = exports.useTurboModuleInterop = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('useTurboModuleInterop', false);
+  var useTurboModules = exports.useTurboModules = (0, _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").createNativeFlagGetter)('useTurboModules', false);
+  var override = exports.override = _$$_REQUIRE(_dependencyMap[0], "./ReactNativeFeatureFlagsBase").setOverrides;
+},52,[53],"../../node_modules/react-native/src/private/featureflags/ReactNativeFeatureFlags.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.createJavaScriptFlagGetter = createJavaScriptFlagGetter;
+  exports.createNativeFlagGetter = createNativeFlagGetter;
+  exports.getOverrides = getOverrides;
+  exports.setOverrides = setOverrides;
+  var _NativeReactNativeFeatureFlags = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./specs/NativeReactNativeFeatureFlags"));
+  var accessedFeatureFlags = new Set();
+  var overrides;
+  function createGetter(configName, customValueGetter, defaultValue) {
+    var cachedValue;
+    return function () {
+      if (cachedValue == null) {
+        var _customValueGetter;
+        cachedValue = (_customValueGetter = customValueGetter()) != null ? _customValueGetter : defaultValue;
+      }
+      return cachedValue;
+    };
+  }
+  function createJavaScriptFlagGetter(configName, defaultValue) {
+    return createGetter(configName, function () {
+      var _overrides, _overrides$configName;
+      accessedFeatureFlags.add(configName);
+      return (_overrides = overrides) == null || (_overrides$configName = _overrides[configName]) == null ? void 0 : _overrides$configName.call(_overrides, defaultValue);
+    }, defaultValue);
+  }
+  function createNativeFlagGetter(configName, defaultValue) {
+    var skipUnavailableNativeModuleError = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    return createGetter(configName, function () {
+      var _NativeReactNativeFea;
+      maybeLogUnavailableNativeModuleError(configName);
+      return _NativeReactNativeFeatureFlags.default == null || (_NativeReactNativeFea = _NativeReactNativeFeatureFlags.default[configName]) == null ? void 0 : _NativeReactNativeFea.call(_NativeReactNativeFeatureFlags.default);
+    }, defaultValue);
+  }
+  function getOverrides() {
+    return overrides;
+  }
+  function setOverrides(newOverrides) {
+    if (overrides != null) {
+      throw new Error('Feature flags cannot be overridden more than once');
+    }
+    if (accessedFeatureFlags.size > 0) {
+      var accessedFeatureFlagsStr = Array.from(accessedFeatureFlags).join(', ');
+      throw new Error(`Feature flags were accessed before being overridden: ${accessedFeatureFlagsStr}`);
+    }
+    overrides = newOverrides;
+  }
+  var reportedConfigNames = new Set();
+  var hasTurboModules = global.RN$Bridgeless === true || global.__turboModuleProxy != null;
+  function maybeLogUnavailableNativeModuleError(configName) {
+    if (!_NativeReactNativeFeatureFlags.default && !reportedConfigNames.has(configName) && hasTurboModules) {
+      reportedConfigNames.add(configName);
+      console.error(`Could not access feature flag '${configName}' because native module method was not available`);
+    }
+  }
+},53,[1,54],"../../node_modules/react-native/src/private/featureflags/ReactNativeFeatureFlagsBase.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var NativeReactNativeFeatureFlags = TurboModuleRegistry.get('NativeReactNativeFeatureFlagsCxx');
+  var _default = exports.default = NativeReactNativeFeatureFlags;
+},54,[31],"../../node_modules/react-native/src/private/featureflags/specs/NativeReactNativeFeatureFlags.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  function processAspectRatio(aspectRatio) {
+    if (typeof aspectRatio === 'number') {
+      return aspectRatio;
+    }
+    if (typeof aspectRatio !== 'string') {
+      if (__DEV__) {
+        _$$_REQUIRE(_dependencyMap[0], "invariant")(!aspectRatio, 'aspectRatio must either be a number, a ratio string or `auto`. You passed: %s', aspectRatio);
+      }
+      return;
+    }
+    var matches = aspectRatio.split('/').map(function (s) {
+      return s.trim();
+    });
+    if (matches.includes('auto')) {
+      if (__DEV__) {
+        _$$_REQUIRE(_dependencyMap[0], "invariant")(matches.length, 'aspectRatio does not support `auto <ratio>`. You passed: %s', aspectRatio);
+      }
+      return;
+    }
+    var hasNonNumericValues = matches.some(function (n) {
+      return Number.isNaN(Number(n));
+    });
+    if (__DEV__) {
+      _$$_REQUIRE(_dependencyMap[0], "invariant")(!hasNonNumericValues && (matches.length === 1 || matches.length === 2), 'aspectRatio must either be a number, a ratio string or `auto`. You passed: %s', aspectRatio);
+    }
+    if (hasNonNumericValues) {
+      return;
+    }
+    if (matches.length === 2) {
+      return Number(matches[0]) / Number(matches[1]);
+    }
+    return Number(matches[0]);
+  }
+  var _default = exports.default = processAspectRatio;
+},55,[32],"../../node_modules/react-native/Libraries/StyleSheet/processAspectRatio.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = processBackgroundImage;
+  var _toConsumableArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/toConsumableArray"));
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/slicedToArray"));
+  var LINEAR_GRADIENT_DIRECTION_REGEX = /^to\s+(?:top|bottom|left|right)(?:\s+(?:top|bottom|left|right))?/i;
+  var LINEAR_GRADIENT_ANGLE_UNIT_REGEX = /^([+-]?\d*\.?\d+)(deg|grad|rad|turn)$/i;
+  var LINEAR_GRADIENT_DEFAULT_DIRECTION = {
+    type: 'angle',
+    value: 180
+  };
+  var DEFAULT_RADIAL_SHAPE = 'ellipse';
+  var DEFAULT_RADIAL_SIZE = 'farthest-corner';
+  var DEFAULT_RADIAL_POSITION = {
+    top: '50%',
+    left: '50%'
+  };
+  function processBackgroundImage(backgroundImage) {
+    var result = [];
+    if (backgroundImage == null) {
+      return result;
+    }
+    if (typeof backgroundImage === 'string') {
+      result = parseBackgroundImageCSSString(backgroundImage.replace(/\n/g, ' '));
+    } else if (Array.isArray(backgroundImage)) {
+      for (var bgImage of backgroundImage) {
+        var processedColorStops = processColorStops(bgImage);
+        if (processedColorStops == null) {
+          return [];
+        }
+        if (bgImage.type === 'linear-gradient') {
+          var direction = LINEAR_GRADIENT_DEFAULT_DIRECTION;
+          var bgDirection = bgImage.direction != null ? bgImage.direction.toLowerCase() : null;
+          if (bgDirection != null) {
+            if (LINEAR_GRADIENT_ANGLE_UNIT_REGEX.test(bgDirection)) {
+              var parsedAngle = getAngleInDegrees(bgDirection);
+              if (parsedAngle != null) {
+                direction = {
+                  type: 'angle',
+                  value: parsedAngle
+                };
+              } else {
+                return [];
+              }
+            } else if (LINEAR_GRADIENT_DIRECTION_REGEX.test(bgDirection)) {
+              var parsedDirection = getDirectionForKeyword(bgDirection);
+              if (parsedDirection != null) {
+                direction = parsedDirection;
+              } else {
+                return [];
+              }
+            } else {
+              return [];
+            }
+          }
+          result = result.concat({
+            type: 'linear-gradient',
+            direction: direction,
+            colorStops: processedColorStops
+          });
+        } else if (bgImage.type === 'radial-gradient') {
+          var shape = DEFAULT_RADIAL_SHAPE;
+          var size = DEFAULT_RADIAL_SIZE;
+          var position = Object.assign({}, DEFAULT_RADIAL_POSITION);
+          if (bgImage.shape != null) {
+            if (bgImage.shape === 'circle' || bgImage.shape === 'ellipse') {
+              shape = bgImage.shape;
+            } else {
+              return [];
+            }
+          }
+          if (bgImage.size != null) {
+            if (typeof bgImage.size === 'string' && (bgImage.size === 'closest-side' || bgImage.size === 'closest-corner' || bgImage.size === 'farthest-side' || bgImage.size === 'farthest-corner')) {
+              size = bgImage.size;
+            } else if (typeof bgImage.size === 'object' && bgImage.size.x != null && bgImage.size.y != null) {
+              size = {
+                x: bgImage.size.x,
+                y: bgImage.size.y
+              };
+            } else {
+              return [];
+            }
+          }
+          if (bgImage.position != null) {
+            position = bgImage.position;
+          }
+          result = result.concat({
+            type: 'radial-gradient',
+            shape: shape,
+            size: size,
+            position: position,
+            colorStops: processedColorStops
+          });
+        }
+      }
+    }
+    return result;
+  }
+  function processColorStops(bgImage) {
+    var processedColorStops = [];
+    for (var index = 0; index < bgImage.colorStops.length; index++) {
+      var colorStop = bgImage.colorStops[index];
+      var positions = colorStop.positions;
+      if (colorStop.color == null && Array.isArray(positions) && positions.length === 1) {
+        var position = positions[0];
+        if (typeof position === 'number' || typeof position === 'string' && position.endsWith('%')) {
+          processedColorStops.push({
+            color: null,
+            position: position
+          });
+        } else {
+          return null;
+        }
+      } else {
+        var processedColor = _$$_REQUIRE(_dependencyMap[3], "./processColor").default(colorStop.color);
+        if (processedColor == null) {
+          return null;
+        }
+        if (positions != null && positions.length > 0) {
+          for (var _position of positions) {
+            if (typeof _position === 'number' || typeof _position === 'string' && _position.endsWith('%')) {
+              processedColorStops.push({
+                color: processedColor,
+                position: _position
+              });
+            } else {
+              return null;
+            }
+          }
+        } else {
+          processedColorStops.push({
+            color: processedColor,
+            position: null
+          });
+        }
+      }
+    }
+    return processedColorStops;
+  }
+  function parseBackgroundImageCSSString(cssString) {
+    var gradients = [];
+    var bgImageStrings = splitGradients(cssString);
+    for (var bgImageString of bgImageStrings) {
+      var bgImage = bgImageString.toLowerCase();
+      var gradientRegex = /^(linear|radial)-gradient\(((?:\([^)]*\)|[^()])*)\)/;
+      var match = gradientRegex.exec(bgImage);
+      if (match) {
+        var _match = (0, _slicedToArray2.default)(match, 3),
+          type = _match[1],
+          gradientContent = _match[2];
+        var isRadial = type.toLowerCase() === 'radial';
+        var gradient = isRadial ? parseRadialGradientCSSString(gradientContent) : parseLinearGradientCSSString(gradientContent);
+        if (gradient != null) {
+          gradients.push(gradient);
+        }
+      }
+    }
+    return gradients;
+  }
+  function parseRadialGradientCSSString(gradientContent) {
+    var shape = DEFAULT_RADIAL_SHAPE;
+    var size = DEFAULT_RADIAL_SIZE;
+    var position = Object.assign({}, DEFAULT_RADIAL_POSITION);
+    var parts = gradientContent.split(/,(?![^(]*\))/);
+    var firstPartStr = parts[0].trim();
+    var remainingParts = (0, _toConsumableArray2.default)(parts);
+    var hasShapeSizeOrPositionString = false;
+    var hasExplicitSingleSize = false;
+    var hasExplicitShape = false;
+    var firstPartTokens = firstPartStr.split(/\s+/);
+    while (firstPartTokens.length > 0) {
+      var token = firstPartTokens.shift();
+      if (token == null) {
+        continue;
+      }
+      var tokenTrimmed = token.toLowerCase().trim();
+      if (tokenTrimmed === 'circle' || tokenTrimmed === 'ellipse') {
+        shape = tokenTrimmed === 'circle' ? 'circle' : 'ellipse';
+        hasShapeSizeOrPositionString = true;
+        hasExplicitShape = true;
+      } else if (tokenTrimmed === 'closest-corner' || tokenTrimmed === 'farthest-corner' || tokenTrimmed === 'closest-side' || tokenTrimmed === 'farthest-side') {
+        size = tokenTrimmed;
+        hasShapeSizeOrPositionString = true;
+      } else if (tokenTrimmed.endsWith('px') || tokenTrimmed.endsWith('%')) {
+        var sizeX = getPositionFromCSSValue(tokenTrimmed);
+        if (sizeX == null) {
+          return null;
+        }
+        if (typeof sizeX === 'number' && sizeX < 0) {
+          return null;
+        }
+        hasShapeSizeOrPositionString = true;
+        size = {
+          x: sizeX,
+          y: sizeX
+        };
+        token = firstPartTokens.shift();
+        if (token == null) {
+          hasExplicitSingleSize = true;
+          continue;
+        }
+        tokenTrimmed = token.toLowerCase().trim();
+        if (tokenTrimmed.endsWith('px') || tokenTrimmed.endsWith('%')) {
+          var sizeY = getPositionFromCSSValue(tokenTrimmed);
+          if (sizeY == null) {
+            return null;
+          }
+          if (typeof sizeY === 'number' && sizeY < 0) {
+            return null;
+          }
+          size = {
+            x: sizeX,
+            y: sizeY
+          };
+        } else {
+          hasExplicitSingleSize = true;
+        }
+      } else if (tokenTrimmed === 'at') {
+        var top = void 0;
+        var left = void 0;
+        var right = void 0;
+        var bottom = void 0;
+        hasShapeSizeOrPositionString = true;
+        if (firstPartTokens.length === 0) {
+          return null;
+        }
+        if (firstPartTokens.length === 1) {
+          token = firstPartTokens.shift();
+          if (token == null) {
+            return null;
+          }
+          tokenTrimmed = token.toLowerCase().trim();
+          if (tokenTrimmed === 'left') {
+            left = '0%';
+            top = '50%';
+          } else if (tokenTrimmed === 'center') {
+            left = '50%';
+            top = '50%';
+          } else if (tokenTrimmed === 'right') {
+            left = '100%';
+            top = '50%';
+          } else if (tokenTrimmed === 'top') {
+            left = '50%';
+            top = '0%';
+          } else if (tokenTrimmed === 'bottom') {
+            left = '50%';
+            top = '100%';
+          } else if (tokenTrimmed.endsWith('px') || tokenTrimmed.endsWith('%')) {
+            var value = getPositionFromCSSValue(tokenTrimmed);
+            if (value == null) {
+              return null;
+            }
+            left = value;
+            top = '50%';
+          }
+        }
+        if (firstPartTokens.length === 2) {
+          var t1 = firstPartTokens.shift();
+          var t2 = firstPartTokens.shift();
+          if (t1 == null || t2 == null) {
+            return null;
+          }
+          var token1 = t1.toLowerCase().trim();
+          var token2 = t2.toLowerCase().trim();
+          var horizontalPositions = ['left', 'center', 'right'];
+          var verticalPositions = ['top', 'center', 'bottom'];
+          if (horizontalPositions.includes(token1) && verticalPositions.includes(token2)) {
+            left = token1 === 'left' ? '0%' : token1 === 'center' ? '50%' : '100%';
+            top = token2 === 'top' ? '0%' : token2 === 'center' ? '50%' : '100%';
+          } else if (verticalPositions.includes(token1) && horizontalPositions.includes(token2)) {
+            left = token2 === 'left' ? '0%' : token2 === 'center' ? '50%' : '100%';
+            top = token1 === 'top' ? '0%' : token1 === 'center' ? '50%' : '100%';
+          } else {
+            if (token1 === 'left') {
+              left = '0%';
+            } else if (token1 === 'center') {
+              left = '50%';
+            } else if (token1 === 'right') {
+              left = '100%';
+            } else if (token1.endsWith('px') || token1.endsWith('%')) {
+              var _value = getPositionFromCSSValue(token1);
+              if (_value == null) {
+                return null;
+              }
+              left = _value;
+            } else {
+              return null;
+            }
+            if (token2 === 'top') {
+              top = '0%';
+            } else if (token2 === 'center') {
+              top = '50%';
+            } else if (token2 === 'bottom') {
+              top = '100%';
+            } else if (token2.endsWith('px') || token2.endsWith('%')) {
+              var _value2 = getPositionFromCSSValue(token2);
+              if (_value2 == null) {
+                return null;
+              }
+              top = _value2;
+            } else {
+              return null;
+            }
+          }
+        }
+        if (firstPartTokens.length === 4) {
+          var _t = firstPartTokens.shift();
+          var _t2 = firstPartTokens.shift();
+          var t3 = firstPartTokens.shift();
+          var t4 = firstPartTokens.shift();
+          if (_t == null || _t2 == null || t3 == null || t4 == null) {
+            return null;
+          }
+          var _token = _t.toLowerCase().trim();
+          var _token2 = _t2.toLowerCase().trim();
+          var token3 = t3.toLowerCase().trim();
+          var token4 = t4.toLowerCase().trim();
+          var keyword1 = _token;
+          var value1 = getPositionFromCSSValue(_token2);
+          var keyword2 = token3;
+          var value2 = getPositionFromCSSValue(token4);
+          if (value1 == null || value2 == null) {
+            return null;
+          }
+          if (keyword1 === 'left') {
+            left = value1;
+          } else if (keyword1 === 'right') {
+            right = value1;
+          } else if (keyword1 === 'top') {
+            top = value1;
+          } else if (keyword1 === 'bottom') {
+            bottom = value1;
+          } else {
+            return null;
+          }
+          if (keyword2 === 'left') {
+            left = value2;
+          } else if (keyword2 === 'right') {
+            right = value2;
+          } else if (keyword2 === 'top') {
+            top = value2;
+          } else if (keyword2 === 'bottom') {
+            bottom = value2;
+          } else {
+            return null;
+          }
+        }
+        if (top != null && left != null) {
+          position = {
+            top: top,
+            left: left
+          };
+        } else if (bottom != null && right != null) {
+          position = {
+            bottom: bottom,
+            right: right
+          };
+        } else if (top != null && right != null) {
+          position = {
+            top: top,
+            right: right
+          };
+        } else if (bottom != null && left != null) {
+          position = {
+            bottom: bottom,
+            left: left
+          };
+        } else {
+          return null;
+        }
+        break;
+      }
+      if (!hasShapeSizeOrPositionString) {
+        break;
+      }
+    }
+    if (hasShapeSizeOrPositionString) {
+      remainingParts.shift();
+      if (!hasExplicitShape && hasExplicitSingleSize) {
+        shape = 'circle';
+      }
+      if (hasExplicitSingleSize && hasExplicitShape && shape === 'ellipse') {
+        return null;
+      }
+    }
+    var colorStops = parseColorStopsCSSString(remainingParts);
+    if (colorStops == null) {
+      return null;
+    }
+    return {
+      type: 'radial-gradient',
+      shape: shape,
+      size: size,
+      position: position,
+      colorStops: colorStops
+    };
+  }
+  function parseLinearGradientCSSString(gradientContent) {
+    var parts = gradientContent.split(',');
+    var direction = LINEAR_GRADIENT_DEFAULT_DIRECTION;
+    var trimmedDirection = parts[0].trim().toLowerCase();
+    if (LINEAR_GRADIENT_ANGLE_UNIT_REGEX.test(trimmedDirection)) {
+      var parsedAngle = getAngleInDegrees(trimmedDirection);
+      if (parsedAngle != null) {
+        direction = {
+          type: 'angle',
+          value: parsedAngle
+        };
+        parts.shift();
+      } else {
+        return null;
+      }
+    } else if (LINEAR_GRADIENT_DIRECTION_REGEX.test(trimmedDirection)) {
+      var parsedDirection = getDirectionForKeyword(trimmedDirection);
+      if (parsedDirection != null) {
+        direction = parsedDirection;
+        parts.shift();
+      } else {
+        return null;
+      }
+    }
+    var colorStops = parseColorStopsCSSString(parts);
+    if (colorStops == null) {
+      return null;
+    }
+    return {
+      type: 'linear-gradient',
+      direction: direction,
+      colorStops: colorStops
+    };
+  }
+  function parseColorStopsCSSString(parts) {
+    var colorStopsString = parts.join(',');
+    var colorStops = [];
+    var stops = colorStopsString.split(/,(?![^(]*\))/);
+    var prevStop = null;
+    for (var i = 0; i < stops.length; i++) {
+      var stop = stops[i];
+      var trimmedStop = stop.trim().toLowerCase();
+      var colorStopParts = trimmedStop.match(/\S+\([^)]*\)|\S+/g);
+      if (colorStopParts == null) {
+        return null;
+      }
+      if (colorStopParts.length === 3) {
+        var color = colorStopParts[0];
+        var position1 = getPositionFromCSSValue(colorStopParts[1]);
+        var position2 = getPositionFromCSSValue(colorStopParts[2]);
+        var processedColor = _$$_REQUIRE(_dependencyMap[3], "./processColor").default(color);
+        if (processedColor == null) {
+          return null;
+        }
+        if (position1 == null || position2 == null) {
+          return null;
+        }
+        colorStops.push({
+          color: processedColor,
+          position: position1
+        });
+        colorStops.push({
+          color: processedColor,
+          position: position2
+        });
+      } else if (colorStopParts.length === 2) {
+        var _color = colorStopParts[0];
+        var position = getPositionFromCSSValue(colorStopParts[1]);
+        var _processedColor = _$$_REQUIRE(_dependencyMap[3], "./processColor").default(_color);
+        if (_processedColor == null) {
+          return null;
+        }
+        if (position == null) {
+          return null;
+        }
+        colorStops.push({
+          color: _processedColor,
+          position: position
+        });
+      } else if (colorStopParts.length === 1) {
+        var _position2 = getPositionFromCSSValue(colorStopParts[0]);
+        if (_position2 != null) {
+          if (prevStop != null && prevStop.length === 1 && getPositionFromCSSValue(prevStop[0]) != null || i === stops.length - 1 || i === 0) {
+            return null;
+          }
+          colorStops.push({
+            color: null,
+            position: _position2
+          });
+        } else {
+          var _processedColor2 = _$$_REQUIRE(_dependencyMap[3], "./processColor").default(colorStopParts[0]);
+          if (_processedColor2 == null) {
+            return null;
+          }
+          colorStops.push({
+            color: _processedColor2,
+            position: null
+          });
+        }
+      } else {
+        return null;
+      }
+      prevStop = colorStopParts;
+    }
+    return colorStops;
+  }
+  function getDirectionForKeyword(direction) {
+    if (direction == null) {
+      return null;
+    }
+    var normalized = direction.replace(/\s+/g, ' ').toLowerCase();
+    switch (normalized) {
+      case 'to top':
+        return {
+          type: 'angle',
+          value: 0
+        };
+      case 'to right':
+        return {
+          type: 'angle',
+          value: 90
+        };
+      case 'to bottom':
+        return {
+          type: 'angle',
+          value: 180
+        };
+      case 'to left':
+        return {
+          type: 'angle',
+          value: 270
+        };
+      case 'to top right':
+      case 'to right top':
+        return {
+          type: 'keyword',
+          value: 'to top right'
+        };
+      case 'to bottom right':
+      case 'to right bottom':
+        return {
+          type: 'keyword',
+          value: 'to bottom right'
+        };
+      case 'to top left':
+      case 'to left top':
+        return {
+          type: 'keyword',
+          value: 'to top left'
+        };
+      case 'to bottom left':
+      case 'to left bottom':
+        return {
+          type: 'keyword',
+          value: 'to bottom left'
+        };
+      default:
+        return null;
+    }
+  }
+  function getAngleInDegrees(angle) {
+    if (angle == null) {
+      return null;
+    }
+    var match = angle.match(LINEAR_GRADIENT_ANGLE_UNIT_REGEX);
+    if (!match) {
+      return null;
+    }
+    var _match2 = (0, _slicedToArray2.default)(match, 3),
+      value = _match2[1],
+      unit = _match2[2];
+    var numericValue = parseFloat(value);
+    switch (unit) {
+      case 'deg':
+        return numericValue;
+      case 'grad':
+        return numericValue * 0.9;
+      case 'rad':
+        return numericValue * 180 / Math.PI;
+      case 'turn':
+        return numericValue * 360;
+      default:
+        return null;
+    }
+  }
+  function getPositionFromCSSValue(position) {
+    if (position.endsWith('px')) {
+      return parseFloat(position);
+    }
+    if (position.endsWith('%')) {
+      return position;
+    }
+  }
+  function splitGradients(input) {
+    var result = [];
+    var current = '';
+    var depth = 0;
+    for (var i = 0; i < input.length; i++) {
+      var char = input[i];
+      if (char === '(') {
+        depth++;
+      } else if (char === ')') {
+        depth--;
+      } else if (char === ',' && depth === 0) {
+        result.push(current.trim());
+        current = '';
+        continue;
+      }
+      current += char;
+    }
+    if (current.trim() !== '') {
+      result.push(current.trim());
+    }
+    return result;
+  }
+},56,[1,42,34,57],"../../node_modules/react-native/Libraries/StyleSheet/processBackgroundImage.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  function processColor(color) {
+    if (color === undefined || color === null) {
+      return color;
+    }
+    var normalizedColor = _$$_REQUIRE(_dependencyMap[0], "./normalizeColor").default(color);
+    if (normalizedColor === null || normalizedColor === undefined) {
+      return undefined;
+    }
+    if (typeof normalizedColor === 'object') {
+      var processColorObject = _$$_REQUIRE(_dependencyMap[1], "./PlatformColorValueTypes").processColorObject;
+      var processedColorObj = processColorObject(normalizedColor);
+      if (processedColorObj != null) {
+        return processedColorObj;
+      }
+    }
+    if (typeof normalizedColor !== 'number') {
+      return null;
+    }
+    normalizedColor = (normalizedColor << 24 | normalizedColor >>> 8) >>> 0;
+    if ("ios" === 'android') {
+      normalizedColor = normalizedColor | 0x0;
+    }
+    return normalizedColor;
+  }
+  var _default = exports.default = processColor;
+},57,[58,60],"../../node_modules/react-native/Libraries/StyleSheet/processColor.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _normalizeColors = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@react-native/normalize-colors"));
+  function normalizeColor(color) {
+    if (typeof color === 'object' && color != null) {
+      var _require = _$$_REQUIRE(_dependencyMap[2], "./PlatformColorValueTypes"),
+        normalizeColorObject = _require.normalizeColorObject;
+      var normalizedColor = normalizeColorObject(color);
+      if (normalizedColor != null) {
+        return normalizedColor;
+      }
+    }
+    if (typeof color === 'string' || typeof color === 'number') {
+      return (0, _normalizeColors.default)(color);
+    }
+  }
+  var _default = exports.default = normalizeColor;
+},58,[1,59,60],"../../node_modules/react-native/Libraries/StyleSheet/normalizeColor.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  /**
+   * 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.
+   *
+   * @format
+   * 
+   */
+
+  /* eslint no-bitwise: 0 */
+
+  'use strict';
+
+  function normalizeColor(color) {
+    if (typeof color === 'number') {
+      if (color >>> 0 === color && color >= 0 && color <= 0xffffffff) {
+        return color;
+      }
+      return null;
+    }
+    if (typeof color !== 'string') {
+      return null;
+    }
+    var matchers = getMatchers();
+    var match;
+
+    // Ordered based on occurrences on Facebook codebase
+    if (match = matchers.hex6.exec(color)) {
+      return parseInt(match[1] + 'ff', 16) >>> 0;
+    }
+    var colorFromKeyword = normalizeKeyword(color);
+    if (colorFromKeyword != null) {
+      return colorFromKeyword;
+    }
+    if (match = matchers.rgba.exec(color) || matchers.rgb.exec(color)) {
+      // rgb(R G B / A) / rgba(R G B / A) notation
+      if (match[9] !== undefined) {
+        return (parse255(match[9]) << 24 |
+        // r
+        parse255(match[10]) << 16 |
+        // g
+        parse255(match[11]) << 8 |
+        // b
+        parse1(match[12])) >>>
+        // a
+        0;
+      }
+      // rgb(R, G, B, A) / rgba(R, G, B, A) notation
+      else if (match[5] !== undefined) {
+        return (parse255(match[5]) << 24 |
+        // r
+        parse255(match[6]) << 16 |
+        // g
+        parse255(match[7]) << 8 |
+        // b
+        parse1(match[8])) >>>
+        // a
+        0;
+      }
+      // rgb(R, G, B) / rgba(R, G, B) notation
+      return (parse255(match[2]) << 24 |
+      // r
+      parse255(match[3]) << 16 |
+      // g
+      parse255(match[4]) << 8 |
+      // b
+      0x000000ff) >>>
+      // a
+      0;
+    }
+    if (match = matchers.hex3.exec(color)) {
+      return parseInt(match[1] + match[1] +
+      // r
+      match[2] + match[2] +
+      // g
+      match[3] + match[3] +
+      // b
+      'ff',
+      // a
+      16) >>> 0;
+    }
+
+    // https://drafts.csswg.org/css-color-4/#hex-notation
+    if (match = matchers.hex8.exec(color)) {
+      return parseInt(match[1], 16) >>> 0;
+    }
+    if (match = matchers.hex4.exec(color)) {
+      return parseInt(match[1] + match[1] +
+      // r
+      match[2] + match[2] +
+      // g
+      match[3] + match[3] +
+      // b
+      match[4] + match[4],
+      // a
+      16) >>> 0;
+    }
+    if (match = matchers.hsl.exec(color)) {
+      return (hslToRgb(parse360(match[1]),
+      // h
+      parsePercentage(match[2]),
+      // s
+      parsePercentage(match[3]) // l
+      ) | 0x000000ff) >>>
+      // a
+      0;
+    }
+    if (match = matchers.hsla.exec(color)) {
+      // hsla(H S L / A) notation
+      if (match[6] !== undefined) {
+        return (hslToRgb(parse360(match[6]),
+        // h
+        parsePercentage(match[7]),
+        // s
+        parsePercentage(match[8]) // l
+        ) | parse1(match[9])) >>>
+        // a
+        0;
+      }
+
+      // hsla(H, S, L, A) notation
+      return (hslToRgb(parse360(match[2]),
+      // h
+      parsePercentage(match[3]),
+      // s
+      parsePercentage(match[4]) // l
+      ) | parse1(match[5])) >>>
+      // a
+      0;
+    }
+    if (match = matchers.hwb.exec(color)) {
+      if (match[5] !== undefined) {
+        // hwb(H W B / A) notation
+        return (hwbToRgb(parse360(match[5]),
+        // h
+        parsePercentage(match[6]),
+        // w
+        parsePercentage(match[7]) // b
+        ) | parse1(match[8])) >>>
+        // a
+        0;
+      }
+      // hwb(H W B) notation
+      return (hwbToRgb(parse360(match[2]),
+      // h
+      parsePercentage(match[3]),
+      // w
+      parsePercentage(match[4]) // b
+      ) | 0x000000ff) >>>
+      // a
+      0;
+    }
+    return null;
+  }
+  function hue2rgb(p, q, t) {
+    if (t < 0) {
+      t += 1;
+    }
+    if (t > 1) {
+      t -= 1;
+    }
+    if (t < 1 / 6) {
+      return p + (q - p) * 6 * t;
+    }
+    if (t < 1 / 2) {
+      return q;
+    }
+    if (t < 2 / 3) {
+      return p + (q - p) * (2 / 3 - t) * 6;
+    }
+    return p;
+  }
+  function hslToRgb(h, s, l) {
+    var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    var p = 2 * l - q;
+    var r = hue2rgb(p, q, h + 1 / 3);
+    var g = hue2rgb(p, q, h);
+    var b = hue2rgb(p, q, h - 1 / 3);
+    return Math.round(r * 255) << 24 | Math.round(g * 255) << 16 | Math.round(b * 255) << 8;
+  }
+  function hwbToRgb(h, w, b) {
+    if (w + b >= 1) {
+      var gray = Math.round(w * 255 / (w + b));
+      return gray << 24 | gray << 16 | gray << 8;
+    }
+    var red = hue2rgb(0, 1, h + 1 / 3) * (1 - w - b) + w;
+    var green = hue2rgb(0, 1, h) * (1 - w - b) + w;
+    var blue = hue2rgb(0, 1, h - 1 / 3) * (1 - w - b) + w;
+    return Math.round(red * 255) << 24 | Math.round(green * 255) << 16 | Math.round(blue * 255) << 8;
+  }
+  var NUMBER = '[-+]?\\d*\\.?\\d+';
+  var PERCENTAGE = NUMBER + '%';
+  function call() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return '\\(\\s*(' + args.join(')\\s*,?\\s*(') + ')\\s*\\)';
+  }
+  function callModern() {
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    return '\\(\\s*(' + args.join(')\\s*(') + ')\\s*\\)';
+  }
+  function callWithSlashSeparator() {
+    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+      args[_key3] = arguments[_key3];
+    }
+    return '\\(\\s*(' + args.slice(0, args.length - 1).join(')\\s*,?\\s*(') + ')\\s*/\\s*(' + args[args.length - 1] + ')\\s*\\)';
+  }
+  function commaSeparatedCall() {
+    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+      args[_key4] = arguments[_key4];
+    }
+    return '\\(\\s*(' + args.join(')\\s*,\\s*(') + ')\\s*\\)';
+  }
+  var cachedMatchers;
+  function getMatchers() {
+    if (cachedMatchers === undefined) {
+      var rgbRegexPattern = call(NUMBER, NUMBER, NUMBER) + '|' + commaSeparatedCall(NUMBER, NUMBER, NUMBER, NUMBER) + '|' + callWithSlashSeparator(NUMBER, NUMBER, NUMBER, NUMBER);
+      cachedMatchers = {
+        rgb: new RegExp('rgb(' + rgbRegexPattern + ')'),
+        rgba: new RegExp('rgba(' + rgbRegexPattern + ')'),
+        hsl: new RegExp('hsl' + call(NUMBER, PERCENTAGE, PERCENTAGE)),
+        hsla: new RegExp('hsla(' + commaSeparatedCall(NUMBER, PERCENTAGE, PERCENTAGE, NUMBER) + '|' + callWithSlashSeparator(NUMBER, PERCENTAGE, PERCENTAGE, NUMBER) + ')'),
+        hwb: new RegExp('hwb(' + callModern(NUMBER, PERCENTAGE, PERCENTAGE) + '|' + callWithSlashSeparator(NUMBER, PERCENTAGE, PERCENTAGE, NUMBER) + ')'),
+        hex3: /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+        hex4: /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+        hex6: /^#([0-9a-fA-F]{6})$/,
+        hex8: /^#([0-9a-fA-F]{8})$/
+      };
+    }
+    return cachedMatchers;
+  }
+  function parse255(str) {
+    var int = parseInt(str, 10);
+    if (int < 0) {
+      return 0;
+    }
+    if (int > 255) {
+      return 255;
+    }
+    return int;
+  }
+  function parse360(str) {
+    var int = parseFloat(str);
+    return (int % 360 + 360) % 360 / 360;
+  }
+  function parse1(str) {
+    var num = parseFloat(str);
+    if (num < 0) {
+      return 0;
+    }
+    if (num > 1) {
+      return 255;
+    }
+    return Math.round(num * 255);
+  }
+  function parsePercentage(str) {
+    // parseFloat conveniently ignores the final %
+    var int = parseFloat(str);
+    if (int < 0) {
+      return 0;
+    }
+    if (int > 100) {
+      return 1;
+    }
+    return int / 100;
+  }
+  function normalizeKeyword(name) {
+    // prettier-ignore
+    switch (name) {
+      case 'transparent':
+        return 0x00000000;
+      // http://www.w3.org/TR/css3-color/#svg-color
+      case 'aliceblue':
+        return 0xf0f8ffff;
+      case 'antiquewhite':
+        return 0xfaebd7ff;
+      case 'aqua':
+        return 0x00ffffff;
+      case 'aquamarine':
+        return 0x7fffd4ff;
+      case 'azure':
+        return 0xf0ffffff;
+      case 'beige':
+        return 0xf5f5dcff;
+      case 'bisque':
+        return 0xffe4c4ff;
+      case 'black':
+        return 0x000000ff;
+      case 'blanchedalmond':
+        return 0xffebcdff;
+      case 'blue':
+        return 0x0000ffff;
+      case 'blueviolet':
+        return 0x8a2be2ff;
+      case 'brown':
+        return 0xa52a2aff;
+      case 'burlywood':
+        return 0xdeb887ff;
+      case 'burntsienna':
+        return 0xea7e5dff;
+      case 'cadetblue':
+        return 0x5f9ea0ff;
+      case 'chartreuse':
+        return 0x7fff00ff;
+      case 'chocolate':
+        return 0xd2691eff;
+      case 'coral':
+        return 0xff7f50ff;
+      case 'cornflowerblue':
+        return 0x6495edff;
+      case 'cornsilk':
+        return 0xfff8dcff;
+      case 'crimson':
+        return 0xdc143cff;
+      case 'cyan':
+        return 0x00ffffff;
+      case 'darkblue':
+        return 0x00008bff;
+      case 'darkcyan':
+        return 0x008b8bff;
+      case 'darkgoldenrod':
+        return 0xb8860bff;
+      case 'darkgray':
+        return 0xa9a9a9ff;
+      case 'darkgreen':
+        return 0x006400ff;
+      case 'darkgrey':
+        return 0xa9a9a9ff;
+      case 'darkkhaki':
+        return 0xbdb76bff;
+      case 'darkmagenta':
+        return 0x8b008bff;
+      case 'darkolivegreen':
+        return 0x556b2fff;
+      case 'darkorange':
+        return 0xff8c00ff;
+      case 'darkorchid':
+        return 0x9932ccff;
+      case 'darkred':
+        return 0x8b0000ff;
+      case 'darksalmon':
+        return 0xe9967aff;
+      case 'darkseagreen':
+        return 0x8fbc8fff;
+      case 'darkslateblue':
+        return 0x483d8bff;
+      case 'darkslategray':
+        return 0x2f4f4fff;
+      case 'darkslategrey':
+        return 0x2f4f4fff;
+      case 'darkturquoise':
+        return 0x00ced1ff;
+      case 'darkviolet':
+        return 0x9400d3ff;
+      case 'deeppink':
+        return 0xff1493ff;
+      case 'deepskyblue':
+        return 0x00bfffff;
+      case 'dimgray':
+        return 0x696969ff;
+      case 'dimgrey':
+        return 0x696969ff;
+      case 'dodgerblue':
+        return 0x1e90ffff;
+      case 'firebrick':
+        return 0xb22222ff;
+      case 'floralwhite':
+        return 0xfffaf0ff;
+      case 'forestgreen':
+        return 0x228b22ff;
+      case 'fuchsia':
+        return 0xff00ffff;
+      case 'gainsboro':
+        return 0xdcdcdcff;
+      case 'ghostwhite':
+        return 0xf8f8ffff;
+      case 'gold':
+        return 0xffd700ff;
+      case 'goldenrod':
+        return 0xdaa520ff;
+      case 'gray':
+        return 0x808080ff;
+      case 'green':
+        return 0x008000ff;
+      case 'greenyellow':
+        return 0xadff2fff;
+      case 'grey':
+        return 0x808080ff;
+      case 'honeydew':
+        return 0xf0fff0ff;
+      case 'hotpink':
+        return 0xff69b4ff;
+      case 'indianred':
+        return 0xcd5c5cff;
+      case 'indigo':
+        return 0x4b0082ff;
+      case 'ivory':
+        return 0xfffff0ff;
+      case 'khaki':
+        return 0xf0e68cff;
+      case 'lavender':
+        return 0xe6e6faff;
+      case 'lavenderblush':
+        return 0xfff0f5ff;
+      case 'lawngreen':
+        return 0x7cfc00ff;
+      case 'lemonchiffon':
+        return 0xfffacdff;
+      case 'lightblue':
+        return 0xadd8e6ff;
+      case 'lightcoral':
+        return 0xf08080ff;
+      case 'lightcyan':
+        return 0xe0ffffff;
+      case 'lightgoldenrodyellow':
+        return 0xfafad2ff;
+      case 'lightgray':
+        return 0xd3d3d3ff;
+      case 'lightgreen':
+        return 0x90ee90ff;
+      case 'lightgrey':
+        return 0xd3d3d3ff;
+      case 'lightpink':
+        return 0xffb6c1ff;
+      case 'lightsalmon':
+        return 0xffa07aff;
+      case 'lightseagreen':
+        return 0x20b2aaff;
+      case 'lightskyblue':
+        return 0x87cefaff;
+      case 'lightslategray':
+        return 0x778899ff;
+      case 'lightslategrey':
+        return 0x778899ff;
+      case 'lightsteelblue':
+        return 0xb0c4deff;
+      case 'lightyellow':
+        return 0xffffe0ff;
+      case 'lime':
+        return 0x00ff00ff;
+      case 'limegreen':
+        return 0x32cd32ff;
+      case 'linen':
+        return 0xfaf0e6ff;
+      case 'magenta':
+        return 0xff00ffff;
+      case 'maroon':
+        return 0x800000ff;
+      case 'mediumaquamarine':
+        return 0x66cdaaff;
+      case 'mediumblue':
+        return 0x0000cdff;
+      case 'mediumorchid':
+        return 0xba55d3ff;
+      case 'mediumpurple':
+        return 0x9370dbff;
+      case 'mediumseagreen':
+        return 0x3cb371ff;
+      case 'mediumslateblue':
+        return 0x7b68eeff;
+      case 'mediumspringgreen':
+        return 0x00fa9aff;
+      case 'mediumturquoise':
+        return 0x48d1ccff;
+      case 'mediumvioletred':
+        return 0xc71585ff;
+      case 'midnightblue':
+        return 0x191970ff;
+      case 'mintcream':
+        return 0xf5fffaff;
+      case 'mistyrose':
+        return 0xffe4e1ff;
+      case 'moccasin':
+        return 0xffe4b5ff;
+      case 'navajowhite':
+        return 0xffdeadff;
+      case 'navy':
+        return 0x000080ff;
+      case 'oldlace':
+        return 0xfdf5e6ff;
+      case 'olive':
+        return 0x808000ff;
+      case 'olivedrab':
+        return 0x6b8e23ff;
+      case 'orange':
+        return 0xffa500ff;
+      case 'orangered':
+        return 0xff4500ff;
+      case 'orchid':
+        return 0xda70d6ff;
+      case 'palegoldenrod':
+        return 0xeee8aaff;
+      case 'palegreen':
+        return 0x98fb98ff;
+      case 'paleturquoise':
+        return 0xafeeeeff;
+      case 'palevioletred':
+        return 0xdb7093ff;
+      case 'papayawhip':
+        return 0xffefd5ff;
+      case 'peachpuff':
+        return 0xffdab9ff;
+      case 'peru':
+        return 0xcd853fff;
+      case 'pink':
+        return 0xffc0cbff;
+      case 'plum':
+        return 0xdda0ddff;
+      case 'powderblue':
+        return 0xb0e0e6ff;
+      case 'purple':
+        return 0x800080ff;
+      case 'rebeccapurple':
+        return 0x663399ff;
+      case 'red':
+        return 0xff0000ff;
+      case 'rosybrown':
+        return 0xbc8f8fff;
+      case 'royalblue':
+        return 0x4169e1ff;
+      case 'saddlebrown':
+        return 0x8b4513ff;
+      case 'salmon':
+        return 0xfa8072ff;
+      case 'sandybrown':
+        return 0xf4a460ff;
+      case 'seagreen':
+        return 0x2e8b57ff;
+      case 'seashell':
+        return 0xfff5eeff;
+      case 'sienna':
+        return 0xa0522dff;
+      case 'silver':
+        return 0xc0c0c0ff;
+      case 'skyblue':
+        return 0x87ceebff;
+      case 'slateblue':
+        return 0x6a5acdff;
+      case 'slategray':
+        return 0x708090ff;
+      case 'slategrey':
+        return 0x708090ff;
+      case 'snow':
+        return 0xfffafaff;
+      case 'springgreen':
+        return 0x00ff7fff;
+      case 'steelblue':
+        return 0x4682b4ff;
+      case 'tan':
+        return 0xd2b48cff;
+      case 'teal':
+        return 0x008080ff;
+      case 'thistle':
+        return 0xd8bfd8ff;
+      case 'tomato':
+        return 0xff6347ff;
+      case 'turquoise':
+        return 0x40e0d0ff;
+      case 'violet':
+        return 0xee82eeff;
+      case 'wheat':
+        return 0xf5deb3ff;
+      case 'white':
+        return 0xffffffff;
+      case 'whitesmoke':
+        return 0xf5f5f5ff;
+      case 'yellow':
+        return 0xffff00ff;
+      case 'yellowgreen':
+        return 0x9acd32ff;
+    }
+    return null;
+  }
+  module.exports = normalizeColor;
+},59,[],"../../node_modules/@react-native/normalize-colors/index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.processColorObject = exports.normalizeColorObject = exports.PlatformColor = exports.DynamicColorIOSPrivate = void 0;
+  var PlatformColor = exports.PlatformColor = function PlatformColor() {
+    for (var _len = arguments.length, names = new Array(_len), _key = 0; _key < _len; _key++) {
+      names[_key] = arguments[_key];
+    }
+    return {
+      semantic: names
+    };
+  };
+  var DynamicColorIOSPrivate = exports.DynamicColorIOSPrivate = function DynamicColorIOSPrivate(tuple) {
+    return {
+      dynamic: {
+        light: tuple.light,
+        dark: tuple.dark,
+        highContrastLight: tuple.highContrastLight,
+        highContrastDark: tuple.highContrastDark
+      }
+    };
+  };
+  var _normalizeColorObject = function _normalizeColorObject(color) {
+    if ('semantic' in color) {
+      return color;
+    } else if ('dynamic' in color && color.dynamic !== undefined) {
+      var normalizeColor = _$$_REQUIRE(_dependencyMap[0], "./normalizeColor").default;
+      var dynamic = color.dynamic;
+      var dynamicColor = {
+        dynamic: {
+          light: normalizeColor(dynamic.light),
+          dark: normalizeColor(dynamic.dark),
+          highContrastLight: normalizeColor(dynamic.highContrastLight),
+          highContrastDark: normalizeColor(dynamic.highContrastDark)
+        }
+      };
+      return dynamicColor;
+    }
+    return null;
+  };
+  var normalizeColorObject = exports.normalizeColorObject = _normalizeColorObject;
+  var _processColorObject = function _processColorObject(color) {
+    if ('dynamic' in color && color.dynamic != null) {
+      var processColor = _$$_REQUIRE(_dependencyMap[1], "./processColor").default;
+      var dynamic = color.dynamic;
+      var dynamicColor = {
+        dynamic: {
+          light: processColor(dynamic.light),
+          dark: processColor(dynamic.dark),
+          highContrastLight: processColor(dynamic.highContrastLight),
+          highContrastDark: processColor(dynamic.highContrastDark)
+        }
+      };
+      return dynamicColor;
+    }
+    return color;
+  };
+  var processColorObject = exports.processColorObject = _processColorObject;
+},60,[58,57],"../../node_modules/react-native/Libraries/StyleSheet/PlatformColorValueTypes.ios.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = processBoxShadow;
+  var _processColor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./processColor"));
+  function processBoxShadow(rawBoxShadows) {
+    var result = [];
+    if (rawBoxShadows == null) {
+      return result;
+    }
+    var boxShadowList = typeof rawBoxShadows === 'string' ? parseBoxShadowString(rawBoxShadows.replace(/\n/g, ' ')) : rawBoxShadows;
+    for (var rawBoxShadow of boxShadowList) {
+      var parsedBoxShadow = {
+        offsetX: 0,
+        offsetY: 0
+      };
+      var value = void 0;
+      for (var arg in rawBoxShadow) {
+        switch (arg) {
+          case 'offsetX':
+            value = typeof rawBoxShadow.offsetX === 'string' ? parseLength(rawBoxShadow.offsetX) : rawBoxShadow.offsetX;
+            if (value == null) {
+              return [];
+            }
+            parsedBoxShadow.offsetX = value;
+            break;
+          case 'offsetY':
+            value = typeof rawBoxShadow.offsetY === 'string' ? parseLength(rawBoxShadow.offsetY) : rawBoxShadow.offsetY;
+            if (value == null) {
+              return [];
+            }
+            parsedBoxShadow.offsetY = value;
+            break;
+          case 'spreadDistance':
+            value = typeof rawBoxShadow.spreadDistance === 'string' ? parseLength(rawBoxShadow.spreadDistance) : rawBoxShadow.spreadDistance;
+            if (value == null) {
+              return [];
+            }
+            parsedBoxShadow.spreadDistance = value;
+            break;
+          case 'blurRadius':
+            value = typeof rawBoxShadow.blurRadius === 'string' ? parseLength(rawBoxShadow.blurRadius) : rawBoxShadow.blurRadius;
+            if (value == null || value < 0) {
+              return [];
+            }
+            parsedBoxShadow.blurRadius = value;
+            break;
+          case 'color':
+            var color = (0, _processColor.default)(rawBoxShadow.color);
+            if (color == null) {
+              return [];
+            }
+            parsedBoxShadow.color = color;
+            break;
+          case 'inset':
+            parsedBoxShadow.inset = rawBoxShadow.inset;
+        }
+      }
+      result.push(parsedBoxShadow);
+    }
+    return result;
+  }
+  function parseBoxShadowString(rawBoxShadows) {
+    var result = [];
+    for (var rawBoxShadow of rawBoxShadows.split(/,(?![^()]*\))/).map(function (bS) {
+      return bS.trim();
+    }).filter(function (bS) {
+      return bS !== '';
+    })) {
+      var boxShadow = {
+        offsetX: 0,
+        offsetY: 0
+      };
+      var offsetX = void 0;
+      var offsetY = void 0;
+      var keywordDetectedAfterLength = false;
+      var lengthCount = 0;
+      var args = rawBoxShadow.split(/\s+(?![^(]*\))/);
+      for (var arg of args) {
+        var processedColor = (0, _processColor.default)(arg);
+        if (processedColor != null) {
+          if (boxShadow.color != null) {
+            return [];
+          }
+          if (offsetX != null) {
+            keywordDetectedAfterLength = true;
+          }
+          boxShadow.color = arg;
+          continue;
+        }
+        if (arg === 'inset') {
+          if (boxShadow.inset != null) {
+            return [];
+          }
+          if (offsetX != null) {
+            keywordDetectedAfterLength = true;
+          }
+          boxShadow.inset = true;
+          continue;
+        }
+        switch (lengthCount) {
+          case 0:
+            offsetX = arg;
+            lengthCount++;
+            break;
+          case 1:
+            if (keywordDetectedAfterLength) {
+              return [];
+            }
+            offsetY = arg;
+            lengthCount++;
+            break;
+          case 2:
+            if (keywordDetectedAfterLength) {
+              return [];
+            }
+            boxShadow.blurRadius = arg;
+            lengthCount++;
+            break;
+          case 3:
+            if (keywordDetectedAfterLength) {
+              return [];
+            }
+            boxShadow.spreadDistance = arg;
+            lengthCount++;
+            break;
+          default:
+            return [];
+        }
+      }
+      if (offsetX == null || offsetY == null) {
+        return [];
+      }
+      boxShadow.offsetX = offsetX;
+      boxShadow.offsetY = offsetY;
+      result.push(boxShadow);
+    }
+    return result;
+  }
+  function parseLength(length) {
+    var argsWithUnitsRegex = /([+-]?\d*(\.\d+)?)([\w\W]+)?/g;
+    var match = argsWithUnitsRegex.exec(length);
+    if (!match || Number.isNaN(match[1])) {
+      return null;
+    }
+    if (match[3] != null && match[3] !== 'px') {
+      return null;
+    }
+    if (match[3] == null && match[1] !== '0') {
+      return null;
+    }
+    return Number(match[1]);
+  }
+},61,[1,57],"../../node_modules/react-native/Libraries/StyleSheet/processBoxShadow.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = processFilter;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _processColor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./processColor"));
+  function processFilter(filter) {
+    var result = [];
+    if (filter == null) {
+      return result;
+    }
+    if (typeof filter === 'string') {
+      filter = filter.replace(/\n/g, ' ');
+      var regex = /([\w-]+)\(([^()]*|\([^()]*\)|[^()]*\([^()]*\)[^()]*)\)/g;
+      var matches;
+      while (matches = regex.exec(filter)) {
+        var filterName = matches[1].toLowerCase();
+        if (filterName === 'drop-shadow') {
+          var dropShadow = parseDropShadow(matches[2]);
+          if (dropShadow != null) {
+            result.push({
+              dropShadow: dropShadow
+            });
+          } else {
+            return [];
+          }
+        } else {
+          var camelizedName = filterName === 'drop-shadow' ? 'dropShadow' : filterName === 'hue-rotate' ? 'hueRotate' : filterName;
+          var amount = _getFilterAmount(camelizedName, matches[2]);
+          if (amount != null) {
+            var filterFunction = {};
+            filterFunction[camelizedName] = amount;
+            result.push(filterFunction);
+          } else {
+            return [];
+          }
+        }
+      }
+    } else if (Array.isArray(filter)) {
+      for (var _filterFunction of filter) {
+        var _Object$entries$ = (0, _slicedToArray2.default)(Object.entries(_filterFunction)[0], 2),
+          _filterName = _Object$entries$[0],
+          filterValue = _Object$entries$[1];
+        if (_filterName === 'dropShadow') {
+          var _dropShadow = parseDropShadow(filterValue);
+          if (_dropShadow == null) {
+            return [];
+          }
+          result.push({
+            dropShadow: _dropShadow
+          });
+        } else {
+          var _amount = _getFilterAmount(_filterName, filterValue);
+          if (_amount != null) {
+            var resultObject = {};
+            resultObject[_filterName] = _amount;
+            result.push(resultObject);
+          } else {
+            return [];
+          }
+        }
+      }
+    } else {
+      throw new TypeError(`${typeof filter} filter is not a string or array`);
+    }
+    return result;
+  }
+  function _getFilterAmount(filterName, filterArgs) {
+    var filterArgAsNumber;
+    var unit;
+    if (typeof filterArgs === 'string') {
+      var argsWithUnitsRegex = new RegExp(/([+-]?\d*(\.\d+)?)([a-zA-Z%]+)?/g);
+      var match = argsWithUnitsRegex.exec(filterArgs);
+      if (!match || isNaN(Number(match[1]))) {
+        return undefined;
+      }
+      filterArgAsNumber = Number(match[1]);
+      unit = match[3];
+    } else if (typeof filterArgs === 'number') {
+      filterArgAsNumber = filterArgs;
+    } else {
+      return undefined;
+    }
+    switch (filterName) {
+      case 'hueRotate':
+        if (filterArgAsNumber === 0) {
+          return 0;
+        }
+        if (unit !== 'deg' && unit !== 'rad') {
+          return undefined;
+        }
+        return unit === 'rad' ? 180 * filterArgAsNumber / Math.PI : filterArgAsNumber;
+      case 'blur':
+        if (unit && unit !== 'px' || filterArgAsNumber < 0) {
+          return undefined;
+        }
+        return filterArgAsNumber;
+      case 'brightness':
+      case 'contrast':
+      case 'grayscale':
+      case 'invert':
+      case 'opacity':
+      case 'saturate':
+      case 'sepia':
+        if (unit && unit !== '%' && unit !== 'px' || filterArgAsNumber < 0) {
+          return undefined;
+        }
+        if (unit === '%') {
+          filterArgAsNumber /= 100;
+        }
+        return filterArgAsNumber;
+      default:
+        return undefined;
+    }
+  }
+  function parseDropShadow(rawDropShadow) {
+    var dropShadow = typeof rawDropShadow === 'string' ? parseDropShadowString(rawDropShadow) : rawDropShadow;
+    var parsedDropShadow = {
+      offsetX: 0,
+      offsetY: 0
+    };
+    var offsetX;
+    var offsetY;
+    for (var arg in dropShadow) {
+      var value = void 0;
+      switch (arg) {
+        case 'offsetX':
+          value = typeof dropShadow.offsetX === 'string' ? parseLength(dropShadow.offsetX) : dropShadow.offsetX;
+          if (value == null) {
+            return null;
+          }
+          offsetX = value;
+          break;
+        case 'offsetY':
+          value = typeof dropShadow.offsetY === 'string' ? parseLength(dropShadow.offsetY) : dropShadow.offsetY;
+          if (value == null) {
+            return null;
+          }
+          offsetY = value;
+          break;
+        case 'standardDeviation':
+          value = typeof dropShadow.standardDeviation === 'string' ? parseLength(dropShadow.standardDeviation) : dropShadow.standardDeviation;
+          if (value == null || value < 0) {
+            return null;
+          }
+          parsedDropShadow.standardDeviation = value;
+          break;
+        case 'color':
+          var color = (0, _processColor.default)(dropShadow.color);
+          if (color == null) {
+            return null;
+          }
+          parsedDropShadow.color = color;
+          break;
+        default:
+          return null;
+      }
+    }
+    if (offsetX == null || offsetY == null) {
+      return null;
+    }
+    parsedDropShadow.offsetX = offsetX;
+    parsedDropShadow.offsetY = offsetY;
+    return parsedDropShadow;
+  }
+  function parseDropShadowString(rawDropShadow) {
+    var dropShadow = {
+      offsetX: 0,
+      offsetY: 0
+    };
+    var offsetX;
+    var offsetY;
+    var lengthCount = 0;
+    var keywordDetectedAfterLength = false;
+    for (var arg of rawDropShadow.split(/\s+(?![^(]*\))/)) {
+      var processedColor = (0, _processColor.default)(arg);
+      if (processedColor != null) {
+        if (dropShadow.color != null) {
+          return null;
+        }
+        if (offsetX != null) {
+          keywordDetectedAfterLength = true;
+        }
+        dropShadow.color = arg;
+        continue;
+      }
+      switch (lengthCount) {
+        case 0:
+          offsetX = arg;
+          lengthCount++;
+          break;
+        case 1:
+          if (keywordDetectedAfterLength) {
+            return null;
+          }
+          offsetY = arg;
+          lengthCount++;
+          break;
+        case 2:
+          if (keywordDetectedAfterLength) {
+            return null;
+          }
+          dropShadow.standardDeviation = arg;
+          lengthCount++;
+          break;
+        default:
+          return null;
+      }
+    }
+    if (offsetX == null || offsetY == null) {
+      return null;
+    }
+    dropShadow.offsetX = offsetX;
+    dropShadow.offsetY = offsetY;
+    return dropShadow;
+  }
+  function parseLength(length) {
+    var argsWithUnitsRegex = /([+-]?\d*(\.\d+)?)([\w\W]+)?/g;
+    var match = argsWithUnitsRegex.exec(length);
+    if (!match || Number.isNaN(match[1])) {
+      return null;
+    }
+    if (match[3] != null && match[3] !== 'px') {
+      return null;
+    }
+    if (match[3] == null && match[1] !== '0') {
+      return null;
+    }
+    return Number(match[1]);
+  }
+},62,[1,34,57],"../../node_modules/react-native/Libraries/StyleSheet/processFilter.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  function processFontVariant(fontVariant) {
+    if (Array.isArray(fontVariant)) {
+      return fontVariant;
+    }
+    var match = fontVariant.split(' ').filter(Boolean);
+    return match;
+  }
+  var _default = exports.default = processFontVariant;
+},63,[],"../../node_modules/react-native/Libraries/StyleSheet/processFontVariant.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty"));
+  function processTransform(transform) {
+    if (typeof transform === 'string') {
+      var regex = new RegExp(/(\w+)\(([^)]+)\)/g);
+      var transformArray = [];
+      var matches;
+      while (matches = regex.exec(transform)) {
+        var _getKeyAndValueFromCS = _getKeyAndValueFromCSSTransform(matches[1], matches[2]),
+          _key = _getKeyAndValueFromCS.key,
+          value = _getKeyAndValueFromCS.value;
+        if (value !== undefined) {
+          transformArray.push((0, _defineProperty2.default)({}, _key, value));
+        }
+      }
+      transform = transformArray;
+    }
+    if (__DEV__) {
+      _validateTransforms(transform);
+    }
+    return transform;
+  }
+  var _getKeyAndValueFromCSSTransform = function _getKeyAndValueFromCSSTransform(key, args) {
+    var _args$match;
+    var argsWithUnitsRegex = new RegExp(/([+-]?\d+(\.\d+)?)([a-zA-Z]+|%)?/g);
+    switch (key) {
+      case 'matrix':
+        return {
+          key: key,
+          value: (_args$match = args.match(/[+-]?\d+(\.\d+)?/g)) == null ? void 0 : _args$match.map(Number)
+        };
+      case 'translate':
+      case 'translate3d':
+        var parsedArgs = [];
+        var missingUnitOfMeasurement = false;
+        var matches;
+        while (matches = argsWithUnitsRegex.exec(args)) {
+          var _value = Number(matches[1]);
+          var _unitOfMeasurement = matches[3];
+          if (_value !== 0 && !_unitOfMeasurement) {
+            missingUnitOfMeasurement = true;
+          }
+          if (_unitOfMeasurement === '%') {
+            parsedArgs.push(`${_value}%`);
+          } else {
+            parsedArgs.push(_value);
+          }
+        }
+        if (__DEV__) {
+          _$$_REQUIRE(_dependencyMap[2], "invariant")(!missingUnitOfMeasurement, `Transform with key ${key} must have units unless the provided value is 0, found %s`, `${key}(${args})`);
+          if (key === 'translate') {
+            _$$_REQUIRE(_dependencyMap[2], "invariant")((parsedArgs == null ? void 0 : parsedArgs.length) === 1 || (parsedArgs == null ? void 0 : parsedArgs.length) === 2, 'Transform with key translate must be an string with 1 or 2 parameters, found %s: %s', parsedArgs == null ? void 0 : parsedArgs.length, `${key}(${args})`);
+          } else {
+            _$$_REQUIRE(_dependencyMap[2], "invariant")((parsedArgs == null ? void 0 : parsedArgs.length) === 3, 'Transform with key translate3d must be an string with 3 parameters, found %s: %s', parsedArgs == null ? void 0 : parsedArgs.length, `${key}(${args})`);
+          }
+        }
+        if ((parsedArgs == null ? void 0 : parsedArgs.length) === 1) {
+          parsedArgs.push(0);
+        }
+        return {
+          key: 'translate',
+          value: parsedArgs
+        };
+      case 'translateX':
+      case 'translateY':
+      case 'perspective':
+        var argMatches = argsWithUnitsRegex.exec(args);
+        if (!(argMatches != null && argMatches.length)) {
+          return {
+            key: key,
+            value: undefined
+          };
+        }
+        var value = Number(argMatches[1]);
+        var unitOfMeasurement = argMatches[3];
+        if (__DEV__) {
+          _$$_REQUIRE(_dependencyMap[2], "invariant")(value === 0 || unitOfMeasurement, `Transform with key ${key} must have units unless the provided value is 0, found %s`, `${key}(${args})`);
+        }
+        return {
+          key: key,
+          value: value
+        };
+      default:
+        return {
+          key: key,
+          value: !isNaN(args) ? Number(args) : args
+        };
+    }
+  };
+  function _validateTransforms(transform) {
+    transform.forEach(function (transformation) {
+      var keys = Object.keys(transformation);
+      _$$_REQUIRE(_dependencyMap[2], "invariant")(keys.length === 1, 'You must specify exactly one property per transform object. Passed properties: %s', _$$_REQUIRE(_dependencyMap[3], "../Utilities/stringifySafe").default(transformation));
+      var key = keys[0];
+      var value = transformation[key];
+      if (key === 'matrix' && transform.length > 1) {
+        console.error('When using a matrix transform, you must specify exactly one transform object. Passed transform: ' + _$$_REQUIRE(_dependencyMap[3], "../Utilities/stringifySafe").default(transform));
+      }
+      _validateTransform(key, value, transformation);
+    });
+  }
+  function _validateTransform(key, value, transformation) {
+    _$$_REQUIRE(_dependencyMap[2], "invariant")(!value.getValue, 'You passed an Animated.Value to a normal component. ' + 'You need to wrap that component in an Animated. For example, ' + 'replace <View /> by <Animated.View />.');
+    var multivalueTransforms = ['matrix', 'translate'];
+    if (multivalueTransforms.indexOf(key) !== -1) {
+      _$$_REQUIRE(_dependencyMap[2], "invariant")(Array.isArray(value), 'Transform with key of %s must have an array as the value: %s', key, _$$_REQUIRE(_dependencyMap[3], "../Utilities/stringifySafe").default(transformation));
+    }
+    switch (key) {
+      case 'matrix':
+        _$$_REQUIRE(_dependencyMap[2], "invariant")(value.length === 9 || value.length === 16, 'Matrix transform must have a length of 9 (2d) or 16 (3d). ' + 'Provided matrix has a length of %s: %s', value.length, _$$_REQUIRE(_dependencyMap[3], "../Utilities/stringifySafe").default(transformation));
+        break;
+      case 'translate':
+        _$$_REQUIRE(_dependencyMap[2], "invariant")(value.length === 2 || value.length === 3, 'Transform with key translate must be an array of length 2 or 3, found %s: %s', value.length, _$$_REQUIRE(_dependencyMap[3], "../Utilities/stringifySafe").default(transformation));
+        break;
+      case 'rotateX':
+      case 'rotateY':
+      case 'rotateZ':
+      case 'rotate':
+      case 'skewX':
+      case 'skewY':
+        _$$_REQUIRE(_dependencyMap[2], "invariant")(typeof value === 'string', 'Transform with key of "%s" must be a string: %s', key, _$$_REQUIRE(_dependencyMap[3], "../Utilities/stringifySafe").default(transformation));
+        _$$_REQUIRE(_dependencyMap[2], "invariant")(value.indexOf('deg') > -1 || value.indexOf('rad') > -1, 'Rotate transform must be expressed in degrees (deg) or radians ' + '(rad): %s', _$$_REQUIRE(_dependencyMap[3], "../Utilities/stringifySafe").default(transformation));
+        break;
+      case 'perspective':
+        _$$_REQUIRE(_dependencyMap[2], "invariant")(typeof value === 'number', 'Transform with key of "%s" must be a number: %s', key, _$$_REQUIRE(_dependencyMap[3], "../Utilities/stringifySafe").default(transformation));
+        _$$_REQUIRE(_dependencyMap[2], "invariant")(value !== 0, 'Transform with key of "%s" cannot be zero: %s', key, _$$_REQUIRE(_dependencyMap[3], "../Utilities/stringifySafe").default(transformation));
+        break;
+      case 'translateX':
+      case 'translateY':
+        _$$_REQUIRE(_dependencyMap[2], "invariant")(typeof value === 'number' || typeof value === 'string' && value.endsWith('%'), 'Transform with key of "%s" must be number or a percentage. Passed value: %s.', key, _$$_REQUIRE(_dependencyMap[3], "../Utilities/stringifySafe").default(transformation));
+        break;
+      case 'scale':
+      case 'scaleX':
+      case 'scaleY':
+        _$$_REQUIRE(_dependencyMap[2], "invariant")(typeof value === 'number', 'Transform with key of "%s" must be a number: %s', key, _$$_REQUIRE(_dependencyMap[3], "../Utilities/stringifySafe").default(transformation));
+        break;
+      default:
+        _$$_REQUIRE(_dependencyMap[2], "invariant")(false, 'Invalid transform %s: %s', key, _$$_REQUIRE(_dependencyMap[3], "../Utilities/stringifySafe").default(transformation));
+    }
+  }
+  var _default = exports.default = processTransform;
+},64,[1,65,32,47],"../../node_modules/react-native/Libraries/StyleSheet/processTransform.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _defineProperty(e, r, t) {
+    return (r = _$$_REQUIRE(_dependencyMap[0], "./toPropertyKey.js")(r)) in e ? Object.defineProperty(e, r, {
+      value: t,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }) : e[r] = t, e;
+  }
+  module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},65,[13],"../../node_modules/@babel/runtime/helpers/defineProperty.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = processTransformOrigin;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "invariant"));
+  var INDEX_X = 0;
+  var INDEX_Y = 1;
+  var INDEX_Z = 2;
+  function processTransformOrigin(transformOrigin) {
+    if (typeof transformOrigin === 'string') {
+      var transformOriginString = transformOrigin;
+      var regex = /(top|bottom|left|right|center|\d+(?:%|px)|0)/gi;
+      var transformOriginArray = ['50%', '50%', 0];
+      var index = INDEX_X;
+      var matches;
+      outer: while (matches = regex.exec(transformOriginString)) {
+        var nextIndex = index + 1;
+        var value = matches[0];
+        var valueLower = value.toLowerCase();
+        switch (valueLower) {
+          case 'left':
+          case 'right':
+            {
+              (0, _invariant.default)(index === INDEX_X, 'Transform-origin %s can only be used for x-position', value);
+              transformOriginArray[INDEX_X] = valueLower === 'left' ? 0 : '100%';
+              break;
+            }
+          case 'top':
+          case 'bottom':
+            {
+              (0, _invariant.default)(index !== INDEX_Z, 'Transform-origin %s can only be used for y-position', value);
+              transformOriginArray[INDEX_Y] = valueLower === 'top' ? 0 : '100%';
+              if (index === INDEX_X) {
+                var horizontal = regex.exec(transformOriginString);
+                if (horizontal == null) {
+                  break outer;
+                }
+                switch (horizontal[0].toLowerCase()) {
+                  case 'left':
+                    transformOriginArray[INDEX_X] = 0;
+                    break;
+                  case 'right':
+                    transformOriginArray[INDEX_X] = '100%';
+                    break;
+                  case 'center':
+                    transformOriginArray[INDEX_X] = '50%';
+                    break;
+                  default:
+                    (0, _invariant.default)(false, 'Could not parse transform-origin: %s', transformOriginString);
+                }
+                nextIndex = INDEX_Z;
+              }
+              break;
+            }
+          case 'center':
+            {
+              (0, _invariant.default)(index !== INDEX_Z, 'Transform-origin value %s cannot be used for z-position', value);
+              transformOriginArray[index] = '50%';
+              break;
+            }
+          default:
+            {
+              if (value.endsWith('%')) {
+                transformOriginArray[index] = value;
+              } else {
+                transformOriginArray[index] = parseFloat(value);
+              }
+              break;
+            }
+        }
+        index = nextIndex;
+      }
+      transformOrigin = transformOriginArray;
+    }
+    if (__DEV__) {
+      _validateTransformOrigin(transformOrigin);
+    }
+    return transformOrigin;
+  }
+  function _validateTransformOrigin(transformOrigin) {
+    (0, _invariant.default)(transformOrigin.length === 3, 'Transform origin must have exactly 3 values.');
+    var _transformOrigin = (0, _slicedToArray2.default)(transformOrigin, 3),
+      x = _transformOrigin[0],
+      y = _transformOrigin[1],
+      z = _transformOrigin[2];
+    (0, _invariant.default)(typeof x === 'number' || typeof x === 'string' && x.endsWith('%'), 'Transform origin x-position must be a number. Passed value: %s.', x);
+    (0, _invariant.default)(typeof y === 'number' || typeof y === 'string' && y.endsWith('%'), 'Transform origin y-position must be a number. Passed value: %s.', y);
+    (0, _invariant.default)(typeof z === 'number', 'Transform origin z-position must be a number. Passed value: %s.', z);
+  }
+},66,[1,34,32],"../../node_modules/react-native/Libraries/StyleSheet/processTransformOrigin.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var dummySize = {
+    width: undefined,
+    height: undefined
+  };
+  function sizesDiffer(one, two) {
+    var defaultedOne = one || dummySize;
+    var defaultedTwo = two || dummySize;
+    return defaultedOne !== defaultedTwo && (defaultedOne.width !== defaultedTwo.width || defaultedOne.height !== defaultedTwo.height);
+  }
+  var _default = exports.default = sizesDiffer;
+},67,[],"../../node_modules/react-native/Libraries/Utilities/differ/sizesDiffer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _NativePlatformConstantsIOS = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativePlatformConstantsIOS"));
+  var Platform = {
+    __constants: null,
+    OS: 'ios',
+    get Version() {
+      return this.constants.osVersion;
+    },
+    get constants() {
+      if (this.__constants == null) {
+        this.__constants = _NativePlatformConstantsIOS.default.getConstants();
+      }
+      return this.__constants;
+    },
+    get isPad() {
+      return this.constants.interfaceIdiom === 'pad';
+    },
+    get isTV() {
+      return this.constants.interfaceIdiom === 'tv';
+    },
+    get isVision() {
+      return this.constants.interfaceIdiom === 'vision';
+    },
+    get isTesting() {
+      if (__DEV__) {
+        return this.constants.isTesting;
+      }
+      return false;
+    },
+    get isDisableAnimations() {
+      var _this$constants$isDis;
+      return (_this$constants$isDis = this.constants.isDisableAnimations) != null ? _this$constants$isDis : this.isTesting;
+    },
+    get isMacCatalyst() {
+      var _this$constants$isMac;
+      return (_this$constants$isMac = this.constants.isMacCatalyst) != null ? _this$constants$isMac : false;
+    },
+    select: function select(spec) {
+      return 'ios' in spec ? spec.ios : 'native' in spec ? spec.native : spec.default;
+    }
+  };
+  var _default = exports.default = Platform;
+},68,[1,69],"../../node_modules/react-native/Libraries/Utilities/Platform.ios.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativePlatformConstantsIOS = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativePlatformConstantsIOS"));
+  Object.keys(_NativePlatformConstantsIOS).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativePlatformConstantsIOS[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativePlatformConstantsIOS[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativePlatformConstantsIOS.default;
+},69,[70],"../../node_modules/react-native/Libraries/Utilities/NativePlatformConstantsIOS.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.getEnforcing('PlatformConstants');
+},70,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativePlatformConstantsIOS.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties"));
+  var _TextAncestor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../Text/TextAncestor"));
+  var _ViewNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./ViewNativeComponent"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[4], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[5], "react/jsx-runtime");
+  var _excluded = ["accessibilityElementsHidden", "accessibilityLabel", "accessibilityLabelledBy", "accessibilityLiveRegion", "accessibilityState", "accessibilityValue", "aria-busy", "aria-checked", "aria-disabled", "aria-expanded", "aria-hidden", "aria-label", "aria-labelledby", "aria-live", "aria-selected", "aria-valuemax", "aria-valuemin", "aria-valuenow", "aria-valuetext", "focusable", "id", "importantForAccessibility", "nativeID", "tabIndex"];
+  var _this = this,
+    _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Components/View/View.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var View = React.forwardRef(function (_ref, forwardedRef) {
+    var _ariaLabelledBy$split;
+    var accessibilityElementsHidden = _ref.accessibilityElementsHidden,
+      accessibilityLabel = _ref.accessibilityLabel,
+      accessibilityLabelledBy = _ref.accessibilityLabelledBy,
+      accessibilityLiveRegion = _ref.accessibilityLiveRegion,
+      accessibilityState = _ref.accessibilityState,
+      accessibilityValue = _ref.accessibilityValue,
+      ariaBusy = _ref['aria-busy'],
+      ariaChecked = _ref['aria-checked'],
+      ariaDisabled = _ref['aria-disabled'],
+      ariaExpanded = _ref['aria-expanded'],
+      ariaHidden = _ref['aria-hidden'],
+      ariaLabel = _ref['aria-label'],
+      ariaLabelledBy = _ref['aria-labelledby'],
+      ariaLive = _ref['aria-live'],
+      ariaSelected = _ref['aria-selected'],
+      ariaValueMax = _ref['aria-valuemax'],
+      ariaValueMin = _ref['aria-valuemin'],
+      ariaValueNow = _ref['aria-valuenow'],
+      ariaValueText = _ref['aria-valuetext'],
+      focusable = _ref.focusable,
+      id = _ref.id,
+      importantForAccessibility = _ref.importantForAccessibility,
+      nativeID = _ref.nativeID,
+      tabIndex = _ref.tabIndex,
+      otherProps = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+    var hasTextAncestor = React.useContext(_TextAncestor.default);
+    var _accessibilityLabelledBy = (_ariaLabelledBy$split = ariaLabelledBy == null ? void 0 : ariaLabelledBy.split(/\s*,\s*/g)) != null ? _ariaLabelledBy$split : accessibilityLabelledBy;
+    var _accessibilityState = accessibilityState != null || ariaBusy != null || ariaChecked != null || ariaDisabled != null || ariaExpanded != null || ariaSelected != null ? {
+      busy: ariaBusy != null ? ariaBusy : accessibilityState == null ? void 0 : accessibilityState.busy,
+      checked: ariaChecked != null ? ariaChecked : accessibilityState == null ? void 0 : accessibilityState.checked,
+      disabled: ariaDisabled != null ? ariaDisabled : accessibilityState == null ? void 0 : accessibilityState.disabled,
+      expanded: ariaExpanded != null ? ariaExpanded : accessibilityState == null ? void 0 : accessibilityState.expanded,
+      selected: ariaSelected != null ? ariaSelected : accessibilityState == null ? void 0 : accessibilityState.selected
+    } : undefined;
+    var _accessibilityValue = accessibilityValue != null || ariaValueMax != null || ariaValueMin != null || ariaValueNow != null || ariaValueText != null ? {
+      max: ariaValueMax != null ? ariaValueMax : accessibilityValue == null ? void 0 : accessibilityValue.max,
+      min: ariaValueMin != null ? ariaValueMin : accessibilityValue == null ? void 0 : accessibilityValue.min,
+      now: ariaValueNow != null ? ariaValueNow : accessibilityValue == null ? void 0 : accessibilityValue.now,
+      text: ariaValueText != null ? ariaValueText : accessibilityValue == null ? void 0 : accessibilityValue.text
+    } : undefined;
+    var actualView = /*#__PURE__*/(0, _jsxRuntime.jsx)(_ViewNativeComponent.default, Object.assign({}, otherProps, {
+      accessibilityLiveRegion: ariaLive === 'off' ? 'none' : ariaLive != null ? ariaLive : accessibilityLiveRegion,
+      accessibilityLabel: ariaLabel != null ? ariaLabel : accessibilityLabel,
+      focusable: tabIndex !== undefined ? !tabIndex : focusable,
+      accessibilityState: _accessibilityState,
+      accessibilityElementsHidden: ariaHidden != null ? ariaHidden : accessibilityElementsHidden,
+      accessibilityLabelledBy: _accessibilityLabelledBy,
+      accessibilityValue: _accessibilityValue,
+      importantForAccessibility: ariaHidden === true ? 'no-hide-descendants' : importantForAccessibility,
+      nativeID: id != null ? id : nativeID,
+      ref: forwardedRef
+    }));
+    if (hasTextAncestor) {
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(_TextAncestor.default.Provider, {
+        value: false,
+        children: actualView
+      });
+    }
+    return actualView;
+  });
+  View.displayName = 'View';
+  var _default = exports.default = View;
+},71,[1,4,72,76,73,171],"../../node_modules/react-native/Libraries/Components/View/View.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var React = _$$_REQUIRE(_dependencyMap[0], "react");
+  var TextAncestorContext = React.createContext(false);
+  if (__DEV__) {
+    TextAncestorContext.displayName = 'TextAncestorContext';
+  }
+  var _default = exports.default = TextAncestorContext;
+},72,[73],"../../node_modules/react-native/Libraries/Text/TextAncestor.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  if (process.env.NODE_ENV === 'production') {
+    module.exports = _$$_REQUIRE(_dependencyMap[0], "./cjs/react.production.js");
+  } else {
+    module.exports = _$$_REQUIRE(_dependencyMap[1], "./cjs/react.development.js");
+  }
+},73,[74,75],"../../node_modules/react/index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  /**
+   * @license React
+   * react.production.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_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
+    REACT_PORTAL_TYPE = Symbol.for("react.portal"),
+    REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
+    REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
+    REACT_PROFILER_TYPE = Symbol.for("react.profiler"),
+    REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
+    REACT_CONTEXT_TYPE = Symbol.for("react.context"),
+    REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
+    REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
+    REACT_MEMO_TYPE = Symbol.for("react.memo"),
+    REACT_LAZY_TYPE = Symbol.for("react.lazy"),
+    MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+  function getIteratorFn(maybeIterable) {
+    if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
+    maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
+    return "function" === typeof maybeIterable ? maybeIterable : null;
+  }
+  var ReactNoopUpdateQueue = {
+      isMounted: function isMounted() {
+        return !1;
+      },
+      enqueueForceUpdate: function enqueueForceUpdate() {},
+      enqueueReplaceState: function enqueueReplaceState() {},
+      enqueueSetState: function enqueueSetState() {}
+    },
+    assign = Object.assign,
+    emptyObject = {};
+  function Component(props, context, updater) {
+    this.props = props;
+    this.context = context;
+    this.refs = emptyObject;
+    this.updater = updater || ReactNoopUpdateQueue;
+  }
+  Component.prototype.isReactComponent = {};
+  Component.prototype.setState = function (partialState, callback) {
+    if ("object" !== typeof partialState && "function" !== typeof partialState && null != partialState) throw Error("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");
+  };
+  Component.prototype.forceUpdate = function (callback) {
+    this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
+  };
+  function ComponentDummy() {}
+  ComponentDummy.prototype = Component.prototype;
+  function PureComponent(props, context, updater) {
+    this.props = props;
+    this.context = context;
+    this.refs = emptyObject;
+    this.updater = updater || ReactNoopUpdateQueue;
+  }
+  var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
+  pureComponentPrototype.constructor = PureComponent;
+  assign(pureComponentPrototype, Component.prototype);
+  pureComponentPrototype.isPureReactComponent = !0;
+  var isArrayImpl = Array.isArray,
+    ReactSharedInternals = {
+      H: null,
+      A: null,
+      T: null,
+      S: null,
+      V: null
+    },
+    hasOwnProperty = Object.prototype.hasOwnProperty;
+  function ReactElement(type, key, self, source, owner, props) {
+    self = props.ref;
+    return {
+      $$typeof: REACT_ELEMENT_TYPE,
+      type: type,
+      key: key,
+      ref: void 0 !== self ? self : null,
+      props: props
+    };
+  }
+  function cloneAndReplaceKey(oldElement, newKey) {
+    return ReactElement(oldElement.type, newKey, void 0, void 0, void 0, oldElement.props);
+  }
+  function isValidElement(object) {
+    return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+  }
+  function escape(key) {
+    var escaperLookup = {
+      "=": "=0",
+      ":": "=2"
+    };
+    return "$" + key.replace(/[=:]/g, function (match) {
+      return escaperLookup[match];
+    });
+  }
+  var userProvidedKeyEscapeRegex = /\/+/g;
+  function getElementKey(element, index) {
+    return "object" === typeof element && null !== element && null != element.key ? escape("" + element.key) : index.toString(36);
+  }
+  function noop$1() {}
+  function resolveThenable(thenable) {
+    switch (thenable.status) {
+      case "fulfilled":
+        return thenable.value;
+      case "rejected":
+        throw thenable.reason;
+      default:
+        switch ("string" === typeof thenable.status ? thenable.then(noop$1, noop$1) : (thenable.status = "pending", thenable.then(function (fulfilledValue) {
+          "pending" === thenable.status && (thenable.status = "fulfilled", thenable.value = fulfilledValue);
+        }, function (error) {
+          "pending" === thenable.status && (thenable.status = "rejected", thenable.reason = error);
+        })), thenable.status) {
+          case "fulfilled":
+            return thenable.value;
+          case "rejected":
+            throw thenable.reason;
+        }
+    }
+    throw thenable;
+  }
+  function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
+    var type = typeof children;
+    if ("undefined" === type || "boolean" === type) children = null;
+    var invokeCallback = !1;
+    if (null === children) invokeCallback = !0;else switch (type) {
+      case "bigint":
+      case "string":
+      case "number":
+        invokeCallback = !0;
+        break;
+      case "object":
+        switch (children.$$typeof) {
+          case REACT_ELEMENT_TYPE:
+          case REACT_PORTAL_TYPE:
+            invokeCallback = !0;
+            break;
+          case REACT_LAZY_TYPE:
+            return invokeCallback = children._init, mapIntoArray(invokeCallback(children._payload), array, escapedPrefix, nameSoFar, callback);
+        }
+    }
+    if (invokeCallback) return callback = callback(children), invokeCallback = "" === nameSoFar ? "." + getElementKey(children, 0) : nameSoFar, isArrayImpl(callback) ? (escapedPrefix = "", null != invokeCallback && (escapedPrefix = invokeCallback.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array, escapedPrefix, "", function (c) {
+      return c;
+    })) : null != callback && (isValidElement(callback) && (callback = cloneAndReplaceKey(callback, escapedPrefix + (null == callback.key || children && children.key === callback.key ? "" : ("" + callback.key).replace(userProvidedKeyEscapeRegex, "$&/") + "/") + invokeCallback)), array.push(callback)), 1;
+    invokeCallback = 0;
+    var nextNamePrefix = "" === nameSoFar ? "." : nameSoFar + ":";
+    if (isArrayImpl(children)) for (var i = 0; i < children.length; i++) nameSoFar = children[i], type = nextNamePrefix + getElementKey(nameSoFar, i), invokeCallback += mapIntoArray(nameSoFar, array, escapedPrefix, type, callback);else if (i = getIteratorFn(children), "function" === typeof i) for (children = i.call(children), i = 0; !(nameSoFar = children.next()).done;) nameSoFar = nameSoFar.value, type = nextNamePrefix + getElementKey(nameSoFar, i++), invokeCallback += mapIntoArray(nameSoFar, array, escapedPrefix, type, callback);else if ("object" === type) {
+      if ("function" === typeof children.then) return mapIntoArray(resolveThenable(children), array, escapedPrefix, nameSoFar, callback);
+      array = String(children);
+      throw Error("Objects are not valid as a React child (found: " + ("[object Object]" === array ? "object with keys {" + Object.keys(children).join(", ") + "}" : array) + "). If you meant to render a collection of children, use an array instead.");
+    }
+    return invokeCallback;
+  }
+  function mapChildren(children, func, context) {
+    if (null == children) return children;
+    var result = [],
+      count = 0;
+    mapIntoArray(children, result, "", "", function (child) {
+      return func.call(context, child, count++);
+    });
+    return result;
+  }
+  function lazyInitializer(payload) {
+    if (-1 === payload._status) {
+      var ctor = payload._result;
+      ctor = ctor();
+      ctor.then(function (moduleObject) {
+        if (0 === payload._status || -1 === payload._status) payload._status = 1, payload._result = moduleObject;
+      }, function (error) {
+        if (0 === payload._status || -1 === payload._status) payload._status = 2, payload._result = error;
+      });
+      -1 === payload._status && (payload._status = 0, payload._result = ctor);
+    }
+    if (1 === payload._status) return payload._result.default;
+    throw payload._result;
+  }
+  var reportGlobalError = "function" === typeof reportError ? reportError : function (error) {
+    if ("object" === typeof window && "function" === typeof window.ErrorEvent) {
+      var event = new window.ErrorEvent("error", {
+        bubbles: !0,
+        cancelable: !0,
+        message: "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error),
+        error: error
+      });
+      if (!window.dispatchEvent(event)) return;
+    } else if ("object" === typeof process && "function" === typeof process.emit) {
+      process.emit("uncaughtException", error);
+      return;
+    }
+    console.error(error);
+  };
+  function noop() {}
+  exports.Children = {
+    map: mapChildren,
+    forEach: function forEach(children, forEachFunc, forEachContext) {
+      mapChildren(children, function () {
+        forEachFunc.apply(this, arguments);
+      }, forEachContext);
+    },
+    count: function count(children) {
+      var n = 0;
+      mapChildren(children, function () {
+        n++;
+      });
+      return n;
+    },
+    toArray: function toArray(children) {
+      return mapChildren(children, function (child) {
+        return child;
+      }) || [];
+    },
+    only: function only(children) {
+      if (!isValidElement(children)) throw Error("React.Children.only expected to receive a single React element child.");
+      return 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.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
+  exports.__COMPILER_RUNTIME = {
+    __proto__: null,
+    c: function c(size) {
+      return ReactSharedInternals.H.useMemoCache(size);
+    }
+  };
+  exports.cache = function (fn) {
+    return function () {
+      return fn.apply(null, arguments);
+    };
+  };
+  exports.cloneElement = function (element, config, children) {
+    if (null === element || void 0 === element) throw Error("The argument must be a React element, but you passed " + element + ".");
+    var props = assign({}, element.props),
+      key = element.key,
+      owner = void 0;
+    if (null != config) for (propName in void 0 !== config.ref && (owner = void 0), void 0 !== config.key && (key = "" + config.key), config) !hasOwnProperty.call(config, propName) || "key" === propName || "__self" === propName || "__source" === propName || "ref" === propName && void 0 === config.ref || (props[propName] = config[propName]);
+    var propName = arguments.length - 2;
+    if (1 === propName) props.children = children;else if (1 < propName) {
+      for (var childArray = Array(propName), i = 0; i < propName; i++) childArray[i] = arguments[i + 2];
+      props.children = childArray;
+    }
+    return ReactElement(element.type, key, void 0, void 0, owner, props);
+  };
+  exports.createContext = function (defaultValue) {
+    defaultValue = {
+      $$typeof: REACT_CONTEXT_TYPE,
+      _currentValue: defaultValue,
+      _currentValue2: defaultValue,
+      _threadCount: 0,
+      Provider: null,
+      Consumer: null
+    };
+    defaultValue.Provider = defaultValue;
+    defaultValue.Consumer = {
+      $$typeof: REACT_CONSUMER_TYPE,
+      _context: defaultValue
+    };
+    return defaultValue;
+  };
+  exports.createElement = function (type, config, children) {
+    var propName,
+      props = {},
+      key = null;
+    if (null != config) for (propName in void 0 !== config.key && (key = "" + config.key), config) hasOwnProperty.call(config, propName) && "key" !== propName && "__self" !== propName && "__source" !== propName && (props[propName] = config[propName]);
+    var childrenLength = arguments.length - 2;
+    if (1 === childrenLength) props.children = children;else if (1 < childrenLength) {
+      for (var childArray = Array(childrenLength), i = 0; i < childrenLength; i++) childArray[i] = arguments[i + 2];
+      props.children = childArray;
+    }
+    if (type && type.defaultProps) for (propName in childrenLength = type.defaultProps, childrenLength) void 0 === props[propName] && (props[propName] = childrenLength[propName]);
+    return ReactElement(type, key, void 0, void 0, null, props);
+  };
+  exports.createRef = function () {
+    return {
+      current: null
+    };
+  };
+  exports.forwardRef = function (render) {
+    return {
+      $$typeof: REACT_FORWARD_REF_TYPE,
+      render: render
+    };
+  };
+  exports.isValidElement = isValidElement;
+  exports.lazy = function (ctor) {
+    return {
+      $$typeof: REACT_LAZY_TYPE,
+      _payload: {
+        _status: -1,
+        _result: ctor
+      },
+      _init: lazyInitializer
+    };
+  };
+  exports.memo = function (type, compare) {
+    return {
+      $$typeof: REACT_MEMO_TYPE,
+      type: type,
+      compare: void 0 === compare ? null : compare
+    };
+  };
+  exports.startTransition = function (scope) {
+    var prevTransition = ReactSharedInternals.T,
+      currentTransition = {};
+    ReactSharedInternals.T = currentTransition;
+    try {
+      var returnValue = scope(),
+        onStartTransitionFinish = ReactSharedInternals.S;
+      null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
+      "object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && returnValue.then(noop, reportGlobalError);
+    } catch (error) {
+      reportGlobalError(error);
+    } finally {
+      ReactSharedInternals.T = prevTransition;
+    }
+  };
+  exports.unstable_useCacheRefresh = function () {
+    return ReactSharedInternals.H.useCacheRefresh();
+  };
+  exports.use = function (usable) {
+    return ReactSharedInternals.H.use(usable);
+  };
+  exports.useActionState = function (action, initialState, permalink) {
+    return ReactSharedInternals.H.useActionState(action, initialState, permalink);
+  };
+  exports.useCallback = function (callback, deps) {
+    return ReactSharedInternals.H.useCallback(callback, deps);
+  };
+  exports.useContext = function (Context) {
+    return ReactSharedInternals.H.useContext(Context);
+  };
+  exports.useDebugValue = function () {};
+  exports.useDeferredValue = function (value, initialValue) {
+    return ReactSharedInternals.H.useDeferredValue(value, initialValue);
+  };
+  exports.useEffect = function (create, createDeps, update) {
+    var dispatcher = ReactSharedInternals.H;
+    if ("function" === typeof update) throw Error("useEffect CRUD overload is not enabled in this build of React.");
+    return dispatcher.useEffect(create, createDeps);
+  };
+  exports.useId = function () {
+    return ReactSharedInternals.H.useId();
+  };
+  exports.useImperativeHandle = function (ref, create, deps) {
+    return ReactSharedInternals.H.useImperativeHandle(ref, create, deps);
+  };
+  exports.useInsertionEffect = function (create, deps) {
+    return ReactSharedInternals.H.useInsertionEffect(create, deps);
+  };
+  exports.useLayoutEffect = function (create, deps) {
+    return ReactSharedInternals.H.useLayoutEffect(create, deps);
+  };
+  exports.useMemo = function (create, deps) {
+    return ReactSharedInternals.H.useMemo(create, deps);
+  };
+  exports.useOptimistic = function (passthrough, reducer) {
+    return ReactSharedInternals.H.useOptimistic(passthrough, reducer);
+  };
+  exports.useReducer = function (reducer, initialArg, init) {
+    return ReactSharedInternals.H.useReducer(reducer, initialArg, init);
+  };
+  exports.useRef = function (initialValue) {
+    return ReactSharedInternals.H.useRef(initialValue);
+  };
+  exports.useState = function (initialState) {
+    return ReactSharedInternals.H.useState(initialState);
+  };
+  exports.useSyncExternalStore = function (subscribe, getSnapshot, getServerSnapshot) {
+    return ReactSharedInternals.H.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+  };
+  exports.useTransition = function () {
+    return ReactSharedInternals.H.useTransition();
+  };
+  exports.version = "19.1.0";
+},74,[],"../../node_modules/react/cjs/react.production.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  /**
+   * @license React
+   * react.development.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";
+
+  "production" !== process.env.NODE_ENV && function () {
+    function defineDeprecationWarning(methodName, info) {
+      Object.defineProperty(Component.prototype, methodName, {
+        get: function get() {
+          console.warn("%s(...) is deprecated in plain JavaScript React classes. %s", info[0], info[1]);
+        }
+      });
+    }
+    function getIteratorFn(maybeIterable) {
+      if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
+      maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
+      return "function" === typeof maybeIterable ? maybeIterable : null;
+    }
+    function warnNoop(publicInstance, callerName) {
+      publicInstance = (publicInstance = publicInstance.constructor) && (publicInstance.displayName || publicInstance.name) || "ReactClass";
+      var warningKey = publicInstance + "." + callerName;
+      didWarnStateUpdateForUnmountedComponent[warningKey] || (console.error("Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.", callerName, publicInstance), didWarnStateUpdateForUnmountedComponent[warningKey] = !0);
+    }
+    function Component(props, context, updater) {
+      this.props = props;
+      this.context = context;
+      this.refs = emptyObject;
+      this.updater = updater || ReactNoopUpdateQueue;
+    }
+    function ComponentDummy() {}
+    function PureComponent(props, context, updater) {
+      this.props = props;
+      this.context = context;
+      this.refs = emptyObject;
+      this.updater = updater || ReactNoopUpdateQueue;
+    }
+    function testStringCoercion(value) {
+      return "" + value;
+    }
+    function checkKeyStringCoercion(value) {
+      try {
+        testStringCoercion(value);
+        var JSCompiler_inline_result = !1;
+      } catch (e) {
+        JSCompiler_inline_result = !0;
+      }
+      if (JSCompiler_inline_result) {
+        JSCompiler_inline_result = console;
+        var JSCompiler_temp_const = JSCompiler_inline_result.error;
+        var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+        JSCompiler_temp_const.call(JSCompiler_inline_result, "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", JSCompiler_inline_result$jscomp$0);
+        return testStringCoercion(value);
+      }
+    }
+    function getComponentNameFromType(type) {
+      if (null == type) return null;
+      if ("function" === typeof type) return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+      if ("string" === typeof type) return type;
+      switch (type) {
+        case REACT_FRAGMENT_TYPE:
+          return "Fragment";
+        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_ACTIVITY_TYPE:
+          return "Activity";
+      }
+      if ("object" === typeof type) switch ("number" === typeof type.tag && console.error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), type.$$typeof) {
+        case REACT_PORTAL_TYPE:
+          return "Portal";
+        case REACT_CONTEXT_TYPE:
+          return (type.displayName || "Context") + ".Provider";
+        case REACT_CONSUMER_TYPE:
+          return (type._context.displayName || "Context") + ".Consumer";
+        case REACT_FORWARD_REF_TYPE:
+          var innerType = type.render;
+          type = type.displayName;
+          type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
+          return type;
+        case REACT_MEMO_TYPE:
+          return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
+        case REACT_LAZY_TYPE:
+          innerType = type._payload;
+          type = type._init;
+          try {
+            return getComponentNameFromType(type(innerType));
+          } catch (x) {}
+      }
+      return null;
+    }
+    function getTaskName(type) {
+      if (type === REACT_FRAGMENT_TYPE) return "<>";
+      if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE) return "<...>";
+      try {
+        var name = getComponentNameFromType(type);
+        return name ? "<" + name + ">" : "<...>";
+      } catch (x) {
+        return "<...>";
+      }
+    }
+    function getOwner() {
+      var dispatcher = ReactSharedInternals.A;
+      return null === dispatcher ? null : dispatcher.getOwner();
+    }
+    function UnknownOwner() {
+      return Error("react-stack-top-frame");
+    }
+    function hasValidKey(config) {
+      if (hasOwnProperty.call(config, "key")) {
+        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+        if (getter && getter.isReactWarning) return !1;
+      }
+      return void 0 !== config.key;
+    }
+    function defineKeyPropWarningGetter(props, displayName) {
+      function warnAboutAccessingKey() {
+        specialPropKeyWarningShown || (specialPropKeyWarningShown = !0, console.error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)", displayName));
+      }
+      warnAboutAccessingKey.isReactWarning = !0;
+      Object.defineProperty(props, "key", {
+        get: warnAboutAccessingKey,
+        configurable: !0
+      });
+    }
+    function elementRefGetterWithDeprecationWarning() {
+      var componentName = getComponentNameFromType(this.type);
+      didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = !0, console.error("Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."));
+      componentName = this.props.ref;
+      return void 0 !== componentName ? componentName : null;
+    }
+    function ReactElement(type, key, self, source, owner, props, debugStack, debugTask) {
+      self = props.ref;
+      type = {
+        $$typeof: REACT_ELEMENT_TYPE,
+        type: type,
+        key: key,
+        props: props,
+        _owner: owner
+      };
+      null !== (void 0 !== self ? self : null) ? Object.defineProperty(type, "ref", {
+        enumerable: !1,
+        get: elementRefGetterWithDeprecationWarning
+      }) : Object.defineProperty(type, "ref", {
+        enumerable: !1,
+        value: null
+      });
+      type._store = {};
+      Object.defineProperty(type._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: 0
+      });
+      Object.defineProperty(type, "_debugInfo", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: null
+      });
+      Object.defineProperty(type, "_debugStack", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: debugStack
+      });
+      Object.defineProperty(type, "_debugTask", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: debugTask
+      });
+      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+      return type;
+    }
+    function cloneAndReplaceKey(oldElement, newKey) {
+      newKey = ReactElement(oldElement.type, newKey, void 0, void 0, oldElement._owner, oldElement.props, oldElement._debugStack, oldElement._debugTask);
+      oldElement._store && (newKey._store.validated = oldElement._store.validated);
+      return newKey;
+    }
+    function isValidElement(object) {
+      return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+    }
+    function escape(key) {
+      var escaperLookup = {
+        "=": "=0",
+        ":": "=2"
+      };
+      return "$" + key.replace(/[=:]/g, function (match) {
+        return escaperLookup[match];
+      });
+    }
+    function getElementKey(element, index) {
+      return "object" === typeof element && null !== element && null != element.key ? (checkKeyStringCoercion(element.key), escape("" + element.key)) : index.toString(36);
+    }
+    function noop$1() {}
+    function resolveThenable(thenable) {
+      switch (thenable.status) {
+        case "fulfilled":
+          return thenable.value;
+        case "rejected":
+          throw thenable.reason;
+        default:
+          switch ("string" === typeof thenable.status ? thenable.then(noop$1, noop$1) : (thenable.status = "pending", thenable.then(function (fulfilledValue) {
+            "pending" === thenable.status && (thenable.status = "fulfilled", thenable.value = fulfilledValue);
+          }, function (error) {
+            "pending" === thenable.status && (thenable.status = "rejected", thenable.reason = error);
+          })), thenable.status) {
+            case "fulfilled":
+              return thenable.value;
+            case "rejected":
+              throw thenable.reason;
+          }
+      }
+      throw thenable;
+    }
+    function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
+      var type = typeof children;
+      if ("undefined" === type || "boolean" === type) children = null;
+      var invokeCallback = !1;
+      if (null === children) invokeCallback = !0;else switch (type) {
+        case "bigint":
+        case "string":
+        case "number":
+          invokeCallback = !0;
+          break;
+        case "object":
+          switch (children.$$typeof) {
+            case REACT_ELEMENT_TYPE:
+            case REACT_PORTAL_TYPE:
+              invokeCallback = !0;
+              break;
+            case REACT_LAZY_TYPE:
+              return invokeCallback = children._init, mapIntoArray(invokeCallback(children._payload), array, escapedPrefix, nameSoFar, callback);
+          }
+      }
+      if (invokeCallback) {
+        invokeCallback = children;
+        callback = callback(invokeCallback);
+        var childKey = "" === nameSoFar ? "." + getElementKey(invokeCallback, 0) : nameSoFar;
+        isArrayImpl(callback) ? (escapedPrefix = "", null != childKey && (escapedPrefix = childKey.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array, escapedPrefix, "", function (c) {
+          return c;
+        })) : null != callback && (isValidElement(callback) && (null != callback.key && (invokeCallback && invokeCallback.key === callback.key || checkKeyStringCoercion(callback.key)), escapedPrefix = cloneAndReplaceKey(callback, escapedPrefix + (null == callback.key || invokeCallback && invokeCallback.key === callback.key ? "" : ("" + callback.key).replace(userProvidedKeyEscapeRegex, "$&/") + "/") + childKey), "" !== nameSoFar && null != invokeCallback && isValidElement(invokeCallback) && null == invokeCallback.key && invokeCallback._store && !invokeCallback._store.validated && (escapedPrefix._store.validated = 2), callback = escapedPrefix), array.push(callback));
+        return 1;
+      }
+      invokeCallback = 0;
+      childKey = "" === nameSoFar ? "." : nameSoFar + ":";
+      if (isArrayImpl(children)) for (var i = 0; i < children.length; i++) nameSoFar = children[i], type = childKey + getElementKey(nameSoFar, i), invokeCallback += mapIntoArray(nameSoFar, array, escapedPrefix, type, callback);else if (i = getIteratorFn(children), "function" === typeof i) for (i === children.entries && (didWarnAboutMaps || console.warn("Using Maps as children is not supported. Use an array of keyed ReactElements instead."), didWarnAboutMaps = !0), children = i.call(children), i = 0; !(nameSoFar = children.next()).done;) nameSoFar = nameSoFar.value, type = childKey + getElementKey(nameSoFar, i++), invokeCallback += mapIntoArray(nameSoFar, array, escapedPrefix, type, callback);else if ("object" === type) {
+        if ("function" === typeof children.then) return mapIntoArray(resolveThenable(children), array, escapedPrefix, nameSoFar, callback);
+        array = String(children);
+        throw Error("Objects are not valid as a React child (found: " + ("[object Object]" === array ? "object with keys {" + Object.keys(children).join(", ") + "}" : array) + "). If you meant to render a collection of children, use an array instead.");
+      }
+      return invokeCallback;
+    }
+    function mapChildren(children, func, context) {
+      if (null == children) return children;
+      var result = [],
+        count = 0;
+      mapIntoArray(children, result, "", "", function (child) {
+        return func.call(context, child, count++);
+      });
+      return result;
+    }
+    function lazyInitializer(payload) {
+      if (-1 === payload._status) {
+        var ctor = payload._result;
+        ctor = ctor();
+        ctor.then(function (moduleObject) {
+          if (0 === payload._status || -1 === payload._status) payload._status = 1, payload._result = moduleObject;
+        }, function (error) {
+          if (0 === payload._status || -1 === payload._status) payload._status = 2, payload._result = error;
+        });
+        -1 === payload._status && (payload._status = 0, payload._result = ctor);
+      }
+      if (1 === payload._status) return ctor = payload._result, void 0 === ctor && console.error("lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n  const MyComponent = lazy(() => import('./MyComponent'))\n\nDid you accidentally put curly braces around the import?", ctor), "default" in ctor || console.error("lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n  const MyComponent = lazy(() => import('./MyComponent'))", ctor), ctor.default;
+      throw payload._result;
+    }
+    function resolveDispatcher() {
+      var dispatcher = ReactSharedInternals.H;
+      null === dispatcher && console.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://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.");
+      return dispatcher;
+    }
+    function noop() {}
+    function enqueueTask(task) {
+      if (null === enqueueTaskImpl) try {
+        var requireString = ("require" + Math.random()).slice(0, 7);
+        enqueueTaskImpl = (module && module[requireString]).call(module, "timers").setImmediate;
+      } catch (_err) {
+        enqueueTaskImpl = function enqueueTaskImpl(callback) {
+          !1 === didWarnAboutMessageChannel && (didWarnAboutMessageChannel = !0, "undefined" === typeof MessageChannel && console.error("This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."));
+          var channel = new MessageChannel();
+          channel.port1.onmessage = callback;
+          channel.port2.postMessage(void 0);
+        };
+      }
+      return enqueueTaskImpl(task);
+    }
+    function aggregateErrors(errors) {
+      return 1 < errors.length && "function" === typeof AggregateError ? new AggregateError(errors) : errors[0];
+    }
+    function popActScope(prevActQueue, prevActScopeDepth) {
+      prevActScopeDepth !== actScopeDepth - 1 && console.error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. ");
+      actScopeDepth = prevActScopeDepth;
+    }
+    function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
+      var queue = ReactSharedInternals.actQueue;
+      if (null !== queue) if (0 !== queue.length) try {
+        flushActQueue(queue);
+        enqueueTask(function () {
+          return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+        });
+        return;
+      } catch (error) {
+        ReactSharedInternals.thrownErrors.push(error);
+      } else ReactSharedInternals.actQueue = null;
+      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve(returnValue);
+    }
+    function flushActQueue(queue) {
+      if (!isFlushing) {
+        isFlushing = !0;
+        var i = 0;
+        try {
+          for (; i < queue.length; i++) {
+            var callback = queue[i];
+            do {
+              ReactSharedInternals.didUsePromise = !1;
+              var continuation = callback(!1);
+              if (null !== continuation) {
+                if (ReactSharedInternals.didUsePromise) {
+                  queue[i] = callback;
+                  queue.splice(0, i);
+                  return;
+                }
+                callback = continuation;
+              } else break;
+            } while (1);
+          }
+          queue.length = 0;
+        } catch (error) {
+          queue.splice(0, i + 1), ReactSharedInternals.thrownErrors.push(error);
+        } finally {
+          isFlushing = !1;
+        }
+      }
+    }
+    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
+      REACT_PORTAL_TYPE = Symbol.for("react.portal"),
+      REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
+      REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
+      REACT_PROFILER_TYPE = Symbol.for("react.profiler");
+    Symbol.for("react.provider");
+    var REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
+      REACT_CONTEXT_TYPE = Symbol.for("react.context"),
+      REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
+      REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
+      REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
+      REACT_MEMO_TYPE = Symbol.for("react.memo"),
+      REACT_LAZY_TYPE = Symbol.for("react.lazy"),
+      REACT_ACTIVITY_TYPE = Symbol.for("react.activity"),
+      MAYBE_ITERATOR_SYMBOL = Symbol.iterator,
+      didWarnStateUpdateForUnmountedComponent = {},
+      ReactNoopUpdateQueue = {
+        isMounted: function isMounted() {
+          return !1;
+        },
+        enqueueForceUpdate: function enqueueForceUpdate(publicInstance) {
+          warnNoop(publicInstance, "forceUpdate");
+        },
+        enqueueReplaceState: function enqueueReplaceState(publicInstance) {
+          warnNoop(publicInstance, "replaceState");
+        },
+        enqueueSetState: function enqueueSetState(publicInstance) {
+          warnNoop(publicInstance, "setState");
+        }
+      },
+      assign = Object.assign,
+      emptyObject = {};
+    Object.freeze(emptyObject);
+    Component.prototype.isReactComponent = {};
+    Component.prototype.setState = function (partialState, callback) {
+      if ("object" !== typeof partialState && "function" !== typeof partialState && null != partialState) throw Error("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");
+    };
+    Component.prototype.forceUpdate = function (callback) {
+      this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
+    };
+    var deprecatedAPIs = {
+        isMounted: ["isMounted", "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."],
+        replaceState: ["replaceState", "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."]
+      },
+      fnName;
+    for (fnName in deprecatedAPIs) deprecatedAPIs.hasOwnProperty(fnName) && defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
+    ComponentDummy.prototype = Component.prototype;
+    deprecatedAPIs = PureComponent.prototype = new ComponentDummy();
+    deprecatedAPIs.constructor = PureComponent;
+    assign(deprecatedAPIs, Component.prototype);
+    deprecatedAPIs.isPureReactComponent = !0;
+    var isArrayImpl = Array.isArray,
+      REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"),
+      ReactSharedInternals = {
+        H: null,
+        A: null,
+        T: null,
+        S: null,
+        V: null,
+        actQueue: null,
+        isBatchingLegacy: !1,
+        didScheduleLegacyUpdate: !1,
+        didUsePromise: !1,
+        thrownErrors: [],
+        getCurrentStack: null,
+        recentlyCreatedOwnerStacks: 0
+      },
+      hasOwnProperty = Object.prototype.hasOwnProperty,
+      createTask = console.createTask ? console.createTask : function () {
+        return null;
+      };
+    deprecatedAPIs = {
+      "react-stack-bottom-frame": function reactStackBottomFrame(callStackForError) {
+        return callStackForError();
+      }
+    };
+    var specialPropKeyWarningShown, didWarnAboutOldJSXRuntime;
+    var didWarnAboutElementRef = {};
+    var unknownOwnerDebugStack = deprecatedAPIs["react-stack-bottom-frame"].bind(deprecatedAPIs, UnknownOwner)();
+    var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+    var didWarnAboutMaps = !1,
+      userProvidedKeyEscapeRegex = /\/+/g,
+      reportGlobalError = "function" === typeof reportError ? reportError : function (error) {
+        if ("object" === typeof window && "function" === typeof window.ErrorEvent) {
+          var event = new window.ErrorEvent("error", {
+            bubbles: !0,
+            cancelable: !0,
+            message: "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error),
+            error: error
+          });
+          if (!window.dispatchEvent(event)) return;
+        } else if ("object" === typeof process && "function" === typeof process.emit) {
+          process.emit("uncaughtException", error);
+          return;
+        }
+        console.error(error);
+      },
+      didWarnAboutMessageChannel = !1,
+      enqueueTaskImpl = null,
+      actScopeDepth = 0,
+      didWarnNoAwaitAct = !1,
+      isFlushing = !1,
+      queueSeveralMicrotasks = "function" === typeof queueMicrotask ? function (callback) {
+        queueMicrotask(function () {
+          return queueMicrotask(callback);
+        });
+      } : enqueueTask;
+    deprecatedAPIs = Object.freeze({
+      __proto__: null,
+      c: function c(size) {
+        return resolveDispatcher().useMemoCache(size);
+      }
+    });
+    exports.Children = {
+      map: mapChildren,
+      forEach: function forEach(children, forEachFunc, forEachContext) {
+        mapChildren(children, function () {
+          forEachFunc.apply(this, arguments);
+        }, forEachContext);
+      },
+      count: function count(children) {
+        var n = 0;
+        mapChildren(children, function () {
+          n++;
+        });
+        return n;
+      },
+      toArray: function toArray(children) {
+        return mapChildren(children, function (child) {
+          return child;
+        }) || [];
+      },
+      only: function only(children) {
+        if (!isValidElement(children)) throw Error("React.Children.only expected to receive a single React element child.");
+        return 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.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
+    exports.__COMPILER_RUNTIME = deprecatedAPIs;
+    exports.act = function (callback) {
+      var prevActQueue = ReactSharedInternals.actQueue,
+        prevActScopeDepth = actScopeDepth;
+      actScopeDepth++;
+      var queue = ReactSharedInternals.actQueue = null !== prevActQueue ? prevActQueue : [],
+        didAwaitActCall = !1;
+      try {
+        var result = callback();
+      } catch (error) {
+        ReactSharedInternals.thrownErrors.push(error);
+      }
+      if (0 < ReactSharedInternals.thrownErrors.length) throw popActScope(prevActQueue, prevActScopeDepth), callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
+      if (null !== result && "object" === typeof result && "function" === typeof result.then) {
+        var thenable = result;
+        queueSeveralMicrotasks(function () {
+          didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = !0, console.error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"));
+        });
+        return {
+          then: function then(resolve, reject) {
+            didAwaitActCall = !0;
+            thenable.then(function (returnValue) {
+              popActScope(prevActQueue, prevActScopeDepth);
+              if (0 === prevActScopeDepth) {
+                try {
+                  flushActQueue(queue), enqueueTask(function () {
+                    return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+                  });
+                } catch (error$0) {
+                  ReactSharedInternals.thrownErrors.push(error$0);
+                }
+                if (0 < ReactSharedInternals.thrownErrors.length) {
+                  var _thrownError = aggregateErrors(ReactSharedInternals.thrownErrors);
+                  ReactSharedInternals.thrownErrors.length = 0;
+                  reject(_thrownError);
+                }
+              } else resolve(returnValue);
+            }, function (error) {
+              popActScope(prevActQueue, prevActScopeDepth);
+              0 < ReactSharedInternals.thrownErrors.length ? (error = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(error)) : reject(error);
+            });
+          }
+        };
+      }
+      var returnValue$jscomp$0 = result;
+      popActScope(prevActQueue, prevActScopeDepth);
+      0 === prevActScopeDepth && (flushActQueue(queue), 0 !== queue.length && queueSeveralMicrotasks(function () {
+        didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = !0, console.error("A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"));
+      }), ReactSharedInternals.actQueue = null);
+      if (0 < ReactSharedInternals.thrownErrors.length) throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
+      return {
+        then: function then(resolve, reject) {
+          didAwaitActCall = !0;
+          0 === prevActScopeDepth ? (ReactSharedInternals.actQueue = queue, enqueueTask(function () {
+            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve, reject);
+          })) : resolve(returnValue$jscomp$0);
+        }
+      };
+    };
+    exports.cache = function (fn) {
+      return function () {
+        return fn.apply(null, arguments);
+      };
+    };
+    exports.captureOwnerStack = function () {
+      var getCurrentStack = ReactSharedInternals.getCurrentStack;
+      return null === getCurrentStack ? null : getCurrentStack();
+    };
+    exports.cloneElement = function (element, config, children) {
+      if (null === element || void 0 === element) throw Error("The argument must be a React element, but you passed " + element + ".");
+      var props = assign({}, element.props),
+        key = element.key,
+        owner = element._owner;
+      if (null != config) {
+        var JSCompiler_inline_result;
+        a: {
+          if (hasOwnProperty.call(config, "ref") && (JSCompiler_inline_result = Object.getOwnPropertyDescriptor(config, "ref").get) && JSCompiler_inline_result.isReactWarning) {
+            JSCompiler_inline_result = !1;
+            break a;
+          }
+          JSCompiler_inline_result = void 0 !== config.ref;
+        }
+        JSCompiler_inline_result && (owner = getOwner());
+        hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key);
+        for (propName in config) !hasOwnProperty.call(config, propName) || "key" === propName || "__self" === propName || "__source" === propName || "ref" === propName && void 0 === config.ref || (props[propName] = config[propName]);
+      }
+      var propName = arguments.length - 2;
+      if (1 === propName) props.children = children;else if (1 < propName) {
+        JSCompiler_inline_result = Array(propName);
+        for (var i = 0; i < propName; i++) JSCompiler_inline_result[i] = arguments[i + 2];
+        props.children = JSCompiler_inline_result;
+      }
+      props = ReactElement(element.type, key, void 0, void 0, owner, props, element._debugStack, element._debugTask);
+      for (key = 2; key < arguments.length; key++) owner = arguments[key], isValidElement(owner) && owner._store && (owner._store.validated = 1);
+      return props;
+    };
+    exports.createContext = function (defaultValue) {
+      defaultValue = {
+        $$typeof: REACT_CONTEXT_TYPE,
+        _currentValue: defaultValue,
+        _currentValue2: defaultValue,
+        _threadCount: 0,
+        Provider: null,
+        Consumer: null
+      };
+      defaultValue.Provider = defaultValue;
+      defaultValue.Consumer = {
+        $$typeof: REACT_CONSUMER_TYPE,
+        _context: defaultValue
+      };
+      defaultValue._currentRenderer = null;
+      defaultValue._currentRenderer2 = null;
+      return defaultValue;
+    };
+    exports.createElement = function (type, config, children) {
+      for (var i = 2; i < arguments.length; i++) {
+        var node = arguments[i];
+        isValidElement(node) && node._store && (node._store.validated = 1);
+      }
+      i = {};
+      node = null;
+      if (null != config) for (propName in didWarnAboutOldJSXRuntime || !("__self" in config) || "key" in config || (didWarnAboutOldJSXRuntime = !0, console.warn("Your app (or one of its dependencies) is using an outdated JSX transform. Update to the modern JSX transform for faster performance: https://react.dev/link/new-jsx-transform")), hasValidKey(config) && (checkKeyStringCoercion(config.key), node = "" + config.key), config) hasOwnProperty.call(config, propName) && "key" !== propName && "__self" !== propName && "__source" !== propName && (i[propName] = config[propName]);
+      var childrenLength = arguments.length - 2;
+      if (1 === childrenLength) i.children = children;else if (1 < childrenLength) {
+        for (var childArray = Array(childrenLength), _i = 0; _i < childrenLength; _i++) childArray[_i] = arguments[_i + 2];
+        Object.freeze && Object.freeze(childArray);
+        i.children = childArray;
+      }
+      if (type && type.defaultProps) for (propName in childrenLength = type.defaultProps, childrenLength) void 0 === i[propName] && (i[propName] = childrenLength[propName]);
+      node && defineKeyPropWarningGetter(i, "function" === typeof type ? type.displayName || type.name || "Unknown" : type);
+      var propName = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+      return ReactElement(type, node, void 0, void 0, getOwner(), i, propName ? Error("react-stack-top-frame") : unknownOwnerDebugStack, propName ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
+    };
+    exports.createRef = function () {
+      var refObject = {
+        current: null
+      };
+      Object.seal(refObject);
+      return refObject;
+    };
+    exports.forwardRef = function (render) {
+      null != render && render.$$typeof === REACT_MEMO_TYPE ? console.error("forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...)).") : "function" !== typeof render ? console.error("forwardRef requires a render function but was given %s.", null === render ? "null" : typeof render) : 0 !== render.length && 2 !== render.length && console.error("forwardRef render functions accept exactly two parameters: props and ref. %s", 1 === render.length ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined.");
+      null != render && null != render.defaultProps && console.error("forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?");
+      var elementType = {
+          $$typeof: REACT_FORWARD_REF_TYPE,
+          render: render
+        },
+        ownName;
+      Object.defineProperty(elementType, "displayName", {
+        enumerable: !1,
+        configurable: !0,
+        get: function get() {
+          return ownName;
+        },
+        set: function set(name) {
+          ownName = name;
+          render.name || render.displayName || (Object.defineProperty(render, "name", {
+            value: name
+          }), render.displayName = name);
+        }
+      });
+      return elementType;
+    };
+    exports.isValidElement = isValidElement;
+    exports.lazy = function (ctor) {
+      return {
+        $$typeof: REACT_LAZY_TYPE,
+        _payload: {
+          _status: -1,
+          _result: ctor
+        },
+        _init: lazyInitializer
+      };
+    };
+    exports.memo = function (type, compare) {
+      null == type && console.error("memo: The first argument must be a component. Instead received: %s", null === type ? "null" : typeof type);
+      compare = {
+        $$typeof: REACT_MEMO_TYPE,
+        type: type,
+        compare: void 0 === compare ? null : compare
+      };
+      var ownName;
+      Object.defineProperty(compare, "displayName", {
+        enumerable: !1,
+        configurable: !0,
+        get: function get() {
+          return ownName;
+        },
+        set: function set(name) {
+          ownName = name;
+          type.name || type.displayName || (Object.defineProperty(type, "name", {
+            value: name
+          }), type.displayName = name);
+        }
+      });
+      return compare;
+    };
+    exports.startTransition = function (scope) {
+      var prevTransition = ReactSharedInternals.T,
+        currentTransition = {};
+      ReactSharedInternals.T = currentTransition;
+      currentTransition._updatedFibers = new Set();
+      try {
+        var returnValue = scope(),
+          onStartTransitionFinish = ReactSharedInternals.S;
+        null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
+        "object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && returnValue.then(noop, reportGlobalError);
+      } catch (error) {
+        reportGlobalError(error);
+      } finally {
+        null === prevTransition && currentTransition._updatedFibers && (scope = currentTransition._updatedFibers.size, currentTransition._updatedFibers.clear(), 10 < scope && console.warn("Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table.")), ReactSharedInternals.T = prevTransition;
+      }
+    };
+    exports.unstable_useCacheRefresh = function () {
+      return resolveDispatcher().useCacheRefresh();
+    };
+    exports.use = function (usable) {
+      return resolveDispatcher().use(usable);
+    };
+    exports.useActionState = function (action, initialState, permalink) {
+      return resolveDispatcher().useActionState(action, initialState, permalink);
+    };
+    exports.useCallback = function (callback, deps) {
+      return resolveDispatcher().useCallback(callback, deps);
+    };
+    exports.useContext = function (Context) {
+      var dispatcher = resolveDispatcher();
+      Context.$$typeof === REACT_CONSUMER_TYPE && console.error("Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?");
+      return dispatcher.useContext(Context);
+    };
+    exports.useDebugValue = function (value, formatterFn) {
+      return resolveDispatcher().useDebugValue(value, formatterFn);
+    };
+    exports.useDeferredValue = function (value, initialValue) {
+      return resolveDispatcher().useDeferredValue(value, initialValue);
+    };
+    exports.useEffect = function (create, createDeps, update) {
+      null == create && console.warn("React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?");
+      var dispatcher = resolveDispatcher();
+      if ("function" === typeof update) throw Error("useEffect CRUD overload is not enabled in this build of React.");
+      return dispatcher.useEffect(create, createDeps);
+    };
+    exports.useId = function () {
+      return resolveDispatcher().useId();
+    };
+    exports.useImperativeHandle = function (ref, create, deps) {
+      return resolveDispatcher().useImperativeHandle(ref, create, deps);
+    };
+    exports.useInsertionEffect = function (create, deps) {
+      null == create && console.warn("React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?");
+      return resolveDispatcher().useInsertionEffect(create, deps);
+    };
+    exports.useLayoutEffect = function (create, deps) {
+      null == create && console.warn("React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?");
+      return resolveDispatcher().useLayoutEffect(create, deps);
+    };
+    exports.useMemo = function (create, deps) {
+      return resolveDispatcher().useMemo(create, deps);
+    };
+    exports.useOptimistic = function (passthrough, reducer) {
+      return resolveDispatcher().useOptimistic(passthrough, reducer);
+    };
+    exports.useReducer = function (reducer, initialArg, init) {
+      return resolveDispatcher().useReducer(reducer, initialArg, init);
+    };
+    exports.useRef = function (initialValue) {
+      return resolveDispatcher().useRef(initialValue);
+    };
+    exports.useState = function (initialState) {
+      return resolveDispatcher().useState(initialState);
+    };
+    exports.useSyncExternalStore = function (subscribe, getSnapshot, getServerSnapshot) {
+      return resolveDispatcher().useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+    };
+    exports.useTransition = function () {
+      return resolveDispatcher().useTransition();
+    };
+    exports.version = "19.1.0";
+    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  }();
+},75,[],"../../node_modules/react/cjs/react.development.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = exports.Commands = void 0;
+  var NativeComponentRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../NativeComponent/NativeComponentRegistry"));
+  var _codegenNativeCommands = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../Utilities/codegenNativeCommands"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var ViewNativeComponent = NativeComponentRegistry.get('RCTView', function () {
+    return {
+      uiViewClassName: 'RCTView'
+    };
+  });
+  var Commands = exports.Commands = (0, _codegenNativeCommands.default)({
+    supportedCommands: ['hotspotUpdate', 'setPressed']
+  });
+  var _default = exports.default = ViewNativeComponent;
+},76,[1,77,105],"../../node_modules/react-native/Libraries/Components/View/ViewNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.get = get;
+  exports.getWithFallback_DEPRECATED = getWithFallback_DEPRECATED;
+  exports.setRuntimeConfigProvider = setRuntimeConfigProvider;
+  exports.unstable_hasStaticViewConfig = unstable_hasStaticViewConfig;
+  var _getNativeComponentAttributes = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../ReactNative/getNativeComponentAttributes"));
+  var _UIManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../ReactNative/UIManager"));
+  var ReactNativeViewConfigRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[3], "../Renderer/shims/ReactNativeViewConfigRegistry"));
+  var StaticViewConfigValidator = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[4], "./StaticViewConfigValidator"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "invariant"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[6], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var getRuntimeConfig;
+  function setRuntimeConfigProvider(runtimeConfigProvider) {
+    if (getRuntimeConfig === undefined) {
+      getRuntimeConfig = runtimeConfigProvider;
+    }
+  }
+  function get(name, viewConfigProvider) {
+    ReactNativeViewConfigRegistry.register(name, function () {
+      var _getRuntimeConfig;
+      var _ref = (_getRuntimeConfig = getRuntimeConfig == null ? void 0 : getRuntimeConfig(name)) != null ? _getRuntimeConfig : {
+          native: !global.RN$Bridgeless,
+          verify: false
+        },
+        native = _ref.native,
+        verify = _ref.verify;
+      var viewConfig;
+      if (native) {
+        var _getNativeComponentAt;
+        viewConfig = (_getNativeComponentAt = (0, _getNativeComponentAttributes.default)(name)) != null ? _getNativeComponentAt : (0, _$$_REQUIRE(_dependencyMap[7], "./ViewConfig").createViewConfig)(viewConfigProvider());
+      } else {
+        var _createViewConfig;
+        viewConfig = (_createViewConfig = (0, _$$_REQUIRE(_dependencyMap[7], "./ViewConfig").createViewConfig)(viewConfigProvider())) != null ? _createViewConfig : (0, _getNativeComponentAttributes.default)(name);
+      }
+      (0, _invariant.default)(viewConfig != null, 'NativeComponentRegistry.get: both static and native view config are missing for native component "%s".', name);
+      if (verify) {
+        var nativeViewConfig = native ? viewConfig : (0, _getNativeComponentAttributes.default)(name);
+        if (nativeViewConfig == null) {
+          return viewConfig;
+        }
+        var staticViewConfig = native ? (0, _$$_REQUIRE(_dependencyMap[7], "./ViewConfig").createViewConfig)(viewConfigProvider()) : viewConfig;
+        var validationOutput = StaticViewConfigValidator.validate(name, nativeViewConfig, staticViewConfig);
+        if (validationOutput.type === 'invalid') {
+          console.error(StaticViewConfigValidator.stringifyValidationResult(name, validationOutput));
+        }
+      }
+      return viewConfig;
+    });
+    return name;
+  }
+  function getWithFallback_DEPRECATED(name, viewConfigProvider) {
+    if (getRuntimeConfig == null) {
+      if (hasNativeViewConfig(name)) {
+        return get(name, viewConfigProvider);
+      }
+    } else {
+      if (getRuntimeConfig(name) != null) {
+        return get(name, viewConfigProvider);
+      }
+    }
+    var FallbackNativeComponent = function FallbackNativeComponent(props) {
+      return null;
+    };
+    FallbackNativeComponent.displayName = `Fallback(${name})`;
+    return FallbackNativeComponent;
+  }
+  function hasNativeViewConfig(name) {
+    (0, _invariant.default)(getRuntimeConfig == null, 'Unexpected invocation!');
+    return _UIManager.default.getViewManagerConfig(name) != null;
+  }
+  function unstable_hasStaticViewConfig(name) {
+    var _getRuntimeConfig2;
+    var _ref2 = (_getRuntimeConfig2 = getRuntimeConfig == null ? void 0 : getRuntimeConfig(name)) != null ? _getRuntimeConfig2 : {
+        native: true
+      },
+      native = _ref2.native;
+    return !native;
+  }
+},77,[1,78,79,99,100,32,73,101],"../../node_modules/react-native/Libraries/NativeComponent/NativeComponentRegistry.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _processBoxShadow = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../StyleSheet/processBoxShadow"));
+  function getNativeComponentAttributes(uiViewClassName) {
+    var viewConfig = _$$_REQUIRE(_dependencyMap[2], "./UIManager").default.getViewManagerConfig(uiViewClassName);
+    if (viewConfig == null) {
+      return null;
+    }
+    var baseModuleName = viewConfig.baseModuleName,
+      bubblingEventTypes = viewConfig.bubblingEventTypes,
+      directEventTypes = viewConfig.directEventTypes;
+    var nativeProps = viewConfig.NativeProps;
+    bubblingEventTypes = bubblingEventTypes != null ? bubblingEventTypes : {};
+    directEventTypes = directEventTypes != null ? directEventTypes : {};
+    while (baseModuleName) {
+      var baseModule = _$$_REQUIRE(_dependencyMap[2], "./UIManager").default.getViewManagerConfig(baseModuleName);
+      if (!baseModule) {
+        baseModuleName = null;
+      } else {
+        bubblingEventTypes = Object.assign({}, baseModule.bubblingEventTypes, bubblingEventTypes);
+        directEventTypes = Object.assign({}, baseModule.directEventTypes, directEventTypes);
+        nativeProps = Object.assign({}, baseModule.NativeProps, nativeProps);
+        baseModuleName = baseModule.baseModuleName;
+      }
+    }
+    var validAttributes = {};
+    for (var key in nativeProps) {
+      var typeName = nativeProps[key];
+      var diff = getDifferForType(typeName);
+      var process = getProcessorForType(typeName);
+      validAttributes[key] = diff == null ? process == null ? true : {
+        process: process
+      } : process == null ? {
+        diff: diff
+      } : {
+        diff: diff,
+        process: process
+      };
+    }
+    validAttributes.style = _$$_REQUIRE(_dependencyMap[3], "../Components/View/ReactNativeStyleAttributes").default;
+    Object.assign(viewConfig, {
+      uiViewClassName: uiViewClassName,
+      validAttributes: validAttributes,
+      bubblingEventTypes: bubblingEventTypes,
+      directEventTypes: directEventTypes
+    });
+    attachDefaultEventTypes(viewConfig);
+    return viewConfig;
+  }
+  function attachDefaultEventTypes(viewConfig) {
+    var constants = _$$_REQUIRE(_dependencyMap[2], "./UIManager").default.getConstants();
+    if (constants.ViewManagerNames || constants.LazyViewManagersEnabled) {
+      viewConfig = merge(viewConfig, _$$_REQUIRE(_dependencyMap[4], "nullthrows")(_$$_REQUIRE(_dependencyMap[2], "./UIManager").default.getDefaultEventTypes)());
+    } else {
+      viewConfig.bubblingEventTypes = merge(viewConfig.bubblingEventTypes, constants.genericBubblingEventTypes);
+      viewConfig.directEventTypes = merge(viewConfig.directEventTypes, constants.genericDirectEventTypes);
+    }
+  }
+  function merge(destination, source) {
+    if (!source) {
+      return destination;
+    }
+    if (!destination) {
+      return source;
+    }
+    for (var key in source) {
+      if (!source.hasOwnProperty(key)) {
+        continue;
+      }
+      var sourceValue = source[key];
+      if (destination.hasOwnProperty(key)) {
+        var destinationValue = destination[key];
+        if (typeof sourceValue === 'object' && typeof destinationValue === 'object') {
+          sourceValue = merge(destinationValue, sourceValue);
+        }
+      }
+      destination[key] = sourceValue;
+    }
+    return destination;
+  }
+  function getDifferForType(typeName) {
+    switch (typeName) {
+      case 'CATransform3D':
+        return _$$_REQUIRE(_dependencyMap[5], "../Utilities/differ/matricesDiffer").default;
+      case 'CGPoint':
+        return _$$_REQUIRE(_dependencyMap[6], "../Utilities/differ/pointsDiffer").default;
+      case 'CGSize':
+        return _$$_REQUIRE(_dependencyMap[7], "../Utilities/differ/sizesDiffer").default;
+      case 'UIEdgeInsets':
+        return _$$_REQUIRE(_dependencyMap[8], "../Utilities/differ/insetsDiffer").default;
+      case 'Point':
+        return _$$_REQUIRE(_dependencyMap[6], "../Utilities/differ/pointsDiffer").default;
+      case 'EdgeInsets':
+        return _$$_REQUIRE(_dependencyMap[8], "../Utilities/differ/insetsDiffer").default;
+    }
+    return null;
+  }
+  function getProcessorForType(typeName) {
+    switch (typeName) {
+      case 'CGColor':
+      case 'UIColor':
+        return _$$_REQUIRE(_dependencyMap[9], "../StyleSheet/processColor").default;
+      case 'CGColorArray':
+      case 'UIColorArray':
+        return _$$_REQUIRE(_dependencyMap[10], "../StyleSheet/processColorArray").default;
+      case 'CGImage':
+      case 'UIImage':
+      case 'RCTImageSource':
+        return _$$_REQUIRE(_dependencyMap[11], "../Image/resolveAssetSource").default;
+      case 'BoxShadowArray':
+        return _processBoxShadow.default;
+      case 'FilterArray':
+        return _$$_REQUIRE(_dependencyMap[12], "../StyleSheet/processFilter").default;
+      case 'Color':
+        return _$$_REQUIRE(_dependencyMap[9], "../StyleSheet/processColor").default;
+      case 'ColorArray':
+        return _$$_REQUIRE(_dependencyMap[10], "../StyleSheet/processColorArray").default;
+      case 'Filter':
+        return _$$_REQUIRE(_dependencyMap[12], "../StyleSheet/processFilter").default;
+      case 'BackgroundImage':
+        return _$$_REQUIRE(_dependencyMap[13], "../StyleSheet/processBackgroundImage").default;
+      case 'ImageSource':
+        return _$$_REQUIRE(_dependencyMap[11], "../Image/resolveAssetSource").default;
+      case 'BoxShadow':
+        return _processBoxShadow.default;
+    }
+    return null;
+  }
+  var _default = exports.default = getNativeComponentAttributes;
+},78,[1,61,79,51,80,88,89,67,90,57,91,92,62,56],"../../node_modules/react-native/Libraries/ReactNative/getNativeComponentAttributes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _nullthrows = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "nullthrows"));
+  function isFabricReactTag(reactTag) {
+    return reactTag % 2 === 0;
+  }
+  var UIManagerImpl = global.RN$Bridgeless === true ? _$$_REQUIRE(_dependencyMap[2], "./BridgelessUIManager").default : _$$_REQUIRE(_dependencyMap[3], "./PaperUIManager").default;
+  var UIManager = Object.assign({}, UIManagerImpl, {
+    measure: function measure(reactTag, callback) {
+      if (isFabricReactTag(reactTag)) {
+        var FabricUIManager = (0, _nullthrows.default)((0, _$$_REQUIRE(_dependencyMap[4], "./FabricUIManager").getFabricUIManager)());
+        var shadowNode = FabricUIManager.findShadowNodeByTag_DEPRECATED(reactTag);
+        if (shadowNode) {
+          FabricUIManager.measure(shadowNode, callback);
+        } else {
+          console.warn(`measure cannot find view with tag #${reactTag}`);
+          callback();
+        }
+      } else {
+        UIManagerImpl.measure(reactTag, callback);
+      }
+    },
+    measureInWindow: function measureInWindow(reactTag, callback) {
+      if (isFabricReactTag(reactTag)) {
+        var FabricUIManager = (0, _nullthrows.default)((0, _$$_REQUIRE(_dependencyMap[4], "./FabricUIManager").getFabricUIManager)());
+        var shadowNode = FabricUIManager.findShadowNodeByTag_DEPRECATED(reactTag);
+        if (shadowNode) {
+          FabricUIManager.measureInWindow(shadowNode, callback);
+        } else {
+          console.warn(`measure cannot find view with tag #${reactTag}`);
+          callback();
+        }
+      } else {
+        UIManagerImpl.measureInWindow(reactTag, callback);
+      }
+    },
+    measureLayout: function measureLayout(reactTag, ancestorReactTag, errorCallback, callback) {
+      if (isFabricReactTag(reactTag)) {
+        var FabricUIManager = (0, _nullthrows.default)((0, _$$_REQUIRE(_dependencyMap[4], "./FabricUIManager").getFabricUIManager)());
+        var shadowNode = FabricUIManager.findShadowNodeByTag_DEPRECATED(reactTag);
+        var ancestorShadowNode = FabricUIManager.findShadowNodeByTag_DEPRECATED(ancestorReactTag);
+        if (!shadowNode || !ancestorShadowNode) {
+          return;
+        }
+        FabricUIManager.measureLayout(shadowNode, ancestorShadowNode, errorCallback, callback);
+      } else {
+        UIManagerImpl.measureLayout(reactTag, ancestorReactTag, errorCallback, callback);
+      }
+    },
+    measureLayoutRelativeToParent: function measureLayoutRelativeToParent(reactTag, errorCallback, callback) {
+      if (isFabricReactTag(reactTag)) {
+        console.warn('RCTUIManager.measureLayoutRelativeToParent method is deprecated and it will not be implemented in newer versions of RN (Fabric) - T47686450');
+        var FabricUIManager = (0, _nullthrows.default)((0, _$$_REQUIRE(_dependencyMap[4], "./FabricUIManager").getFabricUIManager)());
+        var shadowNode = FabricUIManager.findShadowNodeByTag_DEPRECATED(reactTag);
+        if (shadowNode) {
+          FabricUIManager.measure(shadowNode, function (left, top, width, height, pageX, pageY) {
+            callback(left, top, width, height);
+          });
+        }
+      } else {
+        UIManagerImpl.measureLayoutRelativeToParent(reactTag, errorCallback, callback);
+      }
+    },
+    dispatchViewManagerCommand: function dispatchViewManagerCommand(reactTag, commandName, commandArgs) {
+      if (typeof reactTag !== 'number') {
+        throw new Error('dispatchViewManagerCommand: found null reactTag');
+      }
+      if (isFabricReactTag(reactTag)) {
+        var FabricUIManager = (0, _nullthrows.default)((0, _$$_REQUIRE(_dependencyMap[4], "./FabricUIManager").getFabricUIManager)());
+        var shadowNode = FabricUIManager.findShadowNodeByTag_DEPRECATED(reactTag);
+        if (shadowNode) {
+          commandName = `${commandName}`;
+          FabricUIManager.dispatchCommand(shadowNode, commandName, commandArgs);
+        }
+      } else {
+        UIManagerImpl.dispatchViewManagerCommand(reactTag, commandName, commandArgs);
+      }
+    }
+  });
+  var _default = exports.default = UIManager;
+},79,[1,80,81,84,82],"../../node_modules/react-native/Libraries/ReactNative/UIManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  function nullthrows(x, message) {
+    if (x != null) {
+      return x;
+    }
+    var error = new Error(message !== undefined ? message : 'Got unexpected ' + x);
+    error.framesToPop = 1; // Skip nullthrows's own stack frame.
+    throw error;
+  }
+  module.exports = nullthrows;
+  module.exports.default = nullthrows;
+  Object.defineProperty(module.exports, '__esModule', {
+    value: true
+  });
+},80,[],"../../node_modules/nullthrows/nullthrows.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _defineLazyObjectProperty = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../Utilities/defineLazyObjectProperty"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../Utilities/Platform"));
+  var _nullthrows = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "nullthrows"));
+  function raiseSoftError(methodName, details) {
+    console.error(`[ReactNative Architecture][JS] '${methodName}' is not available in the new React Native architecture.` + (details ? ` ${details}` : ''));
+  }
+  var getUIManagerConstants = global.RN$LegacyInterop_UIManager_getConstants;
+  var getUIManagerConstantsCached = function () {
+    var wasCalledOnce = false;
+    var result = {};
+    return function () {
+      if (!wasCalledOnce) {
+        result = (0, _nullthrows.default)(getUIManagerConstants)();
+        wasCalledOnce = true;
+      }
+      return result;
+    };
+  }();
+  var _getConstantsForViewManager = global.RN$LegacyInterop_UIManager_getConstantsForViewManager;
+  var _getDefaultEventTypes = global.RN$LegacyInterop_UIManager_getDefaultEventTypes;
+  var getDefaultEventTypesCached = function () {
+    var wasCalledOnce = false;
+    var result = null;
+    return function () {
+      if (!wasCalledOnce) {
+        result = (0, _nullthrows.default)(_getDefaultEventTypes)();
+        wasCalledOnce = true;
+      }
+      return result;
+    };
+  }();
+  var UIManagerJSOverridenAPIs = {
+    measure: function measure(reactTag, callback) {
+      raiseSoftError('measure');
+    },
+    measureInWindow: function measureInWindow(reactTag, callback) {
+      raiseSoftError('measureInWindow');
+    },
+    measureLayout: function measureLayout(reactTag, ancestorReactTag, errorCallback, callback) {
+      raiseSoftError('measureLayout');
+    },
+    measureLayoutRelativeToParent: function measureLayoutRelativeToParent(reactTag, errorCallback, callback) {
+      raiseSoftError('measureLayoutRelativeToParent');
+    },
+    dispatchViewManagerCommand: function dispatchViewManagerCommand(reactTag, commandID, commandArgs) {
+      raiseSoftError('dispatchViewManagerCommand');
+    }
+  };
+  var UIManagerJSUnusedInNewArchAPIs = {
+    createView: function createView(reactTag, viewName, rootTag, props) {
+      raiseSoftError('createView');
+    },
+    updateView: function updateView(reactTag, viewName, props) {
+      raiseSoftError('updateView');
+    },
+    setChildren: function setChildren(containerTag, reactTags) {
+      raiseSoftError('setChildren');
+    },
+    manageChildren: function manageChildren(containerTag, moveFromIndices, moveToIndices, addChildReactTags, addAtIndices, removeAtIndices) {
+      raiseSoftError('manageChildren');
+    },
+    setJSResponder: function setJSResponder(reactTag, blockNativeResponder) {
+      raiseSoftError('setJSResponder');
+    },
+    clearJSResponder: function clearJSResponder() {
+      raiseSoftError('clearJSResponder');
+    }
+  };
+  var UIManagerJSDeprecatedPlatformAPIs = _Platform.default.select({
+    android: {}
+  });
+  var UIManagerJSPlatformAPIs = _Platform.default.select({
+    android: {
+      getConstantsForViewManager: function getConstantsForViewManager(viewManagerName) {
+        if (_getConstantsForViewManager) {
+          return _getConstantsForViewManager(viewManagerName);
+        }
+        raiseSoftError('getConstantsForViewManager');
+        return {};
+      },
+      getDefaultEventTypes: function getDefaultEventTypes() {
+        if (_getDefaultEventTypes) {
+          return getDefaultEventTypesCached();
+        }
+        raiseSoftError('getDefaultEventTypes');
+        return [];
+      },
+      setLayoutAnimationEnabledExperimental: function setLayoutAnimationEnabledExperimental(enabled) {
+        if (__DEV__) {
+          console.warn('setLayoutAnimationEnabledExperimental is currently a no-op in the New Architecture.');
+        }
+      },
+      sendAccessibilityEvent: function sendAccessibilityEvent(reactTag, eventType) {
+        var AccessibilityEvent = {
+          TYPE_VIEW_FOCUSED: 0x00000008,
+          TYPE_WINDOW_STATE_CHANGED: 0x00000020,
+          TYPE_VIEW_CLICKED: 0x00000001,
+          TYPE_VIEW_HOVER_ENTER: 0x00000080
+        };
+        var eventName = null;
+        if (eventType === AccessibilityEvent.TYPE_VIEW_FOCUSED) {
+          eventName = 'focus';
+        } else if (eventType === AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED) {
+          eventName = 'windowStateChange';
+        } else if (eventType === AccessibilityEvent.TYPE_VIEW_CLICKED) {
+          eventName = 'click';
+        } else if (eventType === AccessibilityEvent.TYPE_VIEW_HOVER_ENTER) {
+          eventName = 'viewHoverEnter';
+        } else {
+          console.error(`sendAccessibilityEvent() dropping event: Called with unsupported eventType: ${eventType}`);
+          return;
+        }
+        var FabricUIManager = (0, _nullthrows.default)((0, _$$_REQUIRE(_dependencyMap[4], "./FabricUIManager").getFabricUIManager)());
+        var shadowNode = FabricUIManager.findShadowNodeByTag_DEPRECATED(reactTag);
+        if (!shadowNode) {
+          console.error(`sendAccessibilityEvent() dropping event: Cannot find view with tag #${reactTag}`);
+          return;
+        }
+        FabricUIManager.sendAccessibilityEvent(shadowNode, eventName);
+      }
+    },
+    ios: {
+      lazilyLoadView: function lazilyLoadView(name) {
+        raiseSoftError('lazilyLoadView');
+        return {};
+      },
+      focus: function focus(reactTag) {
+        var FabricUIManager = (0, _nullthrows.default)((0, _$$_REQUIRE(_dependencyMap[4], "./FabricUIManager").getFabricUIManager)());
+        var shadowNode = FabricUIManager.findShadowNodeByTag_DEPRECATED(reactTag);
+        if (!shadowNode) {
+          console.error(`focus() noop: Cannot find view with tag #${reactTag}`);
+          return;
+        }
+        FabricUIManager.dispatchCommand(shadowNode, 'focus', []);
+      },
+      blur: function blur(reactTag) {
+        var FabricUIManager = (0, _nullthrows.default)((0, _$$_REQUIRE(_dependencyMap[4], "./FabricUIManager").getFabricUIManager)());
+        var shadowNode = FabricUIManager.findShadowNodeByTag_DEPRECATED(reactTag);
+        if (!shadowNode) {
+          console.error(`blur() noop: Cannot find view with tag #${reactTag}`);
+          return;
+        }
+        FabricUIManager.dispatchCommand(shadowNode, 'blur', []);
+      }
+    }
+  });
+  var UIManagerJS = Object.assign({}, UIManagerJSOverridenAPIs, UIManagerJSDeprecatedPlatformAPIs, UIManagerJSPlatformAPIs, UIManagerJSUnusedInNewArchAPIs, {
+    getViewManagerConfig: function getViewManagerConfig(viewManagerName) {
+      if (getUIManagerConstants) {
+        var constants = getUIManagerConstantsCached();
+        if (!constants[viewManagerName] && UIManagerJS.getConstantsForViewManager) {
+          constants[viewManagerName] = UIManagerJS.getConstantsForViewManager(viewManagerName);
+        }
+        return constants[viewManagerName];
+      } else {
+        raiseSoftError(`getViewManagerConfig('${viewManagerName}')`, `If '${viewManagerName}' has a ViewManager and you want to retrieve its native ViewConfig, please turn on the native ViewConfig interop layer. If you want to see if this component is registered with React Native, please call hasViewManagerConfig('${viewManagerName}') instead.`);
+        return null;
+      }
+    },
+    hasViewManagerConfig: function hasViewManagerConfig(viewManagerName) {
+      return (0, _$$_REQUIRE(_dependencyMap[5], "../NativeComponent/NativeComponentRegistryUnstable").unstable_hasComponent)(viewManagerName);
+    },
+    getConstants: function getConstants() {
+      if (getUIManagerConstants) {
+        return getUIManagerConstantsCached();
+      } else {
+        raiseSoftError('getConstants');
+        return null;
+      }
+    },
+    findSubviewIn: function findSubviewIn(reactTag, point, callback) {
+      var FabricUIManager = (0, _nullthrows.default)((0, _$$_REQUIRE(_dependencyMap[4], "./FabricUIManager").getFabricUIManager)());
+      var shadowNode = FabricUIManager.findShadowNodeByTag_DEPRECATED(reactTag);
+      if (!shadowNode) {
+        console.error(`findSubviewIn() noop: Cannot find view with reactTag ${reactTag}`);
+        return;
+      }
+      FabricUIManager.findNodeAtPoint(shadowNode, point[0], point[1], function (internalInstanceHandle) {
+        if (internalInstanceHandle == null) {
+          console.error('findSubviewIn(): Cannot find node at point');
+          return;
+        }
+        var instanceHandle = internalInstanceHandle;
+        var node = instanceHandle.stateNode.node;
+        if (!node) {
+          console.error('findSubviewIn(): Cannot find node at point');
+          return;
+        }
+        var nativeViewTag = instanceHandle.stateNode.canonical.nativeTag;
+        FabricUIManager.measure(node, function (x, y, width, height, pageX, pageY) {
+          callback(nativeViewTag, pageX, pageY, width, height);
+        });
+      });
+    },
+    viewIsDescendantOf: function viewIsDescendantOf(reactTag, ancestorReactTag, callback) {
+      var FabricUIManager = (0, _nullthrows.default)((0, _$$_REQUIRE(_dependencyMap[4], "./FabricUIManager").getFabricUIManager)());
+      var shadowNode = FabricUIManager.findShadowNodeByTag_DEPRECATED(reactTag);
+      if (!shadowNode) {
+        console.error(`viewIsDescendantOf() noop: Cannot find view with reactTag ${reactTag}`);
+        return;
+      }
+      var ancestorShadowNode = FabricUIManager.findShadowNodeByTag_DEPRECATED(ancestorReactTag);
+      if (!ancestorShadowNode) {
+        console.error(`viewIsDescendantOf() noop: Cannot find view with ancestorReactTag ${ancestorReactTag}`);
+        return;
+      }
+      var DOCUMENT_POSITION_CONTAINED_BY = 16;
+      var result = FabricUIManager.compareDocumentPosition(ancestorShadowNode, shadowNode);
+      var isAncestor = (result & DOCUMENT_POSITION_CONTAINED_BY) !== 0;
+      callback([isAncestor]);
+    },
+    configureNextLayoutAnimation: function configureNextLayoutAnimation(config, callback, errorCallback) {
+      var FabricUIManager = (0, _nullthrows.default)((0, _$$_REQUIRE(_dependencyMap[4], "./FabricUIManager").getFabricUIManager)());
+      FabricUIManager.configureNextLayoutAnimation(config, callback, errorCallback);
+    }
+  });
+  if (getUIManagerConstants) {
+    Object.keys(getUIManagerConstantsCached()).forEach(function (viewConfigName) {
+      UIManagerJS[viewConfigName] = getUIManagerConstantsCached()[viewConfigName];
+    });
+    if (UIManagerJS.getConstants().ViewManagerNames) {
+      UIManagerJS.getConstants().ViewManagerNames.forEach(function (viewManagerName) {
+        (0, _defineLazyObjectProperty.default)(UIManagerJS, viewManagerName, {
+          get: function get() {
+            return (0, _nullthrows.default)(UIManagerJS.getConstantsForViewManager)(viewManagerName);
+          }
+        });
+      });
+    }
+  }
+  var _default = exports.default = UIManagerJS;
+},81,[1,50,68,80,82,83],"../../node_modules/react-native/Libraries/ReactNative/BridgelessUIManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.getFabricUIManager = getFabricUIManager;
+  var _defineLazyObjectProperty = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../Utilities/defineLazyObjectProperty"));
+  var nativeFabricUIManagerProxy;
+  var CACHED_PROPERTIES = ['createNode', 'cloneNode', 'cloneNodeWithNewChildren', 'cloneNodeWithNewProps', 'cloneNodeWithNewChildrenAndProps', 'createChildSet', 'appendChild', 'appendChildToSet', 'completeRoot', 'measure', 'measureInWindow', 'measureLayout', 'configureNextLayoutAnimation', 'sendAccessibilityEvent', 'findShadowNodeByTag_DEPRECATED', 'setNativeProps', 'dispatchCommand', 'compareDocumentPosition', 'getBoundingClientRect', 'unstable_DefaultEventPriority', 'unstable_DiscreteEventPriority', 'unstable_ContinuousEventPriority', 'unstable_IdleEventPriority', 'unstable_getCurrentEventPriority'];
+  function getFabricUIManager() {
+    if (nativeFabricUIManagerProxy == null && global.nativeFabricUIManager != null) {
+      nativeFabricUIManagerProxy = createProxyWithCachedProperties(global.nativeFabricUIManager, CACHED_PROPERTIES);
+    }
+    return nativeFabricUIManagerProxy;
+  }
+  function createProxyWithCachedProperties(implementation, propertiesToCache) {
+    var proxy = Object.create(implementation);
+    var _loop = function _loop(propertyName) {
+      (0, _defineLazyObjectProperty.default)(proxy, propertyName, {
+        get: function get() {
+          return implementation[propertyName];
+        }
+      });
+    };
+    for (var propertyName of propertiesToCache) {
+      _loop(propertyName);
+    }
+    return proxy;
+  }
+},82,[1,50],"../../node_modules/react-native/Libraries/ReactNative/FabricUIManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.unstable_hasComponent = unstable_hasComponent;
+  var componentNameToExists = new Map();
+  function unstable_hasComponent(name) {
+    var hasNativeComponent = componentNameToExists.get(name);
+    if (hasNativeComponent == null) {
+      if (global.__nativeComponentRegistry__hasComponent) {
+        hasNativeComponent = global.__nativeComponentRegistry__hasComponent(name);
+        componentNameToExists.set(name, hasNativeComponent);
+      } else {
+        throw `unstable_hasComponent('${name}'): Global function is not registered`;
+      }
+    }
+    return hasNativeComponent;
+  }
+},83,[],"../../node_modules/react-native/Libraries/NativeComponent/NativeComponentRegistryUnstable.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _NativeUIManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativeUIManager"));
+  var _nullthrows = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "nullthrows"));
+  var viewManagerConfigs = {};
+  var triedLoadingConfig = new Set();
+  var NativeUIManagerConstants = {};
+  var isNativeUIManagerConstantsSet = false;
+  function _getConstants() {
+    if (!isNativeUIManagerConstantsSet) {
+      NativeUIManagerConstants = _NativeUIManager.default.getConstants();
+      isNativeUIManagerConstantsSet = true;
+    }
+    return NativeUIManagerConstants;
+  }
+  function _getViewManagerConfig(viewManagerName) {
+    if (viewManagerConfigs[viewManagerName] === undefined && _NativeUIManager.default.getConstantsForViewManager) {
+      try {
+        viewManagerConfigs[viewManagerName] = _NativeUIManager.default.getConstantsForViewManager(viewManagerName);
+      } catch (e) {
+        console.error("NativeUIManager.getConstantsForViewManager('" + viewManagerName + "') threw an exception.", e);
+        viewManagerConfigs[viewManagerName] = null;
+      }
+    }
+    var config = viewManagerConfigs[viewManagerName];
+    if (config) {
+      return config;
+    }
+    if (!global.nativeCallSyncHook) {
+      return config;
+    }
+    if (_NativeUIManager.default.lazilyLoadView && !triedLoadingConfig.has(viewManagerName)) {
+      var result = (0, _nullthrows.default)(_NativeUIManager.default.lazilyLoadView)(viewManagerName);
+      triedLoadingConfig.add(viewManagerName);
+      if (result != null && result.viewConfig != null) {
+        _getConstants()[viewManagerName] = result.viewConfig;
+        lazifyViewManagerConfig(viewManagerName);
+      }
+    }
+    return viewManagerConfigs[viewManagerName];
+  }
+  var UIManagerJS = Object.assign({}, _NativeUIManager.default, {
+    createView: function createView(reactTag, viewName, rootTag, props) {
+      if ("ios" === 'ios' && viewManagerConfigs[viewName] === undefined) {
+        _getViewManagerConfig(viewName);
+      }
+      _NativeUIManager.default.createView(reactTag, viewName, rootTag, props);
+    },
+    getConstants: function getConstants() {
+      return _getConstants();
+    },
+    getViewManagerConfig: function getViewManagerConfig(viewManagerName) {
+      return _getViewManagerConfig(viewManagerName);
+    },
+    hasViewManagerConfig: function hasViewManagerConfig(viewManagerName) {
+      return _getViewManagerConfig(viewManagerName) != null;
+    }
+  });
+  _NativeUIManager.default.getViewManagerConfig = UIManagerJS.getViewManagerConfig;
+  function lazifyViewManagerConfig(viewName) {
+    var viewConfig = _getConstants()[viewName];
+    viewManagerConfigs[viewName] = viewConfig;
+    if (viewConfig.Manager) {
+      _$$_REQUIRE(_dependencyMap[3], "../Utilities/defineLazyObjectProperty").default(viewConfig, 'Constants', {
+        get: function get() {
+          var viewManager = _$$_REQUIRE(_dependencyMap[4], "../BatchedBridge/NativeModules").default[viewConfig.Manager];
+          var constants = {};
+          viewManager && Object.keys(viewManager).forEach(function (key) {
+            var value = viewManager[key];
+            if (typeof value !== 'function') {
+              constants[key] = value;
+            }
+          });
+          return constants;
+        }
+      });
+      _$$_REQUIRE(_dependencyMap[3], "../Utilities/defineLazyObjectProperty").default(viewConfig, 'Commands', {
+        get: function get() {
+          var viewManager = _$$_REQUIRE(_dependencyMap[4], "../BatchedBridge/NativeModules").default[viewConfig.Manager];
+          var commands = {};
+          var index = 0;
+          viewManager && Object.keys(viewManager).forEach(function (key) {
+            var value = viewManager[key];
+            if (typeof value === 'function') {
+              commands[key] = index++;
+            }
+          });
+          return commands;
+        }
+      });
+    }
+  }
+  if ("ios" === 'ios') {
+    Object.keys(_getConstants()).forEach(function (viewName) {
+      lazifyViewManagerConfig(viewName);
+    });
+  } else if (_getConstants().ViewManagerNames) {
+    _NativeUIManager.default.getConstants().ViewManagerNames.forEach(function (viewManagerName) {
+      _$$_REQUIRE(_dependencyMap[3], "../Utilities/defineLazyObjectProperty").default(_NativeUIManager.default, viewManagerName, {
+        get: function get() {
+          return (0, _nullthrows.default)(_NativeUIManager.default.getConstantsForViewManager)(viewManagerName);
+        }
+      });
+    });
+  }
+  if (!global.nativeCallSyncHook) {
+    Object.keys(_getConstants()).forEach(function (viewManagerName) {
+      if (!_$$_REQUIRE(_dependencyMap[5], "./UIManagerProperties").default.includes(viewManagerName)) {
+        if (!viewManagerConfigs[viewManagerName]) {
+          viewManagerConfigs[viewManagerName] = _getConstants()[viewManagerName];
+        }
+        _$$_REQUIRE(_dependencyMap[3], "../Utilities/defineLazyObjectProperty").default(_NativeUIManager.default, viewManagerName, {
+          get: function get() {
+            console.warn(`Accessing view manager configs directly off UIManager via UIManager['${viewManagerName}'] ` + `is no longer supported. Use UIManager.getViewManagerConfig('${viewManagerName}') instead.`);
+            return UIManagerJS.getViewManagerConfig(viewManagerName);
+          }
+        });
+      }
+    });
+  }
+  var _default = exports.default = UIManagerJS;
+},84,[1,85,80,50,33,87],"../../node_modules/react-native/Libraries/ReactNative/PaperUIManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeUIManager = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativeUIManager"));
+  Object.keys(_NativeUIManager).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeUIManager[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeUIManager[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeUIManager.default;
+},85,[86],"../../node_modules/react-native/Libraries/ReactNative/NativeUIManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.getEnforcing('UIManager');
+},86,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeUIManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var UIManagerProperties = ['clearJSResponder', 'configureNextLayoutAnimation', 'createView', 'dispatchViewManagerCommand', 'findSubviewIn', 'getConstantsForViewManager', 'getDefaultEventTypes', 'manageChildren', 'measure', 'measureInWindow', 'measureLayout', 'measureLayoutRelativeToParent', 'removeRootView', 'sendAccessibilityEvent', 'setChildren', 'setJSResponder', 'setLayoutAnimationEnabledExperimental', 'updateView', 'viewIsDescendantOf', 'LazyViewManagersEnabled', 'ViewManagerNames', 'StyleConstants', 'AccessibilityEventTypes', 'UIView', 'getViewManagerConfig', 'hasViewManagerConfig', 'blur', 'focus', 'genericBubblingEventTypes', 'genericDirectEventTypes', 'lazilyLoadView'];
+  var _default = exports.default = UIManagerProperties;
+},87,[],"../../node_modules/react-native/Libraries/ReactNative/UIManagerProperties.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  function matricesDiffer(one, two) {
+    if (one === two) {
+      return false;
+    }
+    return !one || !two || one[12] !== two[12] || one[13] !== two[13] || one[14] !== two[14] || one[5] !== two[5] || one[10] !== two[10] || one[0] !== two[0] || one[1] !== two[1] || one[2] !== two[2] || one[3] !== two[3] || one[4] !== two[4] || one[6] !== two[6] || one[7] !== two[7] || one[8] !== two[8] || one[9] !== two[9] || one[11] !== two[11] || one[15] !== two[15];
+  }
+  var _default = exports.default = matricesDiffer;
+},88,[],"../../node_modules/react-native/Libraries/Utilities/differ/matricesDiffer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var dummyPoint = {
+    x: undefined,
+    y: undefined
+  };
+  function pointsDiffer(one, two) {
+    one = one || dummyPoint;
+    two = two || dummyPoint;
+    return one !== two && (one.x !== two.x || one.y !== two.y);
+  }
+  var _default = exports.default = pointsDiffer;
+},89,[],"../../node_modules/react-native/Libraries/Utilities/differ/pointsDiffer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var dummyInsets = {
+    top: undefined,
+    left: undefined,
+    right: undefined,
+    bottom: undefined
+  };
+  function insetsDiffer(one, two) {
+    one = one || dummyInsets;
+    two = two || dummyInsets;
+    return one !== two && (one.top !== two.top || one.left !== two.left || one.right !== two.right || one.bottom !== two.bottom);
+  }
+  var _default = exports.default = insetsDiffer;
+},90,[],"../../node_modules/react-native/Libraries/Utilities/differ/insetsDiffer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _processColor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./processColor"));
+  var TRANSPARENT = 0;
+  function processColorArray(colors) {
+    return colors == null ? null : colors.map(processColorElement);
+  }
+  function processColorElement(color) {
+    var value = (0, _processColor.default)(color);
+    if (value == null) {
+      console.error('Invalid value in color array:', color);
+      return TRANSPARENT;
+    }
+    return value;
+  }
+  var _default = exports.default = processColorArray;
+},91,[1,57],"../../node_modules/react-native/Libraries/StyleSheet/processColorArray.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _NativeSourceCode = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../NativeModules/specs/NativeSourceCode"));
+  var _customSourceTransformers = [];
+  var _serverURL;
+  var _scriptURL;
+  var _sourceCodeScriptURL;
+  function getSourceCodeScriptURL() {
+    if (_sourceCodeScriptURL != null) {
+      return _sourceCodeScriptURL;
+    }
+    _sourceCodeScriptURL = _NativeSourceCode.default.getConstants().scriptURL;
+    return _sourceCodeScriptURL;
+  }
+  function getDevServerURL() {
+    if (_serverURL === undefined) {
+      var sourceCodeScriptURL = getSourceCodeScriptURL();
+      var match = sourceCodeScriptURL == null ? void 0 : sourceCodeScriptURL.match(/^https?:\/\/.*?\//);
+      if (match) {
+        _serverURL = match[0];
+      } else {
+        _serverURL = null;
+      }
+    }
+    return _serverURL;
+  }
+  function _coerceLocalScriptURL(scriptURL) {
+    var normalizedScriptURL = scriptURL;
+    if (normalizedScriptURL != null) {
+      if (normalizedScriptURL.startsWith('assets://')) {
+        return null;
+      }
+      normalizedScriptURL = normalizedScriptURL.substring(0, normalizedScriptURL.lastIndexOf('/') + 1);
+      if (!normalizedScriptURL.includes('://')) {
+        normalizedScriptURL = 'file://' + normalizedScriptURL;
+      }
+    }
+    return normalizedScriptURL;
+  }
+  function getScriptURL() {
+    if (_scriptURL === undefined) {
+      _scriptURL = _coerceLocalScriptURL(getSourceCodeScriptURL());
+    }
+    return _scriptURL;
+  }
+  function setCustomSourceTransformer(transformer) {
+    _customSourceTransformers = [transformer];
+  }
+  function addCustomSourceTransformer(transformer) {
+    _customSourceTransformers.push(transformer);
+  }
+  function resolveAssetSource(source) {
+    if (source == null || typeof source === 'object') {
+      return source;
+    }
+    var asset = _$$_REQUIRE(_dependencyMap[2], "@react-native/assets-registry/registry").getAssetByID(source);
+    if (!asset) {
+      return null;
+    }
+    var resolver = new (_$$_REQUIRE(_dependencyMap[3], "./AssetSourceResolver").default)(getDevServerURL(), getScriptURL(), asset);
+    if (_customSourceTransformers) {
+      for (var customSourceTransformer of _customSourceTransformers) {
+        var transformedSource = customSourceTransformer(resolver);
+        if (transformedSource != null) {
+          return transformedSource;
+        }
+      }
+    }
+    return resolver.defaultAsset();
+  }
+  resolveAssetSource.pickScale = _$$_REQUIRE(_dependencyMap[4], "./AssetUtils").pickScale;
+  resolveAssetSource.setCustomSourceTransformer = setCustomSourceTransformer;
+  resolveAssetSource.addCustomSourceTransformer = addCustomSourceTransformer;
+  var _default = exports.default = resolveAssetSource;
+},92,[1,93,95,96,97],"../../node_modules/react-native/Libraries/Image/resolveAssetSource.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeSourceCode = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../src/private/specs_DEPRECATED/modules/NativeSourceCode"));
+  Object.keys(_NativeSourceCode).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeSourceCode[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeSourceCode[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeSourceCode.default;
+},93,[94],"../../node_modules/react-native/Libraries/NativeModules/specs/NativeSourceCode.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var NativeModule = TurboModuleRegistry.getEnforcing('SourceCode');
+  var constants = null;
+  var NativeSourceCode = {
+    getConstants: function getConstants() {
+      if (constants == null) {
+        constants = NativeModule.getConstants();
+      }
+      return constants;
+    }
+  };
+  var _default = exports.default = NativeSourceCode;
+},94,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeSourceCode.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var assets = [];
+  function registerAsset(asset) {
+    return assets.push(asset);
+  }
+  function getAssetByID(assetId) {
+    return assets[assetId - 1];
+  }
+  module.exports = {
+    registerAsset: registerAsset,
+    getAssetByID: getAssetByID
+  };
+},95,[],"../../node_modules/@react-native/assets-registry/registry.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  function getScaledAssetPath(asset) {
+    var scale = _$$_REQUIRE(_dependencyMap[3], "./AssetUtils").pickScale(asset.scales, _$$_REQUIRE(_dependencyMap[4], "../Utilities/PixelRatio").default.get());
+    var scaleSuffix = scale === 1 ? '' : '@' + scale + 'x';
+    var assetDir = _$$_REQUIRE(_dependencyMap[5], "@react-native/assets-registry/path-support").getBasePath(asset);
+    return assetDir + '/' + asset.name + scaleSuffix + '.' + asset.type;
+  }
+  function getAssetPathInDrawableFolder(asset) {
+    var scale = _$$_REQUIRE(_dependencyMap[3], "./AssetUtils").pickScale(asset.scales, _$$_REQUIRE(_dependencyMap[4], "../Utilities/PixelRatio").default.get());
+    var drawableFolder = _$$_REQUIRE(_dependencyMap[5], "@react-native/assets-registry/path-support").getAndroidResourceFolderName(asset, scale);
+    var fileName = _$$_REQUIRE(_dependencyMap[5], "@react-native/assets-registry/path-support").getAndroidResourceIdentifier(asset);
+    return drawableFolder + '/' + fileName + '.' + asset.type;
+  }
+  function assetSupportsNetworkLoads(asset) {
+    return !(asset.type === 'xml' && "ios" === 'android');
+  }
+  var AssetSourceResolver = /*#__PURE__*/function () {
+    function AssetSourceResolver(serverUrl, jsbundleUrl, asset) {
+      (0, _classCallCheck2.default)(this, AssetSourceResolver);
+      this.serverUrl = serverUrl;
+      this.jsbundleUrl = jsbundleUrl;
+      this.asset = asset;
+    }
+    return (0, _createClass2.default)(AssetSourceResolver, [{
+      key: "isLoadedFromServer",
+      value: function isLoadedFromServer() {
+        return this.serverUrl != null && this.serverUrl !== '' && assetSupportsNetworkLoads(this.asset);
+      }
+    }, {
+      key: "isLoadedFromFileSystem",
+      value: function isLoadedFromFileSystem() {
+        var _this$jsbundleUrl;
+        return this.jsbundleUrl != null && ((_this$jsbundleUrl = this.jsbundleUrl) == null ? void 0 : _this$jsbundleUrl.startsWith('file://'));
+      }
+    }, {
+      key: "defaultAsset",
+      value: function defaultAsset() {
+        if (this.isLoadedFromServer()) {
+          return this.assetServerURL();
+        }
+        if (this.asset.resolver != null) {
+          return this.getAssetUsingResolver(this.asset.resolver);
+        }
+        if ("ios" === 'android') {
+          return this.isLoadedFromFileSystem() ? this.drawableFolderInBundle() : this.resourceIdentifierWithoutScale();
+        } else {
+          return this.scaledAssetURLNearBundle();
+        }
+      }
+    }, {
+      key: "getAssetUsingResolver",
+      value: function getAssetUsingResolver(resolver) {
+        switch (resolver) {
+          case 'android':
+            return this.isLoadedFromFileSystem() ? this.drawableFolderInBundle() : this.resourceIdentifierWithoutScale();
+          case 'generic':
+            return this.scaledAssetURLNearBundle();
+          default:
+            throw new Error("Don't know how to get asset via provided resolver: " + resolver + '\nAsset: ' + JSON.stringify(this.asset, null, '\t') + '\nPossible resolvers are:' + JSON.stringify(['android', 'generic'], null, '\t'));
+        }
+      }
+    }, {
+      key: "assetServerURL",
+      value: function assetServerURL() {
+        _$$_REQUIRE(_dependencyMap[6], "invariant")(this.serverUrl != null, 'need server to load from');
+        return this.fromSource(this.serverUrl + getScaledAssetPath(this.asset) + '?platform=' + "ios" + '&hash=' + this.asset.hash);
+      }
+    }, {
+      key: "scaledAssetPath",
+      value: function scaledAssetPath() {
+        return this.fromSource(getScaledAssetPath(this.asset));
+      }
+    }, {
+      key: "scaledAssetURLNearBundle",
+      value: function scaledAssetURLNearBundle() {
+        var _this$jsbundleUrl2;
+        var path = (_this$jsbundleUrl2 = this.jsbundleUrl) != null ? _this$jsbundleUrl2 : 'file://';
+        return this.fromSource(path + getScaledAssetPath(this.asset).replace(/\.\.\//g, '_'));
+      }
+    }, {
+      key: "resourceIdentifierWithoutScale",
+      value: function resourceIdentifierWithoutScale() {
+        _$$_REQUIRE(_dependencyMap[6], "invariant")("ios" === 'android', 'resource identifiers work on Android');
+        return this.fromSource(_$$_REQUIRE(_dependencyMap[5], "@react-native/assets-registry/path-support").getAndroidResourceIdentifier(this.asset));
+      }
+    }, {
+      key: "drawableFolderInBundle",
+      value: function drawableFolderInBundle() {
+        var _this$jsbundleUrl3;
+        var path = (_this$jsbundleUrl3 = this.jsbundleUrl) != null ? _this$jsbundleUrl3 : 'file://';
+        return this.fromSource(path + getAssetPathInDrawableFolder(this.asset));
+      }
+    }, {
+      key: "fromSource",
+      value: function fromSource(source) {
+        return {
+          __packager_asset: true,
+          width: this.asset.width,
+          height: this.asset.height,
+          uri: source,
+          scale: _$$_REQUIRE(_dependencyMap[3], "./AssetUtils").pickScale(this.asset.scales, _$$_REQUIRE(_dependencyMap[4], "../Utilities/PixelRatio").default.get())
+        };
+      }
+    }]);
+  }();
+  AssetSourceResolver.pickScale = _$$_REQUIRE(_dependencyMap[3], "./AssetUtils").pickScale;
+  var _default = exports.default = AssetSourceResolver;
+},96,[1,11,12,97,10,98,32],"../../node_modules/react-native/Libraries/Image/AssetSourceResolver.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.getUrlCacheBreaker = getUrlCacheBreaker;
+  exports.pickScale = pickScale;
+  exports.setUrlCacheBreaker = setUrlCacheBreaker;
+  var _PixelRatio = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../Utilities/PixelRatio"));
+  var cacheBreaker;
+  var warnIfCacheBreakerUnset = true;
+  function pickScale(scales, deviceScale) {
+    var requiredDeviceScale = deviceScale != null ? deviceScale : _PixelRatio.default.get();
+    for (var i = 0; i < scales.length; i++) {
+      if (scales[i] >= requiredDeviceScale) {
+        return scales[i];
+      }
+    }
+    return scales[scales.length - 1] || 1;
+  }
+  function setUrlCacheBreaker(appendage) {
+    cacheBreaker = appendage;
+  }
+  function getUrlCacheBreaker() {
+    if (cacheBreaker == null) {
+      if (__DEV__ && warnIfCacheBreakerUnset) {
+        warnIfCacheBreakerUnset = false;
+        console.warn('AssetUtils.getUrlCacheBreaker: Cache breaker value is unset');
+      }
+      return '';
+    }
+    return cacheBreaker;
+  }
+},97,[1,10],"../../node_modules/react-native/Libraries/Image/AssetUtils.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var androidScaleSuffix = {
+    '0.75': 'ldpi',
+    '1': 'mdpi',
+    '1.5': 'hdpi',
+    '2': 'xhdpi',
+    '3': 'xxhdpi',
+    '4': 'xxxhdpi'
+  };
+  var ANDROID_BASE_DENSITY = 160;
+  function getAndroidAssetSuffix(scale) {
+    if (scale.toString() in androidScaleSuffix) {
+      return androidScaleSuffix[scale.toString()];
+    }
+    if (Number.isFinite(scale) && scale > 0) {
+      return Math.round(scale * ANDROID_BASE_DENSITY) + 'dpi';
+    }
+    throw new Error('no such scale ' + scale.toString());
+  }
+  var drawableFileTypes = new Set(['gif', 'jpeg', 'jpg', 'ktx', 'png', 'webp', 'xml']);
+  function getAndroidResourceFolderName(asset, scale) {
+    if (!drawableFileTypes.has(asset.type)) {
+      return 'raw';
+    }
+    var suffix = getAndroidAssetSuffix(scale);
+    if (!suffix) {
+      throw new Error("Don't know which android drawable suffix to use for scale: " + scale + '\nAsset: ' + JSON.stringify(asset, null, '\t') + '\nPossible scales are:' + JSON.stringify(androidScaleSuffix, null, '\t'));
+    }
+    return 'drawable-' + suffix;
+  }
+  function getAndroidResourceIdentifier(asset) {
+    return (getBasePath(asset) + '/' + asset.name).toLowerCase().replace(/\//g, '_').replace(/([^a-z0-9_])/g, '').replace(/^(?:assets|assetsunstable_path)_/, '');
+  }
+  function getBasePath(asset) {
+    var basePath = asset.httpServerLocation;
+    return basePath.startsWith('/') ? basePath.slice(1) : basePath;
+  }
+  module.exports = {
+    getAndroidResourceFolderName: getAndroidResourceFolderName,
+    getAndroidResourceIdentifier: getAndroidResourceIdentifier,
+    getBasePath: getBasePath
+  };
+},98,[],"../../node_modules/@react-native/assets-registry/path-support.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.customDirectEventTypes = exports.customBubblingEventTypes = void 0;
+  exports.get = get;
+  exports.register = register;
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "invariant"));
+  var customBubblingEventTypes = exports.customBubblingEventTypes = {};
+  var customDirectEventTypes = exports.customDirectEventTypes = {};
+  var viewConfigCallbacks = new Map();
+  var viewConfigs = new Map();
+  function processEventTypes(viewConfig) {
+    var bubblingEventTypes = viewConfig.bubblingEventTypes,
+      directEventTypes = viewConfig.directEventTypes;
+    if (__DEV__) {
+      if (bubblingEventTypes != null && directEventTypes != null) {
+        for (var topLevelType in directEventTypes) {
+          (0, _invariant.default)(bubblingEventTypes[topLevelType] == null, 'Event cannot be both direct and bubbling: %s', topLevelType);
+        }
+      }
+    }
+    if (bubblingEventTypes != null) {
+      for (var _topLevelType in bubblingEventTypes) {
+        if (customBubblingEventTypes[_topLevelType] == null) {
+          customBubblingEventTypes[_topLevelType] = bubblingEventTypes[_topLevelType];
+        }
+      }
+    }
+    if (directEventTypes != null) {
+      for (var _topLevelType2 in directEventTypes) {
+        if (customDirectEventTypes[_topLevelType2] == null) {
+          customDirectEventTypes[_topLevelType2] = directEventTypes[_topLevelType2];
+        }
+      }
+    }
+  }
+  function register(name, callback) {
+    (0, _invariant.default)(!viewConfigCallbacks.has(name), 'Tried to register two views with the same name %s', name);
+    (0, _invariant.default)(typeof callback === 'function', 'View config getter callback for component `%s` must be a function (received `%s`)', name, callback === null ? 'null' : typeof callback);
+    viewConfigCallbacks.set(name, callback);
+    return name;
+  }
+  function get(name) {
+    var viewConfig = viewConfigs.get(name);
+    if (viewConfig == null) {
+      var callback = viewConfigCallbacks.get(name);
+      if (typeof callback !== 'function') {
+        (0, _invariant.default)(false, 'View config getter callback for component `%s` must be a function (received `%s`).%s', name, callback === null ? 'null' : typeof callback, typeof name[0] === 'string' && /[a-z]/.test(name[0]) ? ' Make sure to start component names with a capital letter.' : '');
+      }
+      viewConfig = callback();
+      (0, _invariant.default)(viewConfig, 'View config not found for component `%s`', name);
+      processEventTypes(viewConfig);
+      viewConfigs.set(name, viewConfig);
+      viewConfigCallbacks.set(name, null);
+    }
+    return viewConfig;
+  }
+},99,[1,32],"../../node_modules/react-native/Libraries/Renderer/shims/ReactNativeViewConfigRegistry.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.stringifyValidationResult = stringifyValidationResult;
+  exports.validate = validate;
+  var _toConsumableArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/toConsumableArray"));
+  var ReactNativeFeatureFlags = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[2], "../../src/private/featureflags/ReactNativeFeatureFlags"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function validate(name, nativeViewConfig, staticViewConfig) {
+    var differences = [];
+    accumulateDifferences(differences, [], {
+      bubblingEventTypes: nativeViewConfig.bubblingEventTypes,
+      directEventTypes: nativeViewConfig.directEventTypes,
+      uiViewClassName: nativeViewConfig.uiViewClassName,
+      validAttributes: nativeViewConfig.validAttributes
+    }, {
+      bubblingEventTypes: staticViewConfig.bubblingEventTypes,
+      directEventTypes: staticViewConfig.directEventTypes,
+      uiViewClassName: staticViewConfig.uiViewClassName,
+      validAttributes: staticViewConfig.validAttributes
+    });
+    if (differences.length === 0) {
+      return {
+        type: 'valid'
+      };
+    }
+    return {
+      type: 'invalid',
+      differences: differences
+    };
+  }
+  function stringifyValidationResult(name, validationResult) {
+    var differences = validationResult.differences;
+    return [`StaticViewConfigValidator: Invalid static view config for '${name}'.`, ''].concat((0, _toConsumableArray2.default)(differences.map(function (difference) {
+      var type = difference.type,
+        path = difference.path;
+      switch (type) {
+        case 'missing':
+          return `- '${path.join('.')}' is missing.`;
+        case 'unequal':
+          return `- '${path.join('.')}' is the wrong value.`;
+      }
+    })), ['']).join('\n');
+  }
+  function accumulateDifferences(differences, path, nativeObject, staticObject) {
+    for (var nativeKey in nativeObject) {
+      var nativeValue = nativeObject[nativeKey];
+      if (!staticObject.hasOwnProperty(nativeKey)) {
+        differences.push({
+          path: [].concat((0, _toConsumableArray2.default)(path), [nativeKey]),
+          type: 'missing',
+          nativeValue: nativeValue
+        });
+        continue;
+      }
+      var staticValue = staticObject[nativeKey];
+      var nativeValueIfObject = ifObject(nativeValue);
+      if (nativeValueIfObject != null) {
+        var staticValueIfObject = ifObject(staticValue);
+        if (staticValueIfObject != null) {
+          path.push(nativeKey);
+          accumulateDifferences(differences, path, nativeValueIfObject, staticValueIfObject);
+          path.pop();
+          continue;
+        }
+      }
+      if (nativeValue !== staticValue && !ReactNativeFeatureFlags.enableNativeCSSParsing()) {
+        differences.push({
+          path: [].concat((0, _toConsumableArray2.default)(path), [nativeKey]),
+          type: 'unequal',
+          nativeValue: nativeValue,
+          staticValue: staticValue
+        });
+      }
+    }
+  }
+  function ifObject(value) {
+    return typeof value === 'object' && !Array.isArray(value) ? value : null;
+  }
+},100,[1,42,52],"../../node_modules/react-native/Libraries/NativeComponent/StaticViewConfigValidator.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.createViewConfig = createViewConfig;
+  var _PlatformBaseViewConfig = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./PlatformBaseViewConfig"));
+  function createViewConfig(partialViewConfig) {
+    return {
+      uiViewClassName: partialViewConfig.uiViewClassName,
+      Commands: {},
+      bubblingEventTypes: composeIndexers(_PlatformBaseViewConfig.default.bubblingEventTypes, partialViewConfig.bubblingEventTypes),
+      directEventTypes: composeIndexers(_PlatformBaseViewConfig.default.directEventTypes, partialViewConfig.directEventTypes),
+      validAttributes: composeIndexers(_PlatformBaseViewConfig.default.validAttributes, partialViewConfig.validAttributes)
+    };
+  }
+  function composeIndexers(maybeA, maybeB) {
+    var _ref;
+    return maybeA == null || maybeB == null ? (_ref = maybeA != null ? maybeA : maybeB) != null ? _ref : {} : Object.assign({}, maybeA, maybeB);
+  }
+},101,[1,102],"../../node_modules/react-native/Libraries/NativeComponent/ViewConfig.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _BaseViewConfig = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./BaseViewConfig"));
+  var PlatformBaseViewConfig = _BaseViewConfig.default;
+  var _default = exports.default = PlatformBaseViewConfig;
+},102,[1,103],"../../node_modules/react-native/Libraries/NativeComponent/PlatformBaseViewConfig.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var ReactNativeFeatureFlags = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../src/private/featureflags/ReactNativeFeatureFlags"));
+  var _NativeReactNativeFeatureFlags = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../src/private/featureflags/specs/NativeReactNativeFeatureFlags"));
+  var _ReactNativeStyleAttributes = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../Components/View/ReactNativeStyleAttributes"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var bubblingEventTypes = {
+    topPress: {
+      phasedRegistrationNames: {
+        bubbled: 'onPress',
+        captured: 'onPressCapture'
+      }
+    },
+    topChange: {
+      phasedRegistrationNames: {
+        bubbled: 'onChange',
+        captured: 'onChangeCapture'
+      }
+    },
+    topFocus: {
+      phasedRegistrationNames: {
+        bubbled: 'onFocus',
+        captured: 'onFocusCapture'
+      }
+    },
+    topBlur: {
+      phasedRegistrationNames: {
+        bubbled: 'onBlur',
+        captured: 'onBlurCapture'
+      }
+    },
+    topSubmitEditing: {
+      phasedRegistrationNames: {
+        bubbled: 'onSubmitEditing',
+        captured: 'onSubmitEditingCapture'
+      }
+    },
+    topEndEditing: {
+      phasedRegistrationNames: {
+        bubbled: 'onEndEditing',
+        captured: 'onEndEditingCapture'
+      }
+    },
+    topKeyPress: {
+      phasedRegistrationNames: {
+        bubbled: 'onKeyPress',
+        captured: 'onKeyPressCapture'
+      }
+    },
+    topTouchStart: {
+      phasedRegistrationNames: {
+        bubbled: 'onTouchStart',
+        captured: 'onTouchStartCapture'
+      }
+    },
+    topTouchMove: {
+      phasedRegistrationNames: {
+        bubbled: 'onTouchMove',
+        captured: 'onTouchMoveCapture'
+      }
+    },
+    topTouchCancel: {
+      phasedRegistrationNames: {
+        bubbled: 'onTouchCancel',
+        captured: 'onTouchCancelCapture'
+      }
+    },
+    topTouchEnd: {
+      phasedRegistrationNames: {
+        bubbled: 'onTouchEnd',
+        captured: 'onTouchEndCapture'
+      }
+    },
+    topClick: {
+      phasedRegistrationNames: {
+        captured: 'onClickCapture',
+        bubbled: 'onClick'
+      }
+    },
+    topPointerCancel: {
+      phasedRegistrationNames: {
+        captured: 'onPointerCancelCapture',
+        bubbled: 'onPointerCancel'
+      }
+    },
+    topPointerDown: {
+      phasedRegistrationNames: {
+        captured: 'onPointerDownCapture',
+        bubbled: 'onPointerDown'
+      }
+    },
+    topPointerMove: {
+      phasedRegistrationNames: {
+        captured: 'onPointerMoveCapture',
+        bubbled: 'onPointerMove'
+      }
+    },
+    topPointerUp: {
+      phasedRegistrationNames: {
+        captured: 'onPointerUpCapture',
+        bubbled: 'onPointerUp'
+      }
+    },
+    topPointerEnter: {
+      phasedRegistrationNames: {
+        captured: 'onPointerEnterCapture',
+        bubbled: 'onPointerEnter',
+        skipBubbling: true
+      }
+    },
+    topPointerLeave: {
+      phasedRegistrationNames: {
+        captured: 'onPointerLeaveCapture',
+        bubbled: 'onPointerLeave',
+        skipBubbling: true
+      }
+    },
+    topPointerOver: {
+      phasedRegistrationNames: {
+        captured: 'onPointerOverCapture',
+        bubbled: 'onPointerOver'
+      }
+    },
+    topPointerOut: {
+      phasedRegistrationNames: {
+        captured: 'onPointerOutCapture',
+        bubbled: 'onPointerOut'
+      }
+    },
+    topGotPointerCapture: {
+      phasedRegistrationNames: {
+        captured: 'onGotPointerCaptureCapture',
+        bubbled: 'onGotPointerCapture'
+      }
+    },
+    topLostPointerCapture: {
+      phasedRegistrationNames: {
+        captured: 'onLostPointerCaptureCapture',
+        bubbled: 'onLostPointerCapture'
+      }
+    }
+  };
+  var directEventTypes = {
+    topAccessibilityAction: {
+      registrationName: 'onAccessibilityAction'
+    },
+    topAccessibilityTap: {
+      registrationName: 'onAccessibilityTap'
+    },
+    topMagicTap: {
+      registrationName: 'onMagicTap'
+    },
+    topAccessibilityEscape: {
+      registrationName: 'onAccessibilityEscape'
+    },
+    topLayout: {
+      registrationName: 'onLayout'
+    },
+    onGestureHandlerEvent: (0, _$$_REQUIRE(_dependencyMap[4], "./ViewConfigIgnore").DynamicallyInjectedByGestureHandler)({
+      registrationName: 'onGestureHandlerEvent'
+    }),
+    onGestureHandlerStateChange: (0, _$$_REQUIRE(_dependencyMap[4], "./ViewConfigIgnore").DynamicallyInjectedByGestureHandler)({
+      registrationName: 'onGestureHandlerStateChange'
+    })
+  };
+  var validAttributesForNonEventProps = {
+    accessible: true,
+    accessibilityActions: true,
+    accessibilityLabel: true,
+    accessibilityHint: true,
+    accessibilityLanguage: true,
+    accessibilityValue: true,
+    accessibilityViewIsModal: true,
+    accessibilityElementsHidden: true,
+    accessibilityIgnoresInvertColors: true,
+    accessibilityShowsLargeContentViewer: true,
+    accessibilityLargeContentTitle: true,
+    experimental_accessibilityOrder: true,
+    accessibilityRespondsToUserInteraction: true,
+    testID: true,
+    backgroundColor: {
+      process: _$$_REQUIRE(_dependencyMap[5], "../StyleSheet/processColor").default
+    },
+    backfaceVisibility: true,
+    cursor: true,
+    opacity: true,
+    shadowColor: {
+      process: _$$_REQUIRE(_dependencyMap[5], "../StyleSheet/processColor").default
+    },
+    shadowOffset: {
+      diff: _$$_REQUIRE(_dependencyMap[6], "../Utilities/differ/sizesDiffer").default
+    },
+    shadowOpacity: true,
+    shadowRadius: true,
+    needsOffscreenAlphaCompositing: true,
+    overflow: true,
+    shouldRasterizeIOS: true,
+    transform: {
+      diff: _$$_REQUIRE(_dependencyMap[7], "../Utilities/differ/matricesDiffer").default
+    },
+    transformOrigin: true,
+    accessibilityRole: true,
+    accessibilityState: true,
+    nativeID: true,
+    pointerEvents: true,
+    removeClippedSubviews: true,
+    role: true,
+    borderRadius: true,
+    borderColor: {
+      process: _$$_REQUIRE(_dependencyMap[5], "../StyleSheet/processColor").default
+    },
+    borderBlockColor: {
+      process: _$$_REQUIRE(_dependencyMap[5], "../StyleSheet/processColor").default
+    },
+    borderCurve: true,
+    borderWidth: true,
+    borderBlockWidth: true,
+    borderStyle: true,
+    hitSlop: {
+      diff: _$$_REQUIRE(_dependencyMap[8], "../Utilities/differ/insetsDiffer").default
+    },
+    collapsable: true,
+    collapsableChildren: true,
+    filter: _NativeReactNativeFeatureFlags.default != null && ReactNativeFeatureFlags.enableNativeCSSParsing() ? true : {
+      process: _$$_REQUIRE(_dependencyMap[9], "../StyleSheet/processFilter").default
+    },
+    boxShadow: _NativeReactNativeFeatureFlags.default != null && ReactNativeFeatureFlags.enableNativeCSSParsing() ? true : {
+      process: _$$_REQUIRE(_dependencyMap[10], "../StyleSheet/processBoxShadow").default
+    },
+    mixBlendMode: true,
+    isolation: true,
+    borderTopWidth: true,
+    borderTopColor: {
+      process: _$$_REQUIRE(_dependencyMap[5], "../StyleSheet/processColor").default
+    },
+    borderRightWidth: true,
+    borderRightColor: {
+      process: _$$_REQUIRE(_dependencyMap[5], "../StyleSheet/processColor").default
+    },
+    borderBottomWidth: true,
+    borderBottomColor: {
+      process: _$$_REQUIRE(_dependencyMap[5], "../StyleSheet/processColor").default
+    },
+    borderLeftWidth: true,
+    borderLeftColor: {
+      process: _$$_REQUIRE(_dependencyMap[5], "../StyleSheet/processColor").default
+    },
+    borderStartWidth: true,
+    borderBlockStartWidth: true,
+    borderStartColor: {
+      process: _$$_REQUIRE(_dependencyMap[5], "../StyleSheet/processColor").default
+    },
+    borderBlockStartColor: {
+      process: _$$_REQUIRE(_dependencyMap[5], "../StyleSheet/processColor").default
+    },
+    borderEndWidth: true,
+    borderBlockEndWidth: true,
+    borderEndColor: {
+      process: _$$_REQUIRE(_dependencyMap[5], "../StyleSheet/processColor").default
+    },
+    borderBlockEndColor: {
+      process: _$$_REQUIRE(_dependencyMap[5], "../StyleSheet/processColor").default
+    },
+    borderTopLeftRadius: true,
+    borderTopRightRadius: true,
+    borderTopStartRadius: true,
+    borderTopEndRadius: true,
+    borderBottomLeftRadius: true,
+    borderBottomRightRadius: true,
+    borderBottomStartRadius: true,
+    borderBottomEndRadius: true,
+    borderEndEndRadius: true,
+    borderEndStartRadius: true,
+    borderStartEndRadius: true,
+    borderStartStartRadius: true,
+    display: true,
+    zIndex: true,
+    top: true,
+    right: true,
+    start: true,
+    end: true,
+    bottom: true,
+    left: true,
+    inset: true,
+    insetBlock: true,
+    insetBlockEnd: true,
+    insetBlockStart: true,
+    insetInline: true,
+    insetInlineEnd: true,
+    insetInlineStart: true,
+    width: true,
+    height: true,
+    minWidth: true,
+    maxWidth: true,
+    minHeight: true,
+    maxHeight: true,
+    margin: true,
+    marginBlock: true,
+    marginBlockEnd: true,
+    marginBlockStart: true,
+    marginBottom: true,
+    marginEnd: true,
+    marginHorizontal: true,
+    marginInline: true,
+    marginInlineEnd: true,
+    marginInlineStart: true,
+    marginLeft: true,
+    marginRight: true,
+    marginStart: true,
+    marginTop: true,
+    marginVertical: true,
+    padding: true,
+    paddingBlock: true,
+    paddingBlockEnd: true,
+    paddingBlockStart: true,
+    paddingBottom: true,
+    paddingEnd: true,
+    paddingHorizontal: true,
+    paddingInline: true,
+    paddingInlineEnd: true,
+    paddingInlineStart: true,
+    paddingLeft: true,
+    paddingRight: true,
+    paddingStart: true,
+    paddingTop: true,
+    paddingVertical: true,
+    flex: true,
+    flexGrow: true,
+    rowGap: true,
+    columnGap: true,
+    gap: true,
+    flexShrink: true,
+    flexBasis: true,
+    flexDirection: true,
+    flexWrap: true,
+    justifyContent: true,
+    alignItems: true,
+    alignSelf: true,
+    alignContent: true,
+    position: true,
+    aspectRatio: true,
+    boxSizing: true,
+    direction: true,
+    style: _ReactNativeStyleAttributes.default
+  };
+  var validAttributesForEventProps = (0, _$$_REQUIRE(_dependencyMap[4], "./ViewConfigIgnore").ConditionallyIgnoredEventHandlers)({
+    onLayout: true,
+    onMagicTap: true,
+    onAccessibilityAction: true,
+    onAccessibilityEscape: true,
+    onAccessibilityTap: true,
+    onMoveShouldSetResponder: true,
+    onMoveShouldSetResponderCapture: true,
+    onStartShouldSetResponder: true,
+    onStartShouldSetResponderCapture: true,
+    onResponderGrant: true,
+    onResponderReject: true,
+    onResponderStart: true,
+    onResponderEnd: true,
+    onResponderRelease: true,
+    onResponderMove: true,
+    onResponderTerminate: true,
+    onResponderTerminationRequest: true,
+    onShouldBlockNativeResponder: true,
+    onTouchStart: true,
+    onTouchMove: true,
+    onTouchEnd: true,
+    onTouchCancel: true,
+    onClick: true,
+    onClickCapture: true,
+    onPointerUp: true,
+    onPointerDown: true,
+    onPointerCancel: true,
+    onPointerEnter: true,
+    onPointerMove: true,
+    onPointerLeave: true,
+    onPointerOver: true,
+    onPointerOut: true,
+    onGotPointerCapture: true,
+    onLostPointerCapture: true
+  });
+  var PlatformBaseViewConfigIos = {
+    bubblingEventTypes: bubblingEventTypes,
+    directEventTypes: directEventTypes,
+    validAttributes: Object.assign({}, validAttributesForNonEventProps, validAttributesForEventProps)
+  };
+  var _default = exports.default = PlatformBaseViewConfigIos;
+},103,[1,52,54,51,104,57,67,88,90,62,61],"../../node_modules/react-native/Libraries/NativeComponent/BaseViewConfig.ios.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.ConditionallyIgnoredEventHandlers = ConditionallyIgnoredEventHandlers;
+  exports.DynamicallyInjectedByGestureHandler = DynamicallyInjectedByGestureHandler;
+  exports.isIgnored = isIgnored;
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../Utilities/Platform"));
+  var ignoredViewConfigProps = new WeakSet();
+  function DynamicallyInjectedByGestureHandler(object) {
+    ignoredViewConfigProps.add(object);
+    return object;
+  }
+  function ConditionallyIgnoredEventHandlers(value) {
+    if (_Platform.default.OS === 'ios') {
+      return value;
+    }
+    return undefined;
+  }
+  function isIgnored(value) {
+    if (typeof value === 'object' && value != null) {
+      return ignoredViewConfigProps.has(value);
+    }
+    return false;
+  }
+},104,[1,68],"../../node_modules/react-native/Libraries/NativeComponent/ViewConfigIgnore.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  function codegenNativeCommands(options) {
+    var commandObj = {};
+    options.supportedCommands.forEach(function (command) {
+      commandObj[command] = function (ref) {
+        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+          args[_key - 1] = arguments[_key];
+        }
+        _$$_REQUIRE(_dependencyMap[0], "../ReactNative/RendererProxy").dispatchCommand(ref, command, args);
+      };
+    });
+    return commandObj;
+  }
+  var _default = exports.default = codegenNativeCommands;
+},105,[106],"../../node_modules/react-native/Libraries/Utilities/codegenNativeCommands.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.keys(_$$_REQUIRE(_dependencyMap[0], "./RendererImplementation")).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (key in exports && exports[key] === _$$_REQUIRE(_dependencyMap[0], "./RendererImplementation")[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _$$_REQUIRE(_dependencyMap[0], "./RendererImplementation")[key];
+      }
+    });
+  });
+},106,[107],"../../node_modules/react-native/Libraries/ReactNative/RendererProxy.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.dispatchCommand = dispatchCommand;
+  exports.findHostInstance_DEPRECATED = findHostInstance_DEPRECATED;
+  exports.findNodeHandle = findNodeHandle;
+  exports.getNodeFromInternalInstanceHandle = getNodeFromInternalInstanceHandle;
+  exports.getPublicInstanceFromInternalInstanceHandle = getPublicInstanceFromInternalInstanceHandle;
+  exports.getPublicInstanceFromRootTag = getPublicInstanceFromRootTag;
+  exports.isChildPublicInstance = isChildPublicInstance;
+  exports.isProfilingRenderer = isProfilingRenderer;
+  exports.renderElement = renderElement;
+  exports.sendAccessibilityEvent = sendAccessibilityEvent;
+  exports.unmountComponentAtNodeAndRemoveContainer = unmountComponentAtNodeAndRemoveContainer;
+  exports.unstable_batchedUpdates = unstable_batchedUpdates;
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function renderElement(_ref) {
+    var element = _ref.element,
+      rootTag = _ref.rootTag,
+      useFabric = _ref.useFabric,
+      useConcurrentRoot = _ref.useConcurrentRoot;
+    if (useFabric) {
+      _$$_REQUIRE(_dependencyMap[1], "../Renderer/shims/ReactFabric").default.render(element, rootTag, null, useConcurrentRoot, {
+        onCaughtError: _$$_REQUIRE(_dependencyMap[2], "../../src/private/renderer/errorhandling/ErrorHandlers").onCaughtError,
+        onUncaughtError: _$$_REQUIRE(_dependencyMap[2], "../../src/private/renderer/errorhandling/ErrorHandlers").onUncaughtError,
+        onRecoverableError: _$$_REQUIRE(_dependencyMap[2], "../../src/private/renderer/errorhandling/ErrorHandlers").onRecoverableError
+      });
+    } else {
+      _$$_REQUIRE(_dependencyMap[3], "../Renderer/shims/ReactNative").default.render(element, rootTag, undefined, {
+        onCaughtError: _$$_REQUIRE(_dependencyMap[2], "../../src/private/renderer/errorhandling/ErrorHandlers").onCaughtError,
+        onUncaughtError: _$$_REQUIRE(_dependencyMap[2], "../../src/private/renderer/errorhandling/ErrorHandlers").onUncaughtError,
+        onRecoverableError: _$$_REQUIRE(_dependencyMap[2], "../../src/private/renderer/errorhandling/ErrorHandlers").onRecoverableError
+      });
+    }
+  }
+  function findHostInstance_DEPRECATED(componentOrHandle) {
+    return _$$_REQUIRE(_dependencyMap[3], "../Renderer/shims/ReactNative").default.findHostInstance_DEPRECATED(componentOrHandle);
+  }
+  function findNodeHandle(componentOrHandle) {
+    return _$$_REQUIRE(_dependencyMap[3], "../Renderer/shims/ReactNative").default.findNodeHandle(componentOrHandle);
+  }
+  function dispatchCommand(handle, command, args) {
+    if (global.RN$Bridgeless === true) {
+      return _$$_REQUIRE(_dependencyMap[1], "../Renderer/shims/ReactFabric").default.dispatchCommand(handle, command, args);
+    } else {
+      return _$$_REQUIRE(_dependencyMap[3], "../Renderer/shims/ReactNative").default.dispatchCommand(handle, command, args);
+    }
+  }
+  function sendAccessibilityEvent(handle, eventType) {
+    return _$$_REQUIRE(_dependencyMap[3], "../Renderer/shims/ReactNative").default.sendAccessibilityEvent(handle, eventType);
+  }
+  function unmountComponentAtNodeAndRemoveContainer(rootTag) {
+    var rootTagAsNumber = rootTag;
+    _$$_REQUIRE(_dependencyMap[3], "../Renderer/shims/ReactNative").default.unmountComponentAtNodeAndRemoveContainer(rootTagAsNumber);
+  }
+  function unstable_batchedUpdates(fn, bookkeeping) {
+    return _$$_REQUIRE(_dependencyMap[3], "../Renderer/shims/ReactNative").default.unstable_batchedUpdates(fn, bookkeeping);
+  }
+  function isProfilingRenderer() {
+    return Boolean(__DEV__);
+  }
+  function isChildPublicInstance(parentInstance, childInstance) {
+    return _$$_REQUIRE(_dependencyMap[3], "../Renderer/shims/ReactNative").default.isChildPublicInstance(parentInstance, childInstance);
+  }
+  function getNodeFromInternalInstanceHandle(internalInstanceHandle) {
+    return _$$_REQUIRE(_dependencyMap[1], "../Renderer/shims/ReactFabric").default.getNodeFromInternalInstanceHandle(internalInstanceHandle);
+  }
+  function getPublicInstanceFromInternalInstanceHandle(internalInstanceHandle) {
+    return _$$_REQUIRE(_dependencyMap[1], "../Renderer/shims/ReactFabric").default.getPublicInstanceFromInternalInstanceHandle(internalInstanceHandle);
+  }
+  function getPublicInstanceFromRootTag(rootTag) {
+    return _$$_REQUIRE(_dependencyMap[1], "../Renderer/shims/ReactFabric").default.getPublicInstanceFromRootTag(rootTag);
+  }
+},107,[73,108,520,521],"../../node_modules/react-native/Libraries/ReactNative/RendererImplementation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var ReactFabric;
+  if (__DEV__) {
+    ReactFabric = _$$_REQUIRE(_dependencyMap[0], "../implementations/ReactFabric-dev");
+  } else {
+    ReactFabric = _$$_REQUIRE(_dependencyMap[1], "../implementations/ReactFabric-prod");
+  }
+  global.RN$stopSurface = ReactFabric.stopSurface;
+  if (global.RN$Bridgeless !== true) {
+    _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").BatchedBridge.registerCallableModule('ReactFabric', ReactFabric);
+  }
+  var _default = exports.default = ReactFabric;
+},108,[109,519,322],"../../node_modules/react-native/Libraries/Renderer/shims/ReactFabric.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  /**
+   * 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.
+   *
+   * 
+   * @nolint
+   * @preventMunge
+   * @generated SignedSource<<d944291b21bfca6afd58b1fd5a118042>>
+   *
+   * This file was sync'd from the facebook/react repository.
+   */
+
+  "use strict";
+
+  __DEV__ && function () {
+    function commitMount() {
+      throw Error("The current renderer does not support mutation. This error is likely caused by a bug in React. Please file an issue.");
+    }
+    function traverseOwnerTreeUp(hierarchy, instance) {
+      hierarchy.unshift(instance);
+      instance = instance._debugOwner;
+      null != instance && "number" === typeof instance.tag && traverseOwnerTreeUp(hierarchy, instance);
+    }
+    function getHostProps(fiber) {
+      return (fiber = findCurrentHostFiber(fiber)) ? fiber.memoizedProps || emptyObject : emptyObject;
+    }
+    function createHierarchy(fiberHierarchy) {
+      return fiberHierarchy.map(function (fiber$jscomp$0) {
+        return {
+          name: getComponentNameFromType(fiber$jscomp$0.type),
+          getInspectorData: function getInspectorData() {
+            return {
+              props: getHostProps(fiber$jscomp$0),
+              measure: function measure(callback) {
+                var hostFiber = findCurrentHostFiber(fiber$jscomp$0);
+                if (hostFiber = null != hostFiber && null !== hostFiber.stateNode && hostFiber.stateNode.node) nativeFabricUIManager.measure(hostFiber, callback);else {
+                  hostFiber = ReactNativePrivateInterface.UIManager;
+                  var JSCompiler_temp_const = hostFiber.measure,
+                    JSCompiler_inline_result;
+                  a: {
+                    for (var fiber = fiber$jscomp$0; fiber;) {
+                      null !== fiber.stateNode && 5 === fiber.tag && (JSCompiler_inline_result = findNodeHandle(fiber.stateNode));
+                      if (JSCompiler_inline_result) break a;
+                      fiber = fiber.child;
+                    }
+                    JSCompiler_inline_result = null;
+                  }
+                  return JSCompiler_temp_const.call(hostFiber, JSCompiler_inline_result, callback);
+                }
+              }
+            };
+          }
+        };
+      });
+    }
+    function findHook(fiber, id) {
+      for (fiber = fiber.memoizedState; null !== fiber && 0 < id;) fiber = fiber.next, id--;
+      return fiber;
+    }
+    function copyWithSetImpl(obj, path, index, value) {
+      if (index >= path.length) return value;
+      var key = path[index],
+        updated = isArrayImpl(obj) ? obj.slice() : assign({}, obj);
+      updated[key] = copyWithSetImpl(obj[key], path, index + 1, value);
+      return updated;
+    }
+    function copyWithRename(obj, oldPath, newPath) {
+      if (oldPath.length !== newPath.length) console.warn("copyWithRename() expects paths of the same length");else {
+        for (var i = 0; i < newPath.length - 1; i++) if (oldPath[i] !== newPath[i]) {
+          console.warn("copyWithRename() expects paths to be the same except for the deepest key");
+          return;
+        }
+        return copyWithRenameImpl(obj, oldPath, newPath, 0);
+      }
+    }
+    function copyWithRenameImpl(obj, oldPath, newPath, index) {
+      var oldKey = oldPath[index],
+        updated = isArrayImpl(obj) ? obj.slice() : assign({}, obj);
+      index + 1 === oldPath.length ? (updated[newPath[index]] = updated[oldKey], isArrayImpl(updated) ? updated.splice(oldKey, 1) : delete updated[oldKey]) : updated[oldKey] = copyWithRenameImpl(obj[oldKey], oldPath, newPath, index + 1);
+      return updated;
+    }
+    function copyWithDeleteImpl(obj, path, index) {
+      var key = path[index],
+        updated = isArrayImpl(obj) ? obj.slice() : assign({}, obj);
+      if (index + 1 === path.length) return isArrayImpl(updated) ? updated.splice(key, 1) : delete updated[key], updated;
+      updated[key] = copyWithDeleteImpl(obj[key], path, index + 1);
+      return updated;
+    }
+    function shouldSuspendImpl() {
+      return !1;
+    }
+    function shouldErrorImpl() {
+      return null;
+    }
+    function createFiber(tag, pendingProps, key, mode) {
+      return new FiberNode(tag, pendingProps, key, mode);
+    }
+    function scheduleRoot(root, element) {
+      root.context === emptyContextObject && (0 === root.tag && flushPendingEffects(), updateContainerImpl(root.current, 2, element, root, null, null), flushSyncWork());
+    }
+    function scheduleRefresh(root, update) {
+      if (null !== resolveFamily) {
+        var staleFamilies = update.staleFamilies;
+        update = update.updatedFamilies;
+        flushPendingEffects();
+        scheduleFibersWithFamiliesRecursively(root.current, update, staleFamilies);
+        flushSyncWork();
+      }
+    }
+    function setRefreshHandler(handler) {
+      resolveFamily = handler;
+    }
+    function warnForMissingKey() {}
+    function warnInvalidHookAccess() {
+      console.error("Do not call Hooks inside useEffect(...), useMemo(...), or other built-in Hooks. You can only call Hooks at the top level of your React function. For more information, see https://react.dev/link/rules-of-hooks");
+    }
+    function warnInvalidContextAccess() {
+      console.error("Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo().");
+    }
+    function setToSortedString(set) {
+      var array = [];
+      set.forEach(function (value) {
+        array.push(value);
+      });
+      return array.sort().join(", ");
+    }
+    function batchedUpdatesImpl(fn, bookkeeping) {
+      return fn(bookkeeping);
+    }
+    function disabledLog() {}
+    function disableLogs() {
+      if (0 === disabledDepth) {
+        prevLog = console.log;
+        prevInfo = console.info;
+        prevWarn = console.warn;
+        prevError = console.error;
+        prevGroup = console.group;
+        prevGroupCollapsed = console.groupCollapsed;
+        prevGroupEnd = console.groupEnd;
+        var props = {
+          configurable: !0,
+          enumerable: !0,
+          value: disabledLog,
+          writable: !0
+        };
+        Object.defineProperties(console, {
+          info: props,
+          log: props,
+          warn: props,
+          error: props,
+          group: props,
+          groupCollapsed: props,
+          groupEnd: props
+        });
+      }
+      disabledDepth++;
+    }
+    function reenableLogs() {
+      disabledDepth--;
+      if (0 === disabledDepth) {
+        var props = {
+          configurable: !0,
+          enumerable: !0,
+          writable: !0
+        };
+        Object.defineProperties(console, {
+          log: assign({}, props, {
+            value: prevLog
+          }),
+          info: assign({}, props, {
+            value: prevInfo
+          }),
+          warn: assign({}, props, {
+            value: prevWarn
+          }),
+          error: assign({}, props, {
+            value: prevError
+          }),
+          group: assign({}, props, {
+            value: prevGroup
+          }),
+          groupCollapsed: assign({}, props, {
+            value: prevGroupCollapsed
+          }),
+          groupEnd: assign({}, props, {
+            value: prevGroupEnd
+          })
+        });
+      }
+      0 > disabledDepth && console.error("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+    }
+    function describeBuiltInComponentFrame(name) {
+      if (void 0 === prefix) try {
+        throw Error();
+      } catch (x) {
+        var match = x.stack.trim().match(/\n( *(at )?)/);
+        prefix = match && match[1] || "";
+        suffix = -1 < x.stack.indexOf("\n    at") ? " (<anonymous>)" : -1 < x.stack.indexOf("@") ? "@unknown:0:0" : "";
+      }
+      return "\n" + prefix + name + suffix;
+    }
+    function describeNativeComponentFrame(fn, construct) {
+      if (!fn || reentry) return "";
+      var frame = componentFrameCache.get(fn);
+      if (void 0 !== frame) return frame;
+      reentry = !0;
+      frame = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var previousDispatcher = null;
+      previousDispatcher = ReactSharedInternals.H;
+      ReactSharedInternals.H = null;
+      disableLogs();
+      try {
+        var RunInRootFrame = {
+          DetermineComponentFrameRoot: function DetermineComponentFrameRoot() {
+            try {
+              if (construct) {
+                var Fake = function Fake() {
+                  throw Error();
+                };
+                Object.defineProperty(Fake.prototype, "props", {
+                  set: function set() {
+                    throw Error();
+                  }
+                });
+                if ("object" === typeof Reflect && Reflect.construct) {
+                  try {
+                    Reflect.construct(Fake, []);
+                  } catch (x) {
+                    var control = x;
+                  }
+                  Reflect.construct(fn, [], Fake);
+                } else {
+                  try {
+                    Fake.call();
+                  } catch (x$1) {
+                    control = x$1;
+                  }
+                  fn.call(Fake.prototype);
+                }
+              } else {
+                try {
+                  throw Error();
+                } catch (x$2) {
+                  control = x$2;
+                }
+                (Fake = fn()) && "function" === typeof Fake.catch && Fake.catch(function () {});
+              }
+            } catch (sample) {
+              if (sample && control && "string" === typeof sample.stack) return [sample.stack, control.stack];
+            }
+            return [null, null];
+          }
+        };
+        RunInRootFrame.DetermineComponentFrameRoot.displayName = "DetermineComponentFrameRoot";
+        var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, "name");
+        namePropDescriptor && namePropDescriptor.configurable && Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, "name", {
+          value: "DetermineComponentFrameRoot"
+        });
+        var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+          sampleStack = _RunInRootFrame$Deter[0],
+          controlStack = _RunInRootFrame$Deter[1];
+        if (sampleStack && controlStack) {
+          var sampleLines = sampleStack.split("\n"),
+            controlLines = controlStack.split("\n");
+          for (_RunInRootFrame$Deter = namePropDescriptor = 0; namePropDescriptor < sampleLines.length && !sampleLines[namePropDescriptor].includes("DetermineComponentFrameRoot");) namePropDescriptor++;
+          for (; _RunInRootFrame$Deter < controlLines.length && !controlLines[_RunInRootFrame$Deter].includes("DetermineComponentFrameRoot");) _RunInRootFrame$Deter++;
+          if (namePropDescriptor === sampleLines.length || _RunInRootFrame$Deter === controlLines.length) for (namePropDescriptor = sampleLines.length - 1, _RunInRootFrame$Deter = controlLines.length - 1; 1 <= namePropDescriptor && 0 <= _RunInRootFrame$Deter && sampleLines[namePropDescriptor] !== controlLines[_RunInRootFrame$Deter];) _RunInRootFrame$Deter--;
+          for (; 1 <= namePropDescriptor && 0 <= _RunInRootFrame$Deter; namePropDescriptor--, _RunInRootFrame$Deter--) if (sampleLines[namePropDescriptor] !== controlLines[_RunInRootFrame$Deter]) {
+            if (1 !== namePropDescriptor || 1 !== _RunInRootFrame$Deter) {
+              do if (namePropDescriptor--, _RunInRootFrame$Deter--, 0 > _RunInRootFrame$Deter || sampleLines[namePropDescriptor] !== controlLines[_RunInRootFrame$Deter]) {
+                var _frame = "\n" + sampleLines[namePropDescriptor].replace(" at new ", " at ");
+                fn.displayName && _frame.includes("<anonymous>") && (_frame = _frame.replace("<anonymous>", fn.displayName));
+                "function" === typeof fn && componentFrameCache.set(fn, _frame);
+                return _frame;
+              } while (1 <= namePropDescriptor && 0 <= _RunInRootFrame$Deter);
+            }
+            break;
+          }
+        }
+      } finally {
+        reentry = !1, ReactSharedInternals.H = previousDispatcher, reenableLogs(), Error.prepareStackTrace = frame;
+      }
+      sampleLines = (sampleLines = fn ? fn.displayName || fn.name : "") ? describeBuiltInComponentFrame(sampleLines) : "";
+      "function" === typeof fn && componentFrameCache.set(fn, sampleLines);
+      return sampleLines;
+    }
+    function formatOwnerStack(error) {
+      var prevPrepareStackTrace = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      error = error.stack;
+      Error.prepareStackTrace = prevPrepareStackTrace;
+      error.startsWith("Error: react-stack-top-frame\n") && (error = error.slice(29));
+      prevPrepareStackTrace = error.indexOf("\n");
+      -1 !== prevPrepareStackTrace && (error = error.slice(prevPrepareStackTrace + 1));
+      prevPrepareStackTrace = error.indexOf("react-stack-bottom-frame");
+      -1 !== prevPrepareStackTrace && (prevPrepareStackTrace = error.lastIndexOf("\n", prevPrepareStackTrace));
+      if (-1 !== prevPrepareStackTrace) error = error.slice(0, prevPrepareStackTrace);else return "";
+      return error;
+    }
+    function describeFiber(fiber) {
+      switch (fiber.tag) {
+        case 26:
+        case 27:
+        case 5:
+          return describeBuiltInComponentFrame(fiber.type);
+        case 16:
+          return describeBuiltInComponentFrame("Lazy");
+        case 13:
+          return describeBuiltInComponentFrame("Suspense");
+        case 19:
+          return describeBuiltInComponentFrame("SuspenseList");
+        case 0:
+        case 15:
+          return describeNativeComponentFrame(fiber.type, !1);
+        case 11:
+          return describeNativeComponentFrame(fiber.type.render, !1);
+        case 1:
+          return describeNativeComponentFrame(fiber.type, !0);
+        case 31:
+          return describeBuiltInComponentFrame("Activity");
+        default:
+          return "";
+      }
+    }
+    function getStackByFiberInDevAndProd(workInProgress) {
+      try {
+        var info = "";
+        do {
+          info += describeFiber(workInProgress);
+          var debugInfo = workInProgress._debugInfo;
+          if (debugInfo) for (var i = debugInfo.length - 1; 0 <= i; i--) {
+            var entry = debugInfo[i];
+            if ("string" === typeof entry.name) {
+              var JSCompiler_temp_const = info,
+                env = entry.env;
+              var JSCompiler_inline_result = describeBuiltInComponentFrame(entry.name + (env ? " [" + env + "]" : ""));
+              info = JSCompiler_temp_const + JSCompiler_inline_result;
+            }
+          }
+          workInProgress = workInProgress.return;
+        } while (workInProgress);
+        return info;
+      } catch (x) {
+        return "\nError generating stack: " + x.message + "\n" + x.stack;
+      }
+    }
+    function describeFunctionComponentFrameWithoutLineNumber(fn) {
+      return (fn = fn ? fn.displayName || fn.name : "") ? describeBuiltInComponentFrame(fn) : "";
+    }
+    function getIteratorFn(maybeIterable) {
+      if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
+      maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
+      return "function" === typeof maybeIterable ? maybeIterable : null;
+    }
+    function getComponentNameFromType(type) {
+      if (null == type) return null;
+      if ("function" === typeof type) return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+      if ("string" === typeof type) return type;
+      switch (type) {
+        case REACT_FRAGMENT_TYPE:
+          return "Fragment";
+        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_ACTIVITY_TYPE:
+          return "Activity";
+      }
+      if ("object" === typeof type) switch ("number" === typeof type.tag && console.error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), type.$$typeof) {
+        case REACT_PORTAL_TYPE:
+          return "Portal";
+        case REACT_CONTEXT_TYPE:
+          return (type.displayName || "Context") + ".Provider";
+        case REACT_CONSUMER_TYPE:
+          return (type._context.displayName || "Context") + ".Consumer";
+        case REACT_FORWARD_REF_TYPE:
+          var innerType = type.render;
+          type = type.displayName;
+          type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
+          return type;
+        case REACT_MEMO_TYPE:
+          return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
+        case REACT_LAZY_TYPE:
+          innerType = type._payload;
+          type = type._init;
+          try {
+            return getComponentNameFromType(type(innerType));
+          } catch (x) {}
+      }
+      return null;
+    }
+    function getComponentNameFromFiber(fiber) {
+      var type = fiber.type;
+      switch (fiber.tag) {
+        case 31:
+          return "Activity";
+        case 24:
+          return "Cache";
+        case 9:
+          return (type._context.displayName || "Context") + ".Consumer";
+        case 10:
+          return (type.displayName || "Context") + ".Provider";
+        case 18:
+          return "DehydratedFragment";
+        case 11:
+          return fiber = type.render, fiber = fiber.displayName || fiber.name || "", type.displayName || ("" !== fiber ? "ForwardRef(" + fiber + ")" : "ForwardRef");
+        case 7:
+          return "Fragment";
+        case 26:
+        case 27:
+        case 5:
+          return type;
+        case 4:
+          return "Portal";
+        case 3:
+          return "Root";
+        case 6:
+          return "Text";
+        case 16:
+          return getComponentNameFromType(type);
+        case 8:
+          return type === REACT_STRICT_MODE_TYPE ? "StrictMode" : "Mode";
+        case 22:
+          return "Offscreen";
+        case 12:
+          return "Profiler";
+        case 21:
+          return "Scope";
+        case 13:
+          return "Suspense";
+        case 19:
+          return "SuspenseList";
+        case 25:
+          return "TracingMarker";
+        case 30:
+        case 17:
+        case 28:
+        case 1:
+        case 0:
+        case 14:
+        case 15:
+          if ("function" === typeof type) return type.displayName || type.name || null;
+          if ("string" === typeof type) return type;
+          break;
+        case 29:
+          type = fiber._debugInfo;
+          if (null != type) for (var i = type.length - 1; 0 <= i; i--) if ("string" === typeof type[i].name) return type[i].name;
+          if (null !== fiber.return) return getComponentNameFromFiber(fiber.return);
+      }
+      return null;
+    }
+    function getCurrentFiberStackInDev() {
+      if (null === current) return "";
+      var workInProgress = current;
+      try {
+        var info = "";
+        6 === workInProgress.tag && (workInProgress = workInProgress.return);
+        switch (workInProgress.tag) {
+          case 26:
+          case 27:
+          case 5:
+            info += describeBuiltInComponentFrame(workInProgress.type);
+            break;
+          case 13:
+            info += describeBuiltInComponentFrame("Suspense");
+            break;
+          case 19:
+            info += describeBuiltInComponentFrame("SuspenseList");
+            break;
+          case 31:
+            info += describeBuiltInComponentFrame("Activity");
+            break;
+          case 30:
+          case 0:
+          case 15:
+          case 1:
+            workInProgress._debugOwner || "" !== info || (info += describeFunctionComponentFrameWithoutLineNumber(workInProgress.type));
+            break;
+          case 11:
+            workInProgress._debugOwner || "" !== info || (info += describeFunctionComponentFrameWithoutLineNumber(workInProgress.type.render));
+        }
+        for (; workInProgress;) if ("number" === typeof workInProgress.tag) {
+          var fiber = workInProgress;
+          workInProgress = fiber._debugOwner;
+          var debugStack = fiber._debugStack;
+          workInProgress && debugStack && ("string" !== typeof debugStack && (fiber._debugStack = debugStack = formatOwnerStack(debugStack)), "" !== debugStack && (info += "\n" + debugStack));
+        } else if (null != workInProgress.debugStack) {
+          var ownerStack = workInProgress.debugStack;
+          (workInProgress = workInProgress.owner) && ownerStack && (info += "\n" + formatOwnerStack(ownerStack));
+        } else break;
+        var JSCompiler_inline_result = info;
+      } catch (x) {
+        JSCompiler_inline_result = "\nError generating stack: " + x.message + "\n" + x.stack;
+      }
+      return JSCompiler_inline_result;
+    }
+    function runWithFiberInDEV(fiber, callback, arg0, arg1, arg2, arg3, arg4) {
+      var previousFiber = current;
+      setCurrentFiber(fiber);
+      try {
+        return null !== fiber && fiber._debugTask ? fiber._debugTask.run(callback.bind(null, arg0, arg1, arg2, arg3, arg4)) : callback(arg0, arg1, arg2, arg3, arg4);
+      } finally {
+        setCurrentFiber(previousFiber);
+      }
+      throw Error("runWithFiberInDEV should never be called in production. This is a bug in React.");
+    }
+    function setCurrentFiber(fiber) {
+      ReactSharedInternals.getCurrentStack = null === fiber ? null : getCurrentFiberStackInDev;
+      isRendering = !1;
+      current = fiber;
+    }
+    function validateEventDispatches(event) {
+      var dispatchListeners = event._dispatchListeners,
+        dispatchInstances = event._dispatchInstances;
+      dispatchListeners = (event = isArrayImpl(dispatchListeners)) ? dispatchListeners.length : dispatchListeners ? 1 : 0;
+      var instancesIsArr = isArrayImpl(dispatchInstances);
+      dispatchInstances = instancesIsArr ? dispatchInstances.length : dispatchInstances ? 1 : 0;
+      instancesIsArr === event && dispatchInstances === dispatchListeners || console.error("EventPluginUtils: Invalid `event`.");
+    }
+    function executeDispatch(event, listener, inst) {
+      event.currentTarget = getNodeFromInstance$1(inst);
+      try {
+        listener(event);
+      } catch (error) {
+        hasError || (hasError = !0, caughtError = error);
+      }
+      event.currentTarget = null;
+    }
+    function executeDirectDispatch(event) {
+      validateEventDispatches(event);
+      var dispatchListener = event._dispatchListeners,
+        dispatchInstance = event._dispatchInstances;
+      if (isArrayImpl(dispatchListener)) throw Error("Invalid `event`.");
+      event.currentTarget = dispatchListener ? getNodeFromInstance$1(dispatchInstance) : null;
+      dispatchListener = dispatchListener ? dispatchListener(event) : null;
+      event.currentTarget = null;
+      event._dispatchListeners = null;
+      event._dispatchInstances = null;
+      return dispatchListener;
+    }
+    function functionThatReturnsTrue() {
+      return !0;
+    }
+    function functionThatReturnsFalse() {
+      return !1;
+    }
+    function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
+      delete this.nativeEvent;
+      delete this.preventDefault;
+      delete this.stopPropagation;
+      delete this.isDefaultPrevented;
+      delete this.isPropagationStopped;
+      this.dispatchConfig = dispatchConfig;
+      this._targetInst = targetInst;
+      this.nativeEvent = nativeEvent;
+      this._dispatchInstances = this._dispatchListeners = null;
+      dispatchConfig = this.constructor.Interface;
+      for (var propName in dispatchConfig) dispatchConfig.hasOwnProperty(propName) && (delete this[propName], (targetInst = dispatchConfig[propName]) ? this[propName] = targetInst(nativeEvent) : "target" === propName ? this.target = nativeEventTarget : this[propName] = nativeEvent[propName]);
+      this.isDefaultPrevented = (null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : !1 === nativeEvent.returnValue) ? functionThatReturnsTrue : functionThatReturnsFalse;
+      this.isPropagationStopped = functionThatReturnsFalse;
+      return this;
+    }
+    function getPooledWarningPropertyDefinition(propName, getVal) {
+      function warn(action, result) {
+        console.error("This synthetic event is reused for performance reasons. If you're seeing this, you're %s `%s` on a released/nullified synthetic event. %s. If you must keep the original synthetic event around, use event.persist(). See https://react.dev/link/event-pooling for more information.", action, propName, result);
+      }
+      var isFunction = "function" === typeof getVal;
+      return {
+        configurable: !0,
+        set: function set(val) {
+          warn(isFunction ? "setting the method" : "setting the property", "This is effectively a no-op");
+          return val;
+        },
+        get: function get() {
+          warn(isFunction ? "accessing the method" : "accessing the property", isFunction ? "This is a no-op function" : "This is set to null");
+          return getVal;
+        }
+      };
+    }
+    function createOrGetPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
+      if (this.eventPool.length) {
+        var instance = this.eventPool.pop();
+        this.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst);
+        return instance;
+      }
+      return new this(dispatchConfig, targetInst, nativeEvent, nativeInst);
+    }
+    function releasePooledEvent(event) {
+      if (!(event instanceof this)) throw Error("Trying to release an event instance into a pool of a different type.");
+      event.destructor();
+      10 > this.eventPool.length && this.eventPool.push(event);
+    }
+    function addEventPoolingTo(EventConstructor) {
+      EventConstructor.getPooled = createOrGetPooledEvent;
+      EventConstructor.eventPool = [];
+      EventConstructor.release = releasePooledEvent;
+    }
+    function isStartish(topLevelType) {
+      return "topTouchStart" === topLevelType;
+    }
+    function isMoveish(topLevelType) {
+      return "topTouchMove" === topLevelType;
+    }
+    function timestampForTouch(touch) {
+      return touch.timeStamp || touch.timestamp;
+    }
+    function getTouchIdentifier(_ref) {
+      _ref = _ref.identifier;
+      if (null == _ref) throw Error("Touch object is missing identifier.");
+      20 < _ref && console.error("Touch identifier %s is greater than maximum supported %s which causes performance issues backfilling array locations for all of the indices.", _ref, 20);
+      return _ref;
+    }
+    function recordTouchStart(touch) {
+      var identifier = getTouchIdentifier(touch),
+        touchRecord = touchBank[identifier];
+      touchRecord ? (touchRecord.touchActive = !0, touchRecord.startPageX = touch.pageX, touchRecord.startPageY = touch.pageY, touchRecord.startTimeStamp = timestampForTouch(touch), touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), touchRecord.previousPageX = touch.pageX, touchRecord.previousPageY = touch.pageY, touchRecord.previousTimeStamp = timestampForTouch(touch)) : (touchRecord = {
+        touchActive: !0,
+        startPageX: touch.pageX,
+        startPageY: touch.pageY,
+        startTimeStamp: timestampForTouch(touch),
+        currentPageX: touch.pageX,
+        currentPageY: touch.pageY,
+        currentTimeStamp: timestampForTouch(touch),
+        previousPageX: touch.pageX,
+        previousPageY: touch.pageY,
+        previousTimeStamp: timestampForTouch(touch)
+      }, touchBank[identifier] = touchRecord);
+      touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+    }
+    function recordTouchMove(touch) {
+      var touchRecord = touchBank[getTouchIdentifier(touch)];
+      touchRecord ? (touchRecord.touchActive = !0, touchRecord.previousPageX = touchRecord.currentPageX, touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.warn("Cannot record touch move without a touch start.\nTouch Move: %s\nTouch Bank: %s", printTouch(touch), printTouchBank());
+    }
+    function recordTouchEnd(touch) {
+      var touchRecord = touchBank[getTouchIdentifier(touch)];
+      touchRecord ? (touchRecord.touchActive = !1, touchRecord.previousPageX = touchRecord.currentPageX, touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.warn("Cannot record touch end without a touch start.\nTouch End: %s\nTouch Bank: %s", printTouch(touch), printTouchBank());
+    }
+    function printTouch(touch) {
+      return JSON.stringify({
+        identifier: touch.identifier,
+        pageX: touch.pageX,
+        pageY: touch.pageY,
+        timestamp: timestampForTouch(touch)
+      });
+    }
+    function printTouchBank() {
+      var printed = JSON.stringify(touchBank.slice(0, 20));
+      20 < touchBank.length && (printed += " (original size: " + touchBank.length + ")");
+      return printed;
+    }
+    function accumulate(current, next) {
+      if (null == next) throw Error("Accumulated items must not be null or undefined.");
+      return null == current ? next : isArrayImpl(current) ? current.concat(next) : isArrayImpl(next) ? [current].concat(next) : [current, next];
+    }
+    function accumulateInto(current, next) {
+      if (null == next) throw Error("Accumulated items must not be null or undefined.");
+      if (null == current) return next;
+      if (isArrayImpl(current)) {
+        if (isArrayImpl(next)) return current.push.apply(current, next), current;
+        current.push(next);
+        return current;
+      }
+      return isArrayImpl(next) ? [current].concat(next) : [current, next];
+    }
+    function forEachAccumulated(arr, cb, scope) {
+      Array.isArray(arr) ? arr.forEach(cb, scope) : arr && cb.call(scope, arr);
+    }
+    function changeResponder(nextResponderInst, blockHostResponder) {
+      var oldResponderInst = responderInst;
+      responderInst = nextResponderInst;
+      if (null !== ResponderEventPlugin.GlobalResponderHandler) ResponderEventPlugin.GlobalResponderHandler.onChange(oldResponderInst, nextResponderInst, blockHostResponder);
+    }
+    function getParent$1(inst) {
+      do inst = inst.return; while (inst && 5 !== inst.tag);
+      return inst ? inst : null;
+    }
+    function traverseTwoPhase$1(inst, fn, arg) {
+      for (var path = []; inst;) path.push(inst), inst = getParent$1(inst);
+      for (inst = path.length; 0 < inst--;) fn(path[inst], "captured", arg);
+      for (inst = 0; inst < path.length; inst++) fn(path[inst], "bubbled", arg);
+    }
+    function getListener$1(inst, registrationName) {
+      inst = inst.stateNode;
+      if (null === inst) return null;
+      inst = getFiberCurrentPropsFromNode$1(inst);
+      if (null === inst) return null;
+      if ((inst = inst[registrationName]) && "function" !== typeof inst) throw Error("Expected `" + registrationName + "` listener to be a function, instead got a value of `" + typeof inst + "` type.");
+      return inst;
+    }
+    function accumulateDirectionalDispatches$1(inst, phase, event) {
+      inst || console.error("Dispatching inst must not be null");
+      if (phase = getListener$1(inst, event.dispatchConfig.phasedRegistrationNames[phase])) event._dispatchListeners = accumulateInto(event._dispatchListeners, phase), event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
+    }
+    function accumulateDirectDispatchesSingle$1(event) {
+      if (event && event.dispatchConfig.registrationName) {
+        var inst = event._targetInst;
+        if (inst && event && event.dispatchConfig.registrationName) {
+          var listener = getListener$1(inst, event.dispatchConfig.registrationName);
+          listener && (event._dispatchListeners = accumulateInto(event._dispatchListeners, listener), event._dispatchInstances = accumulateInto(event._dispatchInstances, inst));
+        }
+      }
+    }
+    function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
+      if (event && event.dispatchConfig.phasedRegistrationNames) {
+        var targetInst = event._targetInst;
+        targetInst = targetInst ? getParent$1(targetInst) : null;
+        traverseTwoPhase$1(targetInst, accumulateDirectionalDispatches$1, event);
+      }
+    }
+    function accumulateTwoPhaseDispatchesSingle$1(event) {
+      event && event.dispatchConfig.phasedRegistrationNames && traverseTwoPhase$1(event._targetInst, accumulateDirectionalDispatches$1, event);
+    }
+    function recomputePluginOrdering() {
+      if (eventPluginOrder) for (var pluginName in namesToPlugins) {
+        var pluginModule = namesToPlugins[pluginName],
+          pluginIndex = eventPluginOrder.indexOf(pluginName);
+        if (-1 >= pluginIndex) throw Error("EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `" + (pluginName + "`."));
+        if (!plugins[pluginIndex]) {
+          if (!pluginModule.extractEvents) throw Error("EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `" + (pluginName + "` does not."));
+          plugins[pluginIndex] = pluginModule;
+          pluginIndex = pluginModule.eventTypes;
+          for (var eventName in pluginIndex) {
+            var JSCompiler_inline_result = void 0;
+            var dispatchConfig = pluginIndex[eventName],
+              pluginModule$jscomp$0 = pluginModule,
+              eventName$jscomp$0 = eventName;
+            if (eventNameDispatchConfigs.hasOwnProperty(eventName$jscomp$0)) throw Error("EventPluginRegistry: More than one plugin attempted to publish the same event name, `" + (eventName$jscomp$0 + "`."));
+            eventNameDispatchConfigs[eventName$jscomp$0] = dispatchConfig;
+            if (eventName$jscomp$0 = dispatchConfig.phasedRegistrationNames) {
+              for (JSCompiler_inline_result in eventName$jscomp$0) eventName$jscomp$0.hasOwnProperty(JSCompiler_inline_result) && publishRegistrationName(eventName$jscomp$0[JSCompiler_inline_result], pluginModule$jscomp$0);
+              JSCompiler_inline_result = !0;
+            } else dispatchConfig.registrationName ? (publishRegistrationName(dispatchConfig.registrationName, pluginModule$jscomp$0), JSCompiler_inline_result = !0) : JSCompiler_inline_result = !1;
+            if (!JSCompiler_inline_result) throw Error("EventPluginRegistry: Failed to publish event `" + eventName + "` for plugin `" + pluginName + "`.");
+          }
+        }
+      }
+    }
+    function publishRegistrationName(registrationName, pluginModule) {
+      if (registrationNameModules[registrationName]) throw Error("EventPluginRegistry: More than one plugin attempted to publish the same registration name, `" + (registrationName + "`."));
+      registrationNameModules[registrationName] = pluginModule;
+      registrationName.toLowerCase();
+    }
+    function getListener(inst, registrationName) {
+      inst = inst.stateNode;
+      if (null === inst) return null;
+      inst = getFiberCurrentPropsFromNode$1(inst);
+      if (null === inst) return null;
+      if ((inst = inst[registrationName]) && "function" !== typeof inst) throw Error("Expected `" + registrationName + "` listener to be a function, instead got a value of `" + typeof inst + "` type.");
+      return inst;
+    }
+    function accumulateDirectionalDispatches(inst, phase, event) {
+      inst || console.error("Dispatching inst must not be null");
+      if (phase = getListener(inst, event.dispatchConfig.phasedRegistrationNames[phase])) event._dispatchListeners = accumulateInto(event._dispatchListeners, phase), event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
+    }
+    function traverseTwoPhase(inst, fn, arg, skipBubbling) {
+      for (var path = []; inst;) {
+        path.push(inst);
+        do inst = inst.return; while (inst && 5 !== inst.tag);
+        inst = inst ? inst : null;
+      }
+      for (inst = path.length; 0 < inst--;) fn(path[inst], "captured", arg);
+      if (skipBubbling) fn(path[0], "bubbled", arg);else for (inst = 0; inst < path.length; inst++) fn(path[inst], "bubbled", arg);
+    }
+    function accumulateTwoPhaseDispatchesSingle(event) {
+      event && event.dispatchConfig.phasedRegistrationNames && traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event, !1);
+    }
+    function accumulateDirectDispatchesSingle(event) {
+      if (event && event.dispatchConfig.registrationName) {
+        var inst = event._targetInst;
+        if (inst && event && event.dispatchConfig.registrationName) {
+          var listener = getListener(inst, event.dispatchConfig.registrationName);
+          listener && (event._dispatchListeners = accumulateInto(event._dispatchListeners, listener), event._dispatchInstances = accumulateInto(event._dispatchInstances, inst));
+        }
+      }
+    }
+    function defaultDiffer(prevProp, nextProp) {
+      return "object" !== typeof nextProp || null === nextProp ? !0 : ReactNativePrivateInterface.deepDiffer(prevProp, nextProp, deepDifferOptions);
+    }
+    function restoreDeletedValuesInNestedArray(updatePayload, node, validAttributes) {
+      if (isArrayImpl(node)) for (var i = node.length; i-- && 0 < removedKeyCount;) restoreDeletedValuesInNestedArray(updatePayload, node[i], validAttributes);else if (node && 0 < removedKeyCount) for (i in removedKeys) if (removedKeys[i]) {
+        var nextProp = node[i];
+        if (void 0 !== nextProp) {
+          var attributeConfig = validAttributes[i];
+          if (attributeConfig) {
+            "function" === typeof nextProp && (nextProp = !0);
+            "undefined" === typeof nextProp && (nextProp = null);
+            if ("object" !== typeof attributeConfig) updatePayload[i] = nextProp;else if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) nextProp = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, updatePayload[i] = nextProp;
+            removedKeys[i] = !1;
+            removedKeyCount--;
+          }
+        }
+      }
+    }
+    function diffNestedProperty(updatePayload, prevProp, nextProp, validAttributes) {
+      if (!updatePayload && prevProp === nextProp) return updatePayload;
+      if (!prevProp || !nextProp) return nextProp ? addNestedProperty(updatePayload, nextProp, validAttributes) : prevProp ? clearNestedProperty(updatePayload, prevProp, validAttributes) : updatePayload;
+      if (!isArrayImpl(prevProp) && !isArrayImpl(nextProp)) return diffProperties(updatePayload, prevProp, nextProp, validAttributes);
+      if (isArrayImpl(prevProp) && isArrayImpl(nextProp)) {
+        var minLength = prevProp.length < nextProp.length ? prevProp.length : nextProp.length,
+          i;
+        for (i = 0; i < minLength; i++) updatePayload = diffNestedProperty(updatePayload, prevProp[i], nextProp[i], validAttributes);
+        for (; i < prevProp.length; i++) updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
+        for (; i < nextProp.length; i++) updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
+        return updatePayload;
+      }
+      return isArrayImpl(prevProp) ? diffProperties(updatePayload, ReactNativePrivateInterface.flattenStyle(prevProp), nextProp, validAttributes) : diffProperties(updatePayload, prevProp, ReactNativePrivateInterface.flattenStyle(nextProp), validAttributes);
+    }
+    function addNestedProperty(updatePayload, nextProp, validAttributes) {
+      if (!nextProp) return updatePayload;
+      if (!isArrayImpl(nextProp)) return diffProperties(updatePayload, emptyObject$1, nextProp, validAttributes);
+      for (var i = 0; i < nextProp.length; i++) updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
+      return updatePayload;
+    }
+    function clearNestedProperty(updatePayload, prevProp, validAttributes) {
+      if (!prevProp) return updatePayload;
+      if (!isArrayImpl(prevProp)) return diffProperties(updatePayload, prevProp, emptyObject$1, validAttributes);
+      for (var i = 0; i < prevProp.length; i++) updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
+      return updatePayload;
+    }
+    function diffProperties(updatePayload, prevProps, nextProps, validAttributes) {
+      var attributeConfig, propKey;
+      for (propKey in nextProps) if (attributeConfig = validAttributes[propKey]) {
+        var prevProp = prevProps[propKey];
+        var nextProp = nextProps[propKey];
+        "function" === typeof nextProp && (nextProp = !0, "function" === typeof prevProp && (prevProp = !0));
+        "undefined" === typeof nextProp && (nextProp = null, "undefined" === typeof prevProp && (prevProp = null));
+        removedKeys && (removedKeys[propKey] = !1);
+        if (updatePayload && void 0 !== updatePayload[propKey]) {
+          if ("object" !== typeof attributeConfig) updatePayload[propKey] = nextProp;else {
+            if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) attributeConfig = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, updatePayload[propKey] = attributeConfig;
+          }
+        } else if (prevProp !== nextProp) if ("object" !== typeof attributeConfig) defaultDiffer(prevProp, nextProp) && ((updatePayload || (updatePayload = {}))[propKey] = nextProp);else if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) {
+          if (void 0 === prevProp || ("function" === typeof attributeConfig.diff ? attributeConfig.diff(prevProp, nextProp) : defaultDiffer(prevProp, nextProp))) attributeConfig = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, (updatePayload || (updatePayload = {}))[propKey] = attributeConfig;
+        } else removedKeys = null, removedKeyCount = 0, updatePayload = diffNestedProperty(updatePayload, prevProp, nextProp, attributeConfig), 0 < removedKeyCount && updatePayload && (restoreDeletedValuesInNestedArray(updatePayload, nextProp, attributeConfig), removedKeys = null);
+      }
+      for (var _propKey in prevProps) void 0 === nextProps[_propKey] && (!(attributeConfig = validAttributes[_propKey]) || updatePayload && void 0 !== updatePayload[_propKey] || (prevProp = prevProps[_propKey], void 0 !== prevProp && ("object" !== typeof attributeConfig || "function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process ? ((updatePayload || (updatePayload = {}))[_propKey] = null, removedKeys || (removedKeys = {}), removedKeys[_propKey] || (removedKeys[_propKey] = !0, removedKeyCount++)) : updatePayload = clearNestedProperty(updatePayload, prevProp, attributeConfig))));
+      return updatePayload;
+    }
+    function fastAddProperties(payload, props, validAttributes) {
+      if (isArrayImpl(props)) {
+        for (var i = 0; i < props.length; i++) payload = fastAddProperties(payload, props[i], validAttributes);
+        return payload;
+      }
+      for (i in props) {
+        var prop = props[i],
+          attributeConfig = validAttributes[i];
+        if (null != attributeConfig) {
+          var newValue = void 0;
+          if (void 0 === prop) {
+            if (payload && void 0 !== payload[i]) newValue = null;else continue;
+          } else "function" === typeof prop ? newValue = !0 : "object" !== typeof attributeConfig ? newValue = prop : "function" === typeof attributeConfig.process ? newValue = attributeConfig.process(prop) : "function" === typeof attributeConfig.diff && (newValue = prop);
+          void 0 !== newValue ? (payload || (payload = {}), payload[i] = newValue) : payload = fastAddProperties(payload, prop, attributeConfig);
+        }
+      }
+      return payload;
+    }
+    function batchedUpdates$1(fn, bookkeeping) {
+      if (isInsideEventHandler) return fn(bookkeeping);
+      isInsideEventHandler = !0;
+      try {
+        return batchedUpdatesImpl(fn, bookkeeping);
+      } finally {
+        isInsideEventHandler = !1;
+      }
+    }
+    function executeDispatchesAndReleaseTopLevel(e) {
+      if (e) {
+        var dispatchListeners = e._dispatchListeners,
+          dispatchInstances = e._dispatchInstances;
+        validateEventDispatches(e);
+        if (isArrayImpl(dispatchListeners)) for (var i = 0; i < dispatchListeners.length && !e.isPropagationStopped(); i++) {
+          var listener = dispatchListeners[i],
+            instance = dispatchInstances[i];
+          null !== instance ? runWithFiberInDEV(instance, executeDispatch, e, listener, instance) : executeDispatch(e, listener, instance);
+        } else dispatchListeners && (null !== dispatchInstances ? runWithFiberInDEV(dispatchInstances, executeDispatch, e, dispatchListeners, dispatchInstances) : executeDispatch(e, dispatchListeners, dispatchInstances));
+        e._dispatchListeners = null;
+        e._dispatchInstances = null;
+        e.isPersistent() || e.constructor.release(e);
+      }
+    }
+    function dispatchEvent(target, topLevelType, nativeEvent) {
+      var eventTarget = null;
+      if (null != target) {
+        var stateNode = target.stateNode;
+        null != stateNode && (eventTarget = getPublicInstance(stateNode));
+      }
+      batchedUpdates$1(function () {
+        var event = {
+          eventName: topLevelType,
+          nativeEvent: nativeEvent
+        };
+        ReactNativePrivateInterface.RawEventEmitter.emit(topLevelType, event);
+        ReactNativePrivateInterface.RawEventEmitter.emit("*", event);
+        event = eventTarget;
+        for (var events = null, legacyPlugins = plugins, i = 0; i < legacyPlugins.length; i++) {
+          var possiblePlugin = legacyPlugins[i];
+          possiblePlugin && (possiblePlugin = possiblePlugin.extractEvents(topLevelType, target, nativeEvent, event)) && (events = accumulateInto(events, possiblePlugin));
+        }
+        event = events;
+        null !== event && (eventQueue = accumulateInto(eventQueue, event));
+        event = eventQueue;
+        eventQueue = null;
+        if (event) {
+          forEachAccumulated(event, executeDispatchesAndReleaseTopLevel);
+          if (eventQueue) throw Error("processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented.");
+          if (hasError) throw event = caughtError, hasError = !1, caughtError = null, event;
+        }
+      });
+    }
+    function injectInternals(internals) {
+      if ("undefined" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) return !1;
+      var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+      if (hook.isDisabled) return !0;
+      if (!hook.supportsFiber) return console.error("The installed version of React DevTools is too old and will not work with the current version of React. Please update React DevTools. https://react.dev/link/react-devtools"), !0;
+      try {
+        rendererID = hook.inject(internals), injectedHook = hook;
+      } catch (err) {
+        console.error("React instrumentation encountered an error: %s.", err);
+      }
+      return hook.checkDCE ? !0 : !1;
+    }
+    function setIsStrictModeForDevtools(newIsStrictMode) {
+      "function" === typeof log$1 && unstable_setDisableYieldValue(newIsStrictMode);
+      if (injectedHook && "function" === typeof injectedHook.setStrictMode) try {
+        injectedHook.setStrictMode(rendererID, newIsStrictMode);
+      } catch (err) {
+        hasLoggedError || (hasLoggedError = !0, console.error("React instrumentation encountered an error: %s", err));
+      }
+    }
+    function injectProfilingHooks(profilingHooks) {
+      injectedProfilingHooks = profilingHooks;
+    }
+    function markCommitStopped() {
+      null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markCommitStopped && injectedProfilingHooks.markCommitStopped();
+    }
+    function markComponentRenderStarted(fiber) {
+      null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markComponentRenderStarted && injectedProfilingHooks.markComponentRenderStarted(fiber);
+    }
+    function markComponentRenderStopped() {
+      null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markComponentRenderStopped && injectedProfilingHooks.markComponentRenderStopped();
+    }
+    function markRenderStarted(lanes) {
+      null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markRenderStarted && injectedProfilingHooks.markRenderStarted(lanes);
+    }
+    function markRenderStopped() {
+      null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markRenderStopped && injectedProfilingHooks.markRenderStopped();
+    }
+    function markStateUpdateScheduled(fiber, lane) {
+      null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markStateUpdateScheduled && injectedProfilingHooks.markStateUpdateScheduled(fiber, lane);
+    }
+    function clz32Fallback(x) {
+      x >>>= 0;
+      return 0 === x ? 32 : 31 - (log(x) / LN2 | 0) | 0;
+    }
+    function getLabelForLane(lane) {
+      if (lane & 1) return "SyncHydrationLane";
+      if (lane & 2) return "Sync";
+      if (lane & 4) return "InputContinuousHydration";
+      if (lane & 8) return "InputContinuous";
+      if (lane & 16) return "DefaultHydration";
+      if (lane & 32) return "Default";
+      if (lane & 128) return "TransitionHydration";
+      if (lane & 4194048) return "Transition";
+      if (lane & 62914560) return "Retry";
+      if (lane & 67108864) return "SelectiveHydration";
+      if (lane & 134217728) return "IdleHydration";
+      if (lane & 268435456) return "Idle";
+      if (lane & 536870912) return "Offscreen";
+      if (lane & 1073741824) return "Deferred";
+    }
+    function getHighestPriorityLanes(lanes) {
+      var pendingSyncLanes = lanes & 42;
+      if (0 !== pendingSyncLanes) return pendingSyncLanes;
+      switch (lanes & -lanes) {
+        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:
+          return 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 lanes & 4194048;
+        case 4194304:
+        case 8388608:
+        case 16777216:
+        case 33554432:
+          return lanes & 62914560;
+        case 67108864:
+          return 67108864;
+        case 134217728:
+          return 134217728;
+        case 268435456:
+          return 268435456;
+        case 536870912:
+          return 536870912;
+        case 1073741824:
+          return 0;
+        default:
+          return console.error("Should have found matching lanes. This is a bug in React."), lanes;
+      }
+    }
+    function getNextLanes(root, wipLanes, rootHasPendingCommit) {
+      var pendingLanes = root.pendingLanes;
+      if (0 === pendingLanes) return 0;
+      var nextLanes = 0,
+        suspendedLanes = root.suspendedLanes,
+        pingedLanes = root.pingedLanes;
+      root = root.warmLanes;
+      var nonIdlePendingLanes = pendingLanes & 134217727;
+      0 !== nonIdlePendingLanes ? (pendingLanes = nonIdlePendingLanes & ~suspendedLanes, 0 !== pendingLanes ? nextLanes = getHighestPriorityLanes(pendingLanes) : (pingedLanes &= nonIdlePendingLanes, 0 !== pingedLanes ? nextLanes = getHighestPriorityLanes(pingedLanes) : rootHasPendingCommit || (rootHasPendingCommit = nonIdlePendingLanes & ~root, 0 !== rootHasPendingCommit && (nextLanes = getHighestPriorityLanes(rootHasPendingCommit))))) : (nonIdlePendingLanes = pendingLanes & ~suspendedLanes, 0 !== nonIdlePendingLanes ? nextLanes = getHighestPriorityLanes(nonIdlePendingLanes) : 0 !== pingedLanes ? nextLanes = getHighestPriorityLanes(pingedLanes) : rootHasPendingCommit || (rootHasPendingCommit = pendingLanes & ~root, 0 !== rootHasPendingCommit && (nextLanes = getHighestPriorityLanes(rootHasPendingCommit))));
+      return 0 === nextLanes ? 0 : 0 !== wipLanes && wipLanes !== nextLanes && 0 === (wipLanes & suspendedLanes) && (suspendedLanes = nextLanes & -nextLanes, rootHasPendingCommit = wipLanes & -wipLanes, suspendedLanes >= rootHasPendingCommit || 32 === suspendedLanes && 0 !== (rootHasPendingCommit & 4194048)) ? wipLanes : nextLanes;
+    }
+    function checkIfRootIsPrerendering(root, renderLanes) {
+      return 0 === (root.pendingLanes & ~(root.suspendedLanes & ~root.pingedLanes) & renderLanes);
+    }
+    function computeExpirationTime(lane, currentTime) {
+      switch (lane) {
+        case 1:
+        case 2:
+        case 4:
+        case 8:
+        case 64:
+          return currentTime + 250;
+        case 16:
+        case 32:
+        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 currentTime + 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 console.error("Should have found matching lanes. This is a bug in React."), -1;
+      }
+    }
+    function claimNextTransitionLane() {
+      var lane = nextTransitionLane;
+      nextTransitionLane <<= 1;
+      0 === (nextTransitionLane & 4194048) && (nextTransitionLane = 256);
+      return lane;
+    }
+    function claimNextRetryLane() {
+      var lane = nextRetryLane;
+      nextRetryLane <<= 1;
+      0 === (nextRetryLane & 62914560) && (nextRetryLane = 4194304);
+      return lane;
+    }
+    function createLaneMap(initial) {
+      for (var laneMap = [], i = 0; 31 > i; i++) laneMap.push(initial);
+      return laneMap;
+    }
+    function markRootUpdated$1(root, updateLane) {
+      root.pendingLanes |= updateLane;
+      268435456 !== updateLane && (root.suspendedLanes = 0, root.pingedLanes = 0, root.warmLanes = 0);
+    }
+    function markRootFinished(root, finishedLanes, remainingLanes, spawnedLane, updatedLanes, suspendedRetryLanes) {
+      var previouslyPendingLanes = root.pendingLanes;
+      root.pendingLanes = remainingLanes;
+      root.suspendedLanes = 0;
+      root.pingedLanes = 0;
+      root.warmLanes = 0;
+      root.expiredLanes &= remainingLanes;
+      root.entangledLanes &= remainingLanes;
+      root.errorRecoveryDisabledLanes &= remainingLanes;
+      root.shellSuspendCounter = 0;
+      var entanglements = root.entanglements,
+        expirationTimes = root.expirationTimes,
+        hiddenUpdates = root.hiddenUpdates;
+      for (remainingLanes = previouslyPendingLanes & ~remainingLanes; 0 < remainingLanes;) {
+        var index = 31 - clz32(remainingLanes),
+          lane = 1 << index;
+        entanglements[index] = 0;
+        expirationTimes[index] = -1;
+        var hiddenUpdatesForLane = hiddenUpdates[index];
+        if (null !== hiddenUpdatesForLane) for (hiddenUpdates[index] = null, index = 0; index < hiddenUpdatesForLane.length; index++) {
+          var update = hiddenUpdatesForLane[index];
+          null !== update && (update.lane &= -536870913);
+        }
+        remainingLanes &= ~lane;
+      }
+      0 !== spawnedLane && markSpawnedDeferredLane(root, spawnedLane, 0);
+      0 !== suspendedRetryLanes && 0 === updatedLanes && (root.suspendedLanes |= suspendedRetryLanes & ~(previouslyPendingLanes & ~finishedLanes));
+    }
+    function markSpawnedDeferredLane(root, spawnedLane, entangledLanes) {
+      root.pendingLanes |= spawnedLane;
+      root.suspendedLanes &= ~spawnedLane;
+      var spawnedLaneIndex = 31 - clz32(spawnedLane);
+      root.entangledLanes |= spawnedLane;
+      root.entanglements[spawnedLaneIndex] = root.entanglements[spawnedLaneIndex] | 1073741824 | entangledLanes & 4194090;
+    }
+    function markRootEntangled(root, entangledLanes) {
+      var rootEntangledLanes = root.entangledLanes |= entangledLanes;
+      for (root = root.entanglements; rootEntangledLanes;) {
+        var index = 31 - clz32(rootEntangledLanes),
+          lane = 1 << index;
+        lane & entangledLanes | root[index] & entangledLanes && (root[index] |= entangledLanes);
+        rootEntangledLanes &= ~lane;
+      }
+    }
+    function addFiberToLanesMap(root, fiber, lanes) {
+      if (isDevToolsPresent) for (root = root.pendingUpdatersLaneMap; 0 < lanes;) {
+        var index = 31 - clz32(lanes),
+          lane = 1 << index;
+        root[index].add(fiber);
+        lanes &= ~lane;
+      }
+    }
+    function movePendingFibersToMemoized(root, lanes) {
+      if (isDevToolsPresent) for (var pendingUpdatersLaneMap = root.pendingUpdatersLaneMap, memoizedUpdaters = root.memoizedUpdaters; 0 < lanes;) {
+        var index = 31 - clz32(lanes);
+        root = 1 << index;
+        index = pendingUpdatersLaneMap[index];
+        0 < index.size && (index.forEach(function (fiber) {
+          var alternate = fiber.alternate;
+          null !== alternate && memoizedUpdaters.has(alternate) || memoizedUpdaters.add(fiber);
+        }), index.clear());
+        lanes &= ~root;
+      }
+    }
+    function lanesToEventPriority(lanes) {
+      lanes &= -lanes;
+      return 0 !== DiscreteEventPriority && DiscreteEventPriority < lanes ? 0 !== ContinuousEventPriority && ContinuousEventPriority < lanes ? 0 !== (lanes & 134217727) ? DefaultEventPriority : IdleEventPriority : ContinuousEventPriority : DiscreteEventPriority;
+    }
+    function getNearestMountedFiber(fiber) {
+      var node = fiber,
+        nearestMounted = fiber;
+      if (fiber.alternate) for (; node.return;) node = node.return;else {
+        fiber = node;
+        do node = fiber, 0 !== (node.flags & 4098) && (nearestMounted = node.return), fiber = node.return; while (fiber);
+      }
+      return 3 === node.tag ? nearestMounted : null;
+    }
+    function assertIsMounted(fiber) {
+      if (getNearestMountedFiber(fiber) !== fiber) throw Error("Unable to find node on an unmounted component.");
+    }
+    function findCurrentFiberUsingSlowPath(fiber) {
+      var alternate = fiber.alternate;
+      if (!alternate) {
+        alternate = getNearestMountedFiber(fiber);
+        if (null === alternate) throw Error("Unable to find node on an unmounted component.");
+        return alternate !== fiber ? null : fiber;
+      }
+      for (var a = fiber, b = alternate;;) {
+        var parentA = a.return;
+        if (null === parentA) break;
+        var parentB = parentA.alternate;
+        if (null === parentB) {
+          b = parentA.return;
+          if (null !== b) {
+            a = b;
+            continue;
+          }
+          break;
+        }
+        if (parentA.child === parentB.child) {
+          for (parentB = parentA.child; parentB;) {
+            if (parentB === a) return assertIsMounted(parentA), fiber;
+            if (parentB === b) return assertIsMounted(parentA), alternate;
+            parentB = parentB.sibling;
+          }
+          throw Error("Unable to find node on an unmounted component.");
+        }
+        if (a.return !== b.return) a = parentA, b = parentB;else {
+          for (var didFindChild = !1, _child = parentA.child; _child;) {
+            if (_child === a) {
+              didFindChild = !0;
+              a = parentA;
+              b = parentB;
+              break;
+            }
+            if (_child === b) {
+              didFindChild = !0;
+              b = parentA;
+              a = parentB;
+              break;
+            }
+            _child = _child.sibling;
+          }
+          if (!didFindChild) {
+            for (_child = parentB.child; _child;) {
+              if (_child === a) {
+                didFindChild = !0;
+                a = parentB;
+                b = parentA;
+                break;
+              }
+              if (_child === b) {
+                didFindChild = !0;
+                b = parentB;
+                a = parentA;
+                break;
+              }
+              _child = _child.sibling;
+            }
+            if (!didFindChild) throw 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 Error("Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue.");
+      }
+      if (3 !== a.tag) throw Error("Unable to find node on an unmounted component.");
+      return a.stateNode.current === a ? fiber : alternate;
+    }
+    function findCurrentHostFiber(parent) {
+      parent = findCurrentFiberUsingSlowPath(parent);
+      return null !== parent ? findCurrentHostFiberImpl(parent) : null;
+    }
+    function findCurrentHostFiberImpl(node) {
+      var tag = node.tag;
+      if (5 === tag || 26 === tag || 27 === tag || 6 === tag) return node;
+      for (node = node.child; null !== node;) {
+        tag = findCurrentHostFiberImpl(node);
+        if (null !== tag) return tag;
+        node = node.sibling;
+      }
+      return null;
+    }
+    function doesFiberContain(parentFiber, childFiber) {
+      for (var parentFiberAlternate = parentFiber.alternate; null !== childFiber;) {
+        if (childFiber === parentFiber || childFiber === parentFiberAlternate) return !0;
+        childFiber = childFiber.return;
+      }
+      return !1;
+    }
+    function createCursor(defaultValue) {
+      return {
+        current: defaultValue
+      };
+    }
+    function pop(cursor, fiber) {
+      0 > index$jscomp$0 ? console.error("Unexpected pop.") : (fiber !== fiberStack[index$jscomp$0] && console.error("Unexpected Fiber popped."), cursor.current = valueStack[index$jscomp$0], valueStack[index$jscomp$0] = null, fiberStack[index$jscomp$0] = null, index$jscomp$0--);
+    }
+    function push(cursor, value, fiber) {
+      index$jscomp$0++;
+      valueStack[index$jscomp$0] = cursor.current;
+      fiberStack[index$jscomp$0] = fiber;
+      cursor.current = value;
+    }
+    function createCapturedValueAtFiber(value, source) {
+      if ("object" === typeof value && null !== value) {
+        var existing = CapturedStacks.get(value);
+        if (void 0 !== existing) return existing;
+        source = {
+          value: value,
+          source: source,
+          stack: getStackByFiberInDevAndProd(source)
+        };
+        CapturedStacks.set(value, source);
+        return source;
+      }
+      return {
+        value: value,
+        source: source,
+        stack: getStackByFiberInDevAndProd(source)
+      };
+    }
+    function requiredContext(c) {
+      null === c && console.error("Expected host context to exist. This error is likely caused by a bug in React. Please file an issue.");
+      return c;
+    }
+    function pushHostContainer(fiber, nextRootInstance) {
+      push(rootInstanceStackCursor, nextRootInstance, fiber);
+      push(contextFiberStackCursor, fiber, fiber);
+      push(contextStackCursor, null, fiber);
+      nextRootInstance = {
+        isInAParentText: !1
+      };
+      pop(contextStackCursor, fiber);
+      push(contextStackCursor, nextRootInstance, fiber);
+    }
+    function popHostContainer(fiber) {
+      pop(contextStackCursor, fiber);
+      pop(contextFiberStackCursor, fiber);
+      pop(rootInstanceStackCursor, fiber);
+    }
+    function pushHostContext(fiber) {
+      null !== fiber.memoizedState && push(hostTransitionProviderCursor, fiber, fiber);
+      var context = requiredContext(contextStackCursor.current);
+      var nextContext = fiber.type;
+      nextContext = "AndroidTextInput" === nextContext || "RCTMultilineTextInputView" === nextContext || "RCTSinglelineTextInputView" === nextContext || "RCTText" === nextContext || "RCTVirtualText" === nextContext;
+      nextContext = context.isInAParentText !== nextContext ? {
+        isInAParentText: nextContext
+      } : context;
+      context !== nextContext && (push(contextFiberStackCursor, fiber, fiber), push(contextStackCursor, nextContext, fiber));
+    }
+    function popHostContext(fiber) {
+      contextFiberStackCursor.current === fiber && (pop(contextStackCursor, fiber), pop(contextFiberStackCursor, fiber));
+      hostTransitionProviderCursor.current === fiber && (pop(hostTransitionProviderCursor, fiber), HostTransitionContext._currentValue2 = NotPendingTransition);
+    }
+    function findNotableNode(node, indent) {
+      return void 0 === node.serverProps && 0 === node.serverTail.length && 1 === node.children.length && 3 < node.distanceFromLeaf && node.distanceFromLeaf > 15 - indent ? findNotableNode(node.children[0], indent) : node;
+    }
+    function indentation(indent) {
+      return "  " + "  ".repeat(indent);
+    }
+    function added(indent) {
+      return "+ " + "  ".repeat(indent);
+    }
+    function removed(indent) {
+      return "- " + "  ".repeat(indent);
+    }
+    function describeFiberType(fiber) {
+      switch (fiber.tag) {
+        case 26:
+        case 27:
+        case 5:
+          return fiber.type;
+        case 16:
+          return "Lazy";
+        case 13:
+          return "Suspense";
+        case 19:
+          return "SuspenseList";
+        case 0:
+        case 15:
+          return fiber = fiber.type, fiber.displayName || fiber.name || null;
+        case 11:
+          return fiber = fiber.type.render, fiber.displayName || fiber.name || null;
+        case 1:
+          return fiber = fiber.type, fiber.displayName || fiber.name || null;
+        default:
+          return null;
+      }
+    }
+    function describeTextNode(content, maxLength) {
+      return needsEscaping.test(content) ? (content = JSON.stringify(content), content.length > maxLength - 2 ? 8 > maxLength ? '{"..."}' : "{" + content.slice(0, maxLength - 7) + '..."}' : "{" + content + "}") : content.length > maxLength ? 5 > maxLength ? '{"..."}' : content.slice(0, maxLength - 3) + "..." : content;
+    }
+    function describeTextDiff(clientText, serverProps, indent) {
+      var maxLength = 120 - 2 * indent;
+      if (null === serverProps) return added(indent) + describeTextNode(clientText, maxLength) + "\n";
+      if ("string" === typeof serverProps) {
+        for (var firstDiff = 0; firstDiff < serverProps.length && firstDiff < clientText.length && serverProps.charCodeAt(firstDiff) === clientText.charCodeAt(firstDiff); firstDiff++);
+        firstDiff > maxLength - 8 && 10 < firstDiff && (clientText = "..." + clientText.slice(firstDiff - 8), serverProps = "..." + serverProps.slice(firstDiff - 8));
+        return added(indent) + describeTextNode(clientText, maxLength) + "\n" + removed(indent) + describeTextNode(serverProps, maxLength) + "\n";
+      }
+      return indentation(indent) + describeTextNode(clientText, maxLength) + "\n";
+    }
+    function objectName(object) {
+      return Object.prototype.toString.call(object).replace(/^\[object (.*)\]$/, function (m, p0) {
+        return p0;
+      });
+    }
+    function describeValue(value, maxLength) {
+      switch (typeof value) {
+        case "string":
+          return value = JSON.stringify(value), value.length > maxLength ? 5 > maxLength ? '"..."' : value.slice(0, maxLength - 4) + '..."' : value;
+        case "object":
+          if (null === value) return "null";
+          if (isArrayImpl(value)) return "[...]";
+          if (value.$$typeof === REACT_ELEMENT_TYPE) return (maxLength = getComponentNameFromType(value.type)) ? "<" + maxLength + ">" : "<...>";
+          var name = objectName(value);
+          if ("Object" === name) {
+            name = "";
+            maxLength -= 2;
+            for (var propName in value) if (value.hasOwnProperty(propName)) {
+              var jsonPropName = JSON.stringify(propName);
+              jsonPropName !== '"' + propName + '"' && (propName = jsonPropName);
+              maxLength -= propName.length - 2;
+              jsonPropName = describeValue(value[propName], 15 > maxLength ? maxLength : 15);
+              maxLength -= jsonPropName.length;
+              if (0 > maxLength) {
+                name += "" === name ? "..." : ", ...";
+                break;
+              }
+              name += ("" === name ? "" : ",") + propName + ":" + jsonPropName;
+            }
+            return "{" + name + "}";
+          }
+          return name;
+        case "function":
+          return (maxLength = value.displayName || value.name) ? "function " + maxLength : "function";
+        default:
+          return String(value);
+      }
+    }
+    function describePropValue(value, maxLength) {
+      return "string" !== typeof value || needsEscaping.test(value) ? "{" + describeValue(value, maxLength - 2) + "}" : value.length > maxLength - 2 ? 5 > maxLength ? '"..."' : '"' + value.slice(0, maxLength - 5) + '..."' : '"' + value + '"';
+    }
+    function describeExpandedElement(type, props, rowPrefix) {
+      var remainingRowLength = 120 - rowPrefix.length - type.length,
+        properties = [],
+        propName;
+      for (propName in props) if (props.hasOwnProperty(propName) && "children" !== propName) {
+        var propValue = describePropValue(props[propName], 120 - rowPrefix.length - propName.length - 1);
+        remainingRowLength -= propName.length + propValue.length + 2;
+        properties.push(propName + "=" + propValue);
+      }
+      return 0 === properties.length ? rowPrefix + "<" + type + ">\n" : 0 < remainingRowLength ? rowPrefix + "<" + type + " " + properties.join(" ") + ">\n" : rowPrefix + "<" + type + "\n" + rowPrefix + "  " + properties.join("\n" + rowPrefix + "  ") + "\n" + rowPrefix + ">\n";
+    }
+    function describePropertiesDiff(clientObject, serverObject, indent) {
+      var properties = "",
+        remainingServerProperties = assign({}, serverObject),
+        propName;
+      for (propName in clientObject) if (clientObject.hasOwnProperty(propName)) {
+        delete remainingServerProperties[propName];
+        var maxLength = 120 - 2 * indent - propName.length - 2,
+          clientPropValue = describeValue(clientObject[propName], maxLength);
+        serverObject.hasOwnProperty(propName) ? (maxLength = describeValue(serverObject[propName], maxLength), properties += added(indent) + propName + ": " + clientPropValue + "\n", properties += removed(indent) + propName + ": " + maxLength + "\n") : properties += added(indent) + propName + ": " + clientPropValue + "\n";
+      }
+      for (var _propName in remainingServerProperties) remainingServerProperties.hasOwnProperty(_propName) && (clientObject = describeValue(remainingServerProperties[_propName], 120 - 2 * indent - _propName.length - 2), properties += removed(indent) + _propName + ": " + clientObject + "\n");
+      return properties;
+    }
+    function describeElementDiff(type, clientProps, serverProps, indent) {
+      var content = "",
+        serverPropNames = new Map();
+      for (propName$jscomp$0 in serverProps) serverProps.hasOwnProperty(propName$jscomp$0) && serverPropNames.set(propName$jscomp$0.toLowerCase(), propName$jscomp$0);
+      if (1 === serverPropNames.size && serverPropNames.has("children")) content += describeExpandedElement(type, clientProps, indentation(indent));else {
+        for (var _propName2 in clientProps) if (clientProps.hasOwnProperty(_propName2) && "children" !== _propName2) {
+          var maxLength$jscomp$0 = 120 - 2 * (indent + 1) - _propName2.length - 1,
+            serverPropName = serverPropNames.get(_propName2.toLowerCase());
+          if (void 0 !== serverPropName) {
+            serverPropNames.delete(_propName2.toLowerCase());
+            var propName$jscomp$0 = clientProps[_propName2];
+            serverPropName = serverProps[serverPropName];
+            var clientPropValue = describePropValue(propName$jscomp$0, maxLength$jscomp$0);
+            maxLength$jscomp$0 = describePropValue(serverPropName, maxLength$jscomp$0);
+            "object" === typeof propName$jscomp$0 && null !== propName$jscomp$0 && "object" === typeof serverPropName && null !== serverPropName && "Object" === objectName(propName$jscomp$0) && "Object" === objectName(serverPropName) && (2 < Object.keys(propName$jscomp$0).length || 2 < Object.keys(serverPropName).length || -1 < clientPropValue.indexOf("...") || -1 < maxLength$jscomp$0.indexOf("...")) ? content += indentation(indent + 1) + _propName2 + "={{\n" + describePropertiesDiff(propName$jscomp$0, serverPropName, indent + 2) + indentation(indent + 1) + "}}\n" : (content += added(indent + 1) + _propName2 + "=" + clientPropValue + "\n", content += removed(indent + 1) + _propName2 + "=" + maxLength$jscomp$0 + "\n");
+          } else content += indentation(indent + 1) + _propName2 + "=" + describePropValue(clientProps[_propName2], maxLength$jscomp$0) + "\n";
+        }
+        serverPropNames.forEach(function (propName) {
+          if ("children" !== propName) {
+            var maxLength = 120 - 2 * (indent + 1) - propName.length - 1;
+            content += removed(indent + 1) + propName + "=" + describePropValue(serverProps[propName], maxLength) + "\n";
+          }
+        });
+        content = "" === content ? indentation(indent) + "<" + type + ">\n" : indentation(indent) + "<" + type + "\n" + content + indentation(indent) + ">\n";
+      }
+      type = serverProps.children;
+      clientProps = clientProps.children;
+      if ("string" === typeof type || "number" === typeof type || "bigint" === typeof type) {
+        serverPropNames = "";
+        if ("string" === typeof clientProps || "number" === typeof clientProps || "bigint" === typeof clientProps) serverPropNames = "" + clientProps;
+        content += describeTextDiff(serverPropNames, "" + type, indent + 1);
+      } else if ("string" === typeof clientProps || "number" === typeof clientProps || "bigint" === typeof clientProps) content = null == type ? content + describeTextDiff("" + clientProps, null, indent + 1) : content + describeTextDiff("" + clientProps, void 0, indent + 1);
+      return content;
+    }
+    function describeSiblingFiber(fiber, indent) {
+      var type = describeFiberType(fiber);
+      if (null === type) {
+        type = "";
+        for (fiber = fiber.child; fiber;) type += describeSiblingFiber(fiber, indent), fiber = fiber.sibling;
+        return type;
+      }
+      return indentation(indent) + "<" + type + ">\n";
+    }
+    function describeNode(node, indent) {
+      var skipToNode = findNotableNode(node, indent);
+      if (skipToNode !== node && (1 !== node.children.length || node.children[0] !== skipToNode)) return indentation(indent) + "...\n" + describeNode(skipToNode, indent + 1);
+      skipToNode = "";
+      var debugInfo = node.fiber._debugInfo;
+      if (debugInfo) for (var i = 0; i < debugInfo.length; i++) {
+        var serverComponentName = debugInfo[i].name;
+        "string" === typeof serverComponentName && (skipToNode += indentation(indent) + "<" + serverComponentName + ">\n", indent++);
+      }
+      debugInfo = "";
+      i = node.fiber.pendingProps;
+      if (6 === node.fiber.tag) debugInfo = describeTextDiff(i, node.serverProps, indent), indent++;else if (serverComponentName = describeFiberType(node.fiber), null !== serverComponentName) if (void 0 === node.serverProps) {
+        debugInfo = indent;
+        var maxLength = 120 - 2 * debugInfo - serverComponentName.length - 2,
+          content = "";
+        for (propName in i) if (i.hasOwnProperty(propName) && "children" !== propName) {
+          var propValue = describePropValue(i[propName], 15);
+          maxLength -= propName.length + propValue.length + 2;
+          if (0 > maxLength) {
+            content += " ...";
+            break;
+          }
+          content += " " + propName + "=" + propValue;
+        }
+        debugInfo = indentation(debugInfo) + "<" + serverComponentName + content + ">\n";
+        indent++;
+      } else null === node.serverProps ? (debugInfo = describeExpandedElement(serverComponentName, i, added(indent)), indent++) : "string" === typeof node.serverProps ? console.error("Should not have matched a non HostText fiber to a Text node. This is a bug in React.") : (debugInfo = describeElementDiff(serverComponentName, i, node.serverProps, indent), indent++);
+      var propName = "";
+      i = node.fiber.child;
+      for (serverComponentName = 0; i && serverComponentName < node.children.length;) maxLength = node.children[serverComponentName], maxLength.fiber === i ? (propName += describeNode(maxLength, indent), serverComponentName++) : propName += describeSiblingFiber(i, indent), i = i.sibling;
+      i && 0 < node.children.length && (propName += indentation(indent) + "...\n");
+      i = node.serverTail;
+      null === node.serverProps && indent--;
+      for (node = 0; node < i.length; node++) serverComponentName = i[node], propName = "string" === typeof serverComponentName ? propName + (removed(indent) + describeTextNode(serverComponentName, 120 - 2 * indent) + "\n") : propName + describeExpandedElement(serverComponentName.type, serverComponentName.props, removed(indent));
+      return skipToNode + debugInfo + propName;
+    }
+    function upgradeHydrationErrorsToRecoverable() {
+      var queuedErrors = hydrationErrors;
+      null !== queuedErrors && (null === workInProgressRootRecoverableErrors ? workInProgressRootRecoverableErrors = queuedErrors : workInProgressRootRecoverableErrors.push.apply(workInProgressRootRecoverableErrors, queuedErrors), hydrationErrors = null);
+      return queuedErrors;
+    }
+    function emitPendingHydrationWarnings() {
+      var diffRoot = hydrationDiffRootDEV;
+      if (null !== diffRoot) {
+        hydrationDiffRootDEV = null;
+        try {
+          var diff = "\n\n" + describeNode(diffRoot, 0);
+        } catch (x) {
+          diff = "";
+        }
+        for (; 0 < diffRoot.children.length;) diffRoot = diffRoot.children[0];
+        runWithFiberInDEV(diffRoot.fiber, function () {
+          console.error("A tree hydrated but some attributes of the server rendered HTML didn't match the client properties. This won't be patched up. This can happen if a SSR-ed Client Component used:\n\n- A server/client branch `if (typeof window !== 'undefined')`.\n- Variable input such as `Date.now()` or `Math.random()` which changes each time it's called.\n- Date formatting in a user's locale which doesn't match the server.\n- External changing data without sending a snapshot of it along with the HTML.\n- Invalid HTML tag nesting.\n\nIt can also happen if the client has a browser extension installed which messes with the HTML before React loaded.\n\n%s%s", "https://react.dev/link/hydration-mismatch", diff);
+        });
+      }
+    }
+    function is(x, y) {
+      return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+    }
+    function resetContextDependencies() {
+      lastContextDependency = currentlyRenderingFiber$1 = null;
+      isDisallowedContextReadInDEV = !1;
+    }
+    function pushProvider(providerFiber, context, nextValue) {
+      push(valueCursor, context._currentValue2, providerFiber);
+      context._currentValue2 = nextValue;
+      push(renderer2CursorDEV, context._currentRenderer2, providerFiber);
+      void 0 !== context._currentRenderer2 && null !== context._currentRenderer2 && context._currentRenderer2 !== rendererSigil && console.error("Detected multiple renderers concurrently rendering the same context provider. This is currently unsupported.");
+      context._currentRenderer2 = rendererSigil;
+    }
+    function popProvider(context, providerFiber) {
+      context._currentValue2 = valueCursor.current;
+      var currentRenderer2 = renderer2CursorDEV.current;
+      pop(renderer2CursorDEV, providerFiber);
+      context._currentRenderer2 = currentRenderer2;
+      pop(valueCursor, providerFiber);
+    }
+    function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
+      for (; null !== parent;) {
+        var alternate = parent.alternate;
+        (parent.childLanes & renderLanes) !== renderLanes ? (parent.childLanes |= renderLanes, null !== alternate && (alternate.childLanes |= renderLanes)) : null !== alternate && (alternate.childLanes & renderLanes) !== renderLanes && (alternate.childLanes |= renderLanes);
+        if (parent === propagationRoot) break;
+        parent = parent.return;
+      }
+      parent !== propagationRoot && console.error("Expected to find the propagation root when scheduling context work. This error is likely caused by a bug in React. Please file an issue.");
+    }
+    function propagateContextChanges(workInProgress, contexts, renderLanes, forcePropagateEntireTree) {
+      var fiber = workInProgress.child;
+      null !== fiber && (fiber.return = workInProgress);
+      for (; null !== fiber;) {
+        var list = fiber.dependencies;
+        if (null !== list) {
+          var nextFiber = fiber.child;
+          list = list.firstContext;
+          a: for (; null !== list;) {
+            var dependency = list;
+            list = fiber;
+            for (var i = 0; i < contexts.length; i++) if (dependency.context === contexts[i]) {
+              list.lanes |= renderLanes;
+              dependency = list.alternate;
+              null !== dependency && (dependency.lanes |= renderLanes);
+              scheduleContextWorkOnParentPath(list.return, renderLanes, workInProgress);
+              forcePropagateEntireTree || (nextFiber = null);
+              break a;
+            }
+            list = dependency.next;
+          }
+        } else if (18 === fiber.tag) {
+          nextFiber = fiber.return;
+          if (null === nextFiber) throw Error("We just came from a parent so we must have had a parent. This is a bug in React.");
+          nextFiber.lanes |= renderLanes;
+          list = nextFiber.alternate;
+          null !== list && (list.lanes |= renderLanes);
+          scheduleContextWorkOnParentPath(nextFiber, renderLanes, workInProgress);
+          nextFiber = null;
+        } else nextFiber = fiber.child;
+        if (null !== nextFiber) nextFiber.return = fiber;else for (nextFiber = fiber; null !== nextFiber;) {
+          if (nextFiber === workInProgress) {
+            nextFiber = null;
+            break;
+          }
+          fiber = nextFiber.sibling;
+          if (null !== fiber) {
+            fiber.return = nextFiber.return;
+            nextFiber = fiber;
+            break;
+          }
+          nextFiber = nextFiber.return;
+        }
+        fiber = nextFiber;
+      }
+    }
+    function propagateParentContextChanges(current, workInProgress, renderLanes, forcePropagateEntireTree) {
+      current = null;
+      for (var parent = workInProgress, isInsidePropagationBailout = !1; null !== parent;) {
+        if (!isInsidePropagationBailout) if (0 !== (parent.flags & 524288)) isInsidePropagationBailout = !0;else if (0 !== (parent.flags & 262144)) break;
+        if (10 === parent.tag) {
+          var currentParent = parent.alternate;
+          if (null === currentParent) throw Error("Should have a current fiber. This is a bug in React.");
+          currentParent = currentParent.memoizedProps;
+          if (null !== currentParent) {
+            var context = parent.type;
+            objectIs(parent.pendingProps.value, currentParent.value) || (null !== current ? current.push(context) : current = [context]);
+          }
+        } else if (parent === hostTransitionProviderCursor.current) {
+          currentParent = parent.alternate;
+          if (null === currentParent) throw Error("Should have a current fiber. This is a bug in React.");
+          currentParent.memoizedState.memoizedState !== parent.memoizedState.memoizedState && (null !== current ? current.push(HostTransitionContext) : current = [HostTransitionContext]);
+        }
+        parent = parent.return;
+      }
+      null !== current && propagateContextChanges(workInProgress, current, renderLanes, forcePropagateEntireTree);
+      workInProgress.flags |= 262144;
+    }
+    function checkIfContextChanged(currentDependencies) {
+      for (currentDependencies = currentDependencies.firstContext; null !== currentDependencies;) {
+        if (!objectIs(currentDependencies.context._currentValue2, currentDependencies.memoizedValue)) return !0;
+        currentDependencies = currentDependencies.next;
+      }
+      return !1;
+    }
+    function prepareToReadContext(workInProgress) {
+      currentlyRenderingFiber$1 = workInProgress;
+      lastContextDependency = null;
+      workInProgress = workInProgress.dependencies;
+      null !== workInProgress && (workInProgress.firstContext = null);
+    }
+    function _readContext(context) {
+      isDisallowedContextReadInDEV && console.error("Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo().");
+      return readContextForConsumer(currentlyRenderingFiber$1, context);
+    }
+    function readContextDuringReconciliation(consumer, context) {
+      null === currentlyRenderingFiber$1 && prepareToReadContext(consumer);
+      return readContextForConsumer(consumer, context);
+    }
+    function readContextForConsumer(consumer, context) {
+      var value = context._currentValue2;
+      context = {
+        context: context,
+        memoizedValue: value,
+        next: null
+      };
+      if (null === lastContextDependency) {
+        if (null === consumer) throw Error("Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo().");
+        lastContextDependency = context;
+        consumer.dependencies = {
+          lanes: 0,
+          firstContext: context,
+          _debugThenableState: null
+        };
+        consumer.flags |= 524288;
+      } else lastContextDependency = lastContextDependency.next = context;
+      return value;
+    }
+    function createCache() {
+      return {
+        controller: new AbortControllerLocal(),
+        data: new Map(),
+        refCount: 0
+      };
+    }
+    function retainCache(cache) {
+      cache.controller.signal.aborted && console.warn("A cache instance was retained after it was already freed. This likely indicates a bug in React.");
+      cache.refCount++;
+    }
+    function releaseCache(cache) {
+      cache.refCount--;
+      0 > cache.refCount && console.warn("A cache instance was released after it was already freed. This likely indicates a bug in React.");
+      0 === cache.refCount && scheduleCallback$2(NormalPriority, function () {
+        cache.controller.abort();
+      });
+    }
+    function pushNestedEffectDurations() {
+      var prevEffectDuration = profilerEffectDuration;
+      profilerEffectDuration = 0;
+      return prevEffectDuration;
+    }
+    function popNestedEffectDurations(prevEffectDuration) {
+      var elapsedTime = profilerEffectDuration;
+      profilerEffectDuration = prevEffectDuration;
+      return elapsedTime;
+    }
+    function bubbleNestedEffectDurations(prevEffectDuration) {
+      var elapsedTime = profilerEffectDuration;
+      profilerEffectDuration += prevEffectDuration;
+      return elapsedTime;
+    }
+    function startProfilerTimer(fiber) {
+      profilerStartTime = now();
+      0 > fiber.actualStartTime && (fiber.actualStartTime = profilerStartTime);
+    }
+    function stopProfilerTimerIfRunningAndRecordDuration(fiber) {
+      if (0 <= profilerStartTime) {
+        var elapsedTime = now() - profilerStartTime;
+        fiber.actualDuration += elapsedTime;
+        fiber.selfBaseDuration = elapsedTime;
+        profilerStartTime = -1;
+      }
+    }
+    function stopProfilerTimerIfRunningAndRecordIncompleteDuration(fiber) {
+      if (0 <= profilerStartTime) {
+        var elapsedTime = now() - profilerStartTime;
+        fiber.actualDuration += elapsedTime;
+        profilerStartTime = -1;
+      }
+    }
+    function recordEffectDuration() {
+      if (0 <= profilerStartTime) {
+        var elapsedTime = now() - profilerStartTime;
+        profilerStartTime = -1;
+        profilerEffectDuration += elapsedTime;
+      }
+    }
+    function startEffectTimer() {
+      profilerStartTime = now();
+    }
+    function transferActualDuration(fiber) {
+      for (var child = fiber.child; child;) fiber.actualDuration += child.actualDuration, child = child.sibling;
+    }
+    function ensureRootIsScheduled(root) {
+      root !== lastScheduledRoot && null === root.next && (null === lastScheduledRoot ? firstScheduledRoot = lastScheduledRoot = root : lastScheduledRoot = lastScheduledRoot.next = root);
+      mightHavePendingSyncWork = !0;
+      null !== ReactSharedInternals.actQueue ? didScheduleMicrotask_act || (didScheduleMicrotask_act = !0, scheduleImmediateRootScheduleTask()) : didScheduleMicrotask || (didScheduleMicrotask = !0, scheduleImmediateRootScheduleTask());
+      ReactSharedInternals.isBatchingLegacy && 0 === root.tag && (ReactSharedInternals.didScheduleLegacyUpdate = !0);
+    }
+    function flushSyncWorkAcrossRoots_impl(syncTransitionLanes, onlyLegacy) {
+      if (!isFlushingWork && mightHavePendingSyncWork) {
+        isFlushingWork = !0;
+        do {
+          var didPerformSomeWork = !1;
+          for (var root = firstScheduledRoot; null !== root;) {
+            if (!onlyLegacy || 0 === root.tag) if (0 !== syncTransitionLanes) {
+              var pendingLanes = root.pendingLanes;
+              if (0 === pendingLanes) var nextLanes = 0;else {
+                var suspendedLanes = root.suspendedLanes,
+                  pingedLanes = root.pingedLanes;
+                nextLanes = (1 << 31 - clz32(42 | syncTransitionLanes) + 1) - 1;
+                nextLanes &= pendingLanes & ~(suspendedLanes & ~pingedLanes);
+                nextLanes = nextLanes & 201326741 ? nextLanes & 201326741 | 1 : nextLanes ? nextLanes | 2 : 0;
+              }
+              0 !== nextLanes && (didPerformSomeWork = !0, performSyncWorkOnRoot(root, nextLanes));
+            } else nextLanes = workInProgressRootRenderLanes, nextLanes = getNextLanes(root, root === workInProgressRoot ? nextLanes : 0, null !== root.cancelPendingCommit || root.timeoutHandle !== noTimeout), 0 === (nextLanes & 3) || checkIfRootIsPrerendering(root, nextLanes) || (didPerformSomeWork = !0, performSyncWorkOnRoot(root, nextLanes));
+            root = root.next;
+          }
+        } while (didPerformSomeWork);
+        isFlushingWork = !1;
+      }
+    }
+    function processRootScheduleInImmediateTask() {
+      processRootScheduleInMicrotask();
+    }
+    function processRootScheduleInMicrotask() {
+      mightHavePendingSyncWork = didScheduleMicrotask_act = didScheduleMicrotask = !1;
+      0 !== currentEventTransitionLane && (currentEventTransitionLane = 0);
+      for (var currentTime = now$1(), prev = null, root = firstScheduledRoot; null !== root;) {
+        var next = root.next,
+          nextLanes = scheduleTaskForRootDuringMicrotask(root, currentTime);
+        0 === nextLanes ? (root.next = null, null === prev ? firstScheduledRoot = next : prev.next = next, null === next && (lastScheduledRoot = prev)) : (prev = root, 0 !== (nextLanes & 3) && (mightHavePendingSyncWork = !0));
+        root = next;
+      }
+      flushSyncWorkAcrossRoots_impl(0, !1);
+    }
+    function scheduleTaskForRootDuringMicrotask(root, currentTime) {
+      for (var suspendedLanes = root.suspendedLanes, pingedLanes = root.pingedLanes, expirationTimes = root.expirationTimes, lanes = root.pendingLanes & -62914561; 0 < lanes;) {
+        var index = 31 - clz32(lanes),
+          lane = 1 << index,
+          expirationTime = expirationTimes[index];
+        if (-1 === expirationTime) {
+          if (0 === (lane & suspendedLanes) || 0 !== (lane & pingedLanes)) expirationTimes[index] = computeExpirationTime(lane, currentTime);
+        } else expirationTime <= currentTime && (root.expiredLanes |= lane);
+        lanes &= ~lane;
+      }
+      currentTime = workInProgressRoot;
+      suspendedLanes = workInProgressRootRenderLanes;
+      suspendedLanes = getNextLanes(root, root === currentTime ? suspendedLanes : 0, null !== root.cancelPendingCommit || root.timeoutHandle !== noTimeout);
+      pingedLanes = root.callbackNode;
+      if (0 === suspendedLanes || root === currentTime && (workInProgressSuspendedReason === SuspendedOnData || workInProgressSuspendedReason === SuspendedOnAction) || null !== root.cancelPendingCommit) return null !== pingedLanes && cancelCallback(pingedLanes), root.callbackNode = null, root.callbackPriority = 0;
+      if (0 === (suspendedLanes & 3) || checkIfRootIsPrerendering(root, suspendedLanes)) {
+        currentTime = suspendedLanes & -suspendedLanes;
+        if (currentTime !== root.callbackPriority || null !== ReactSharedInternals.actQueue && pingedLanes !== fakeActCallbackNode$1) cancelCallback(pingedLanes);else return currentTime;
+        switch (lanesToEventPriority(suspendedLanes)) {
+          case DiscreteEventPriority:
+          case ContinuousEventPriority:
+            suspendedLanes = UserBlockingPriority;
+            break;
+          case DefaultEventPriority:
+            suspendedLanes = NormalPriority$1;
+            break;
+          case IdleEventPriority:
+            suspendedLanes = IdlePriority;
+            break;
+          default:
+            suspendedLanes = NormalPriority$1;
+        }
+        pingedLanes = performWorkOnRootViaSchedulerTask.bind(null, root);
+        null !== ReactSharedInternals.actQueue ? (ReactSharedInternals.actQueue.push(pingedLanes), suspendedLanes = fakeActCallbackNode$1) : suspendedLanes = scheduleCallback$3(suspendedLanes, pingedLanes);
+        root.callbackPriority = currentTime;
+        root.callbackNode = suspendedLanes;
+        return currentTime;
+      }
+      null !== pingedLanes && cancelCallback(pingedLanes);
+      root.callbackPriority = 2;
+      root.callbackNode = null;
+      return 2;
+    }
+    function performWorkOnRootViaSchedulerTask(root, didTimeout) {
+      nestedUpdateScheduled = currentUpdateIsNested = !1;
+      if (pendingEffectsStatus !== NO_PENDING_EFFECTS && pendingEffectsStatus !== PENDING_PASSIVE_PHASE) return root.callbackNode = null, root.callbackPriority = 0, null;
+      var originalCallbackNode = root.callbackNode;
+      if (flushPendingEffects(!0) && root.callbackNode !== originalCallbackNode) return null;
+      var workInProgressRootRenderLanes$jscomp$0 = workInProgressRootRenderLanes;
+      workInProgressRootRenderLanes$jscomp$0 = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes$jscomp$0 : 0, null !== root.cancelPendingCommit || root.timeoutHandle !== noTimeout);
+      if (0 === workInProgressRootRenderLanes$jscomp$0) return null;
+      performWorkOnRoot(root, workInProgressRootRenderLanes$jscomp$0, didTimeout);
+      scheduleTaskForRootDuringMicrotask(root, now$1());
+      return null != root.callbackNode && root.callbackNode === originalCallbackNode ? performWorkOnRootViaSchedulerTask.bind(null, root) : null;
+    }
+    function performSyncWorkOnRoot(root, lanes) {
+      if (flushPendingEffects()) return null;
+      currentUpdateIsNested = nestedUpdateScheduled;
+      nestedUpdateScheduled = !1;
+      performWorkOnRoot(root, lanes, !0);
+    }
+    function cancelCallback(callbackNode) {
+      callbackNode !== fakeActCallbackNode$1 && null !== callbackNode && cancelCallback$1(callbackNode);
+    }
+    function scheduleImmediateRootScheduleTask() {
+      null !== ReactSharedInternals.actQueue && ReactSharedInternals.actQueue.push(function () {
+        processRootScheduleInMicrotask();
+        return null;
+      });
+      supportsMicrotasks ? scheduleMicrotask(function () {
+        (executionContext & (RenderContext | CommitContext)) !== NoContext ? scheduleCallback$3(ImmediatePriority, processRootScheduleInImmediateTask) : processRootScheduleInMicrotask();
+      }) : scheduleCallback$3(ImmediatePriority, processRootScheduleInImmediateTask);
+    }
+    function requestTransitionLane() {
+      0 === currentEventTransitionLane && (currentEventTransitionLane = claimNextTransitionLane());
+      return currentEventTransitionLane;
+    }
+    function entangleAsyncAction(transition, thenable) {
+      if (null === currentEntangledListeners) {
+        var entangledListeners = currentEntangledListeners = [];
+        currentEntangledPendingCount = 0;
+        currentEntangledLane = requestTransitionLane();
+        currentEntangledActionThenable = {
+          status: "pending",
+          value: void 0,
+          then: function then(resolve) {
+            entangledListeners.push(resolve);
+          }
+        };
+      }
+      currentEntangledPendingCount++;
+      thenable.then(pingEngtangledActionScope, pingEngtangledActionScope);
+      return thenable;
+    }
+    function pingEngtangledActionScope() {
+      if (0 === --currentEntangledPendingCount && null !== currentEntangledListeners) {
+        null !== currentEntangledActionThenable && (currentEntangledActionThenable.status = "fulfilled");
+        var listeners = currentEntangledListeners;
+        currentEntangledListeners = null;
+        currentEntangledLane = 0;
+        currentEntangledActionThenable = null;
+        for (var i = 0; i < listeners.length; i++) (0, listeners[i])();
+      }
+    }
+    function chainThenableValue(thenable, result) {
+      var listeners = [],
+        thenableWithOverride = {
+          status: "pending",
+          value: null,
+          reason: null,
+          then: function then(resolve) {
+            listeners.push(resolve);
+          }
+        };
+      thenable.then(function () {
+        thenableWithOverride.status = "fulfilled";
+        thenableWithOverride.value = result;
+        for (var i = 0; i < listeners.length; i++) (0, listeners[i])(result);
+      }, function (error) {
+        thenableWithOverride.status = "rejected";
+        thenableWithOverride.reason = error;
+        for (error = 0; error < listeners.length; error++) (0, listeners[error])(void 0);
+      });
+      return thenableWithOverride;
+    }
+    function peekCacheFromPool() {
+      var cacheResumedFromPreviousRender = resumedCache.current;
+      return null !== cacheResumedFromPreviousRender ? cacheResumedFromPreviousRender : workInProgressRoot.pooledCache;
+    }
+    function pushTransition(offscreenWorkInProgress, prevCachePool) {
+      null === prevCachePool ? push(resumedCache, resumedCache.current, offscreenWorkInProgress) : push(resumedCache, prevCachePool.pool, offscreenWorkInProgress);
+    }
+    function getSuspendedCache() {
+      var cacheFromPool = peekCacheFromPool();
+      return null === cacheFromPool ? null : {
+        parent: CacheContext._currentValue2,
+        pool: cacheFromPool
+      };
+    }
+    function shallowEqual(objA, objB) {
+      if (objectIs(objA, objB)) return !0;
+      if ("object" !== typeof objA || null === objA || "object" !== typeof objB || null === objB) return !1;
+      var keysA = Object.keys(objA),
+        keysB = Object.keys(objB);
+      if (keysA.length !== keysB.length) return !1;
+      for (keysB = 0; keysB < keysA.length; keysB++) {
+        var currentKey = keysA[keysB];
+        if (!hasOwnProperty.call(objB, currentKey) || !objectIs(objA[currentKey], objB[currentKey])) return !1;
+      }
+      return !0;
+    }
+    function createThenableState() {
+      return {
+        didWarnAboutUncachedPromise: !1,
+        thenables: []
+      };
+    }
+    function isThenableResolved(thenable) {
+      thenable = thenable.status;
+      return "fulfilled" === thenable || "rejected" === thenable;
+    }
+    function noop() {}
+    function trackUsedThenable(thenableState, thenable, index) {
+      null !== ReactSharedInternals.actQueue && (ReactSharedInternals.didUsePromise = !0);
+      var trackedThenables = thenableState.thenables;
+      index = trackedThenables[index];
+      void 0 === index ? trackedThenables.push(thenable) : index !== thenable && (thenableState.didWarnAboutUncachedPromise || (thenableState.didWarnAboutUncachedPromise = !0, console.error("A component was suspended by an uncached promise. Creating promises inside a Client Component or hook is not yet supported, except via a Suspense-compatible library or framework.")), thenable.then(noop, noop), thenable = index);
+      switch (thenable.status) {
+        case "fulfilled":
+          return thenable.value;
+        case "rejected":
+          throw thenableState = thenable.reason, checkIfUseWrappedInAsyncCatch(thenableState), thenableState;
+        default:
+          if ("string" === typeof thenable.status) thenable.then(noop, noop);else {
+            thenableState = workInProgressRoot;
+            if (null !== thenableState && 100 < thenableState.shellSuspendCounter) throw Error("An unknown Component is an async Client Component. Only Server Components can be async at the moment. This error is often caused by accidentally adding `'use client'` to a module that was originally written for the server.");
+            thenableState = thenable;
+            thenableState.status = "pending";
+            thenableState.then(function (fulfilledValue) {
+              if ("pending" === thenable.status) {
+                var fulfilledThenable = thenable;
+                fulfilledThenable.status = "fulfilled";
+                fulfilledThenable.value = fulfilledValue;
+              }
+            }, function (error) {
+              if ("pending" === thenable.status) {
+                var rejectedThenable = thenable;
+                rejectedThenable.status = "rejected";
+                rejectedThenable.reason = error;
+              }
+            });
+          }
+          switch (thenable.status) {
+            case "fulfilled":
+              return thenable.value;
+            case "rejected":
+              throw thenableState = thenable.reason, checkIfUseWrappedInAsyncCatch(thenableState), thenableState;
+          }
+          suspendedThenable = thenable;
+          needsToResetSuspendedThenableDEV = !0;
+          throw SuspenseException;
+      }
+    }
+    function getSuspendedThenable() {
+      if (null === suspendedThenable) throw Error("Expected a suspended thenable. This is a bug in React. Please file an issue.");
+      var thenable = suspendedThenable;
+      suspendedThenable = null;
+      needsToResetSuspendedThenableDEV = !1;
+      return thenable;
+    }
+    function checkIfUseWrappedInAsyncCatch(rejectedReason) {
+      if (rejectedReason === SuspenseException || rejectedReason === SuspenseActionException) throw Error("Hooks are not supported inside an async component. This error is often caused by accidentally adding `'use client'` to a module that was originally written for the server.");
+    }
+    function finishQueueingConcurrentUpdates() {
+      for (var endIndex = concurrentQueuesIndex, i = concurrentlyUpdatedLanes = concurrentQueuesIndex = 0; i < endIndex;) {
+        var fiber = concurrentQueues[i];
+        concurrentQueues[i++] = null;
+        var queue = concurrentQueues[i];
+        concurrentQueues[i++] = null;
+        var update = concurrentQueues[i];
+        concurrentQueues[i++] = null;
+        var lane = concurrentQueues[i];
+        concurrentQueues[i++] = null;
+        if (null !== queue && null !== update) {
+          var pending = queue.pending;
+          null === pending ? update.next = update : (update.next = pending.next, pending.next = update);
+          queue.pending = update;
+        }
+        0 !== lane && markUpdateLaneFromFiberToRoot(fiber, update, lane);
+      }
+    }
+    function enqueueUpdate$1(fiber, queue, update, lane) {
+      concurrentQueues[concurrentQueuesIndex++] = fiber;
+      concurrentQueues[concurrentQueuesIndex++] = queue;
+      concurrentQueues[concurrentQueuesIndex++] = update;
+      concurrentQueues[concurrentQueuesIndex++] = lane;
+      concurrentlyUpdatedLanes |= lane;
+      fiber.lanes |= lane;
+      fiber = fiber.alternate;
+      null !== fiber && (fiber.lanes |= lane);
+    }
+    function enqueueConcurrentHookUpdate(fiber, queue, update, lane) {
+      enqueueUpdate$1(fiber, queue, update, lane);
+      return getRootForUpdatedFiber(fiber);
+    }
+    function enqueueConcurrentRenderForLane(fiber, lane) {
+      enqueueUpdate$1(fiber, null, null, lane);
+      return getRootForUpdatedFiber(fiber);
+    }
+    function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
+      sourceFiber.lanes |= lane;
+      var alternate = sourceFiber.alternate;
+      null !== alternate && (alternate.lanes |= lane);
+      for (var isHidden = !1, parent = sourceFiber.return; null !== parent;) parent.childLanes |= lane, alternate = parent.alternate, null !== alternate && (alternate.childLanes |= lane), 22 === parent.tag && (sourceFiber = parent.stateNode, null === sourceFiber || sourceFiber._visibility & 1 || (isHidden = !0)), sourceFiber = parent, parent = parent.return;
+      return 3 === sourceFiber.tag ? (parent = sourceFiber.stateNode, isHidden && null !== update && (isHidden = 31 - clz32(lane), sourceFiber = parent.hiddenUpdates, alternate = sourceFiber[isHidden], null === alternate ? sourceFiber[isHidden] = [update] : alternate.push(update), update.lane = lane | 536870912), parent) : null;
+    }
+    function getRootForUpdatedFiber(sourceFiber) {
+      if (nestedUpdateCount > NESTED_UPDATE_LIMIT) throw nestedPassiveUpdateCount = nestedUpdateCount = 0, rootWithPassiveNestedUpdates = rootWithNestedUpdates = null, Error("Maximum update depth exceeded. This can happen when a component repeatedly calls setState inside componentWillUpdate or componentDidUpdate. React limits the number of nested updates to prevent infinite loops.");
+      nestedPassiveUpdateCount > NESTED_PASSIVE_UPDATE_LIMIT && (nestedPassiveUpdateCount = 0, rootWithPassiveNestedUpdates = null, console.error("Maximum update depth exceeded. This can happen when a component calls setState inside useEffect, but useEffect either doesn't have a dependency array, or one of the dependencies changes on every render."));
+      null === sourceFiber.alternate && 0 !== (sourceFiber.flags & 4098) && warnAboutUpdateOnNotYetMountedFiberInDEV(sourceFiber);
+      for (var node = sourceFiber, parent = node.return; null !== parent;) null === node.alternate && 0 !== (node.flags & 4098) && warnAboutUpdateOnNotYetMountedFiberInDEV(sourceFiber), node = parent, parent = node.return;
+      return 3 === node.tag ? node.stateNode : null;
+    }
+    function initializeUpdateQueue(fiber) {
+      fiber.updateQueue = {
+        baseState: fiber.memoizedState,
+        firstBaseUpdate: null,
+        lastBaseUpdate: null,
+        shared: {
+          pending: null,
+          lanes: 0,
+          hiddenCallbacks: null
+        },
+        callbacks: null
+      };
+    }
+    function cloneUpdateQueue(current, workInProgress) {
+      current = current.updateQueue;
+      workInProgress.updateQueue === current && (workInProgress.updateQueue = {
+        baseState: current.baseState,
+        firstBaseUpdate: current.firstBaseUpdate,
+        lastBaseUpdate: current.lastBaseUpdate,
+        shared: current.shared,
+        callbacks: null
+      });
+    }
+    function createUpdate(lane) {
+      return {
+        lane: lane,
+        tag: UpdateState,
+        payload: null,
+        callback: null,
+        next: null
+      };
+    }
+    function enqueueUpdate(fiber, update, lane) {
+      var updateQueue = fiber.updateQueue;
+      if (null === updateQueue) return null;
+      updateQueue = updateQueue.shared;
+      if (currentlyProcessingQueue === updateQueue && !didWarnUpdateInsideUpdate) {
+        var componentName = getComponentNameFromFiber(fiber);
+        console.error("An update (setState, replaceState, or forceUpdate) was scheduled from inside an update function. Update functions should be pure, with zero side-effects. Consider using componentDidUpdate or a callback.\n\nPlease update the following component: %s", componentName);
+        didWarnUpdateInsideUpdate = !0;
+      }
+      if ((executionContext & RenderContext) !== NoContext) return componentName = updateQueue.pending, null === componentName ? update.next = update : (update.next = componentName.next, componentName.next = update), updateQueue.pending = update, update = getRootForUpdatedFiber(fiber), markUpdateLaneFromFiberToRoot(fiber, null, lane), update;
+      enqueueUpdate$1(fiber, updateQueue, update, lane);
+      return getRootForUpdatedFiber(fiber);
+    }
+    function entangleTransitions(root, fiber, lane) {
+      fiber = fiber.updateQueue;
+      if (null !== fiber && (fiber = fiber.shared, 0 !== (lane & 4194048))) {
+        var queueLanes = fiber.lanes;
+        queueLanes &= root.pendingLanes;
+        lane |= queueLanes;
+        fiber.lanes = lane;
+        markRootEntangled(root, lane);
+      }
+    }
+    function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
+      var queue = workInProgress.updateQueue,
+        current = workInProgress.alternate;
+      if (null !== current && (current = current.updateQueue, queue === current)) {
+        var newFirst = null,
+          newLast = null;
+        queue = queue.firstBaseUpdate;
+        if (null !== queue) {
+          do {
+            var clone = {
+              lane: queue.lane,
+              tag: queue.tag,
+              payload: queue.payload,
+              callback: null,
+              next: null
+            };
+            null === newLast ? newFirst = newLast = clone : newLast = newLast.next = clone;
+            queue = queue.next;
+          } while (null !== queue);
+          null === newLast ? newFirst = newLast = capturedUpdate : newLast = newLast.next = capturedUpdate;
+        } else newFirst = newLast = capturedUpdate;
+        queue = {
+          baseState: current.baseState,
+          firstBaseUpdate: newFirst,
+          lastBaseUpdate: newLast,
+          shared: current.shared,
+          callbacks: current.callbacks
+        };
+        workInProgress.updateQueue = queue;
+        return;
+      }
+      workInProgress = queue.lastBaseUpdate;
+      null === workInProgress ? queue.firstBaseUpdate = capturedUpdate : workInProgress.next = capturedUpdate;
+      queue.lastBaseUpdate = capturedUpdate;
+    }
+    function suspendIfUpdateReadFromEntangledAsyncAction() {
+      if (didReadFromEntangledAsyncAction) {
+        var entangledActionThenable = currentEntangledActionThenable;
+        if (null !== entangledActionThenable) throw entangledActionThenable;
+      }
+    }
+    function processUpdateQueue(workInProgress, props, instance$jscomp$0, renderLanes) {
+      didReadFromEntangledAsyncAction = !1;
+      var queue = workInProgress.updateQueue;
+      hasForceUpdate = !1;
+      currentlyProcessingQueue = queue.shared;
+      var firstBaseUpdate = queue.firstBaseUpdate,
+        lastBaseUpdate = queue.lastBaseUpdate,
+        pendingQueue = queue.shared.pending;
+      if (null !== pendingQueue) {
+        queue.shared.pending = null;
+        var lastPendingUpdate = pendingQueue,
+          firstPendingUpdate = lastPendingUpdate.next;
+        lastPendingUpdate.next = null;
+        null === lastBaseUpdate ? firstBaseUpdate = firstPendingUpdate : lastBaseUpdate.next = firstPendingUpdate;
+        lastBaseUpdate = lastPendingUpdate;
+        var current = workInProgress.alternate;
+        null !== current && (current = current.updateQueue, pendingQueue = current.lastBaseUpdate, pendingQueue !== lastBaseUpdate && (null === pendingQueue ? current.firstBaseUpdate = firstPendingUpdate : pendingQueue.next = firstPendingUpdate, current.lastBaseUpdate = lastPendingUpdate));
+      }
+      if (null !== firstBaseUpdate) {
+        var newState = queue.baseState;
+        lastBaseUpdate = 0;
+        current = firstPendingUpdate = lastPendingUpdate = null;
+        pendingQueue = firstBaseUpdate;
+        do {
+          var updateLane = pendingQueue.lane & -536870913,
+            isHiddenUpdate = updateLane !== pendingQueue.lane;
+          if (isHiddenUpdate ? (workInProgressRootRenderLanes & updateLane) === updateLane : (renderLanes & updateLane) === updateLane) {
+            0 !== updateLane && updateLane === currentEntangledLane && (didReadFromEntangledAsyncAction = !0);
+            null !== current && (current = current.next = {
+              lane: 0,
+              tag: pendingQueue.tag,
+              payload: pendingQueue.payload,
+              callback: null,
+              next: null
+            });
+            a: {
+              updateLane = workInProgress;
+              var partialState = pendingQueue;
+              var nextProps = props,
+                instance = instance$jscomp$0;
+              switch (partialState.tag) {
+                case ReplaceState:
+                  partialState = partialState.payload;
+                  if ("function" === typeof partialState) {
+                    isDisallowedContextReadInDEV = !0;
+                    var nextState = partialState.call(instance, newState, nextProps);
+                    if (updateLane.mode & 8) {
+                      setIsStrictModeForDevtools(!0);
+                      try {
+                        partialState.call(instance, newState, nextProps);
+                      } finally {
+                        setIsStrictModeForDevtools(!1);
+                      }
+                    }
+                    isDisallowedContextReadInDEV = !1;
+                    newState = nextState;
+                    break a;
+                  }
+                  newState = partialState;
+                  break a;
+                case CaptureUpdate:
+                  updateLane.flags = updateLane.flags & -65537 | 128;
+                case UpdateState:
+                  nextState = partialState.payload;
+                  if ("function" === typeof nextState) {
+                    isDisallowedContextReadInDEV = !0;
+                    partialState = nextState.call(instance, newState, nextProps);
+                    if (updateLane.mode & 8) {
+                      setIsStrictModeForDevtools(!0);
+                      try {
+                        nextState.call(instance, newState, nextProps);
+                      } finally {
+                        setIsStrictModeForDevtools(!1);
+                      }
+                    }
+                    isDisallowedContextReadInDEV = !1;
+                  } else partialState = nextState;
+                  if (null === partialState || void 0 === partialState) break a;
+                  newState = assign({}, newState, partialState);
+                  break a;
+                case ForceUpdate:
+                  hasForceUpdate = !0;
+              }
+            }
+            updateLane = pendingQueue.callback;
+            null !== updateLane && (workInProgress.flags |= 64, isHiddenUpdate && (workInProgress.flags |= 8192), isHiddenUpdate = queue.callbacks, null === isHiddenUpdate ? queue.callbacks = [updateLane] : isHiddenUpdate.push(updateLane));
+          } else isHiddenUpdate = {
+            lane: updateLane,
+            tag: pendingQueue.tag,
+            payload: pendingQueue.payload,
+            callback: pendingQueue.callback,
+            next: null
+          }, null === current ? (firstPendingUpdate = current = isHiddenUpdate, lastPendingUpdate = newState) : current = current.next = isHiddenUpdate, lastBaseUpdate |= updateLane;
+          pendingQueue = pendingQueue.next;
+          if (null === pendingQueue) if (pendingQueue = queue.shared.pending, null === pendingQueue) break;else isHiddenUpdate = pendingQueue, pendingQueue = isHiddenUpdate.next, isHiddenUpdate.next = null, queue.lastBaseUpdate = isHiddenUpdate, queue.shared.pending = null;
+        } while (1);
+        null === current && (lastPendingUpdate = newState);
+        queue.baseState = lastPendingUpdate;
+        queue.firstBaseUpdate = firstPendingUpdate;
+        queue.lastBaseUpdate = current;
+        null === firstBaseUpdate && (queue.shared.lanes = 0);
+        workInProgressRootSkippedLanes |= lastBaseUpdate;
+        workInProgress.lanes = lastBaseUpdate;
+        workInProgress.memoizedState = newState;
+      }
+      currentlyProcessingQueue = null;
+    }
+    function callCallback(callback, context) {
+      if ("function" !== typeof callback) throw Error("Invalid argument passed as callback. Expected a function. Instead received: " + callback);
+      callback.call(context);
+    }
+    function commitHiddenCallbacks(updateQueue, context) {
+      var hiddenCallbacks = updateQueue.shared.hiddenCallbacks;
+      if (null !== hiddenCallbacks) for (updateQueue.shared.hiddenCallbacks = null, updateQueue = 0; updateQueue < hiddenCallbacks.length; updateQueue++) callCallback(hiddenCallbacks[updateQueue], context);
+    }
+    function commitCallbacks(updateQueue, context) {
+      var callbacks = updateQueue.callbacks;
+      if (null !== callbacks) for (updateQueue.callbacks = null, updateQueue = 0; updateQueue < callbacks.length; updateQueue++) callCallback(callbacks[updateQueue], context);
+    }
+    function pushHiddenContext(fiber, context) {
+      var prevEntangledRenderLanes = entangledRenderLanes;
+      push(prevEntangledRenderLanesCursor, prevEntangledRenderLanes, fiber);
+      push(currentTreeHiddenStackCursor, context, fiber);
+      entangledRenderLanes = prevEntangledRenderLanes | context.baseLanes;
+    }
+    function reuseHiddenContextOnStack(fiber) {
+      push(prevEntangledRenderLanesCursor, entangledRenderLanes, fiber);
+      push(currentTreeHiddenStackCursor, currentTreeHiddenStackCursor.current, fiber);
+    }
+    function popHiddenContext(fiber) {
+      entangledRenderLanes = prevEntangledRenderLanesCursor.current;
+      pop(currentTreeHiddenStackCursor, fiber);
+      pop(prevEntangledRenderLanesCursor, fiber);
+    }
+    function mountHookTypesDev() {
+      var hookName = currentHookNameInDev;
+      null === hookTypesDev ? hookTypesDev = [hookName] : hookTypesDev.push(hookName);
+    }
+    function updateHookTypesDev() {
+      var hookName = currentHookNameInDev;
+      if (null !== hookTypesDev && (hookTypesUpdateIndexDev++, hookTypesDev[hookTypesUpdateIndexDev] !== hookName)) {
+        var componentName = getComponentNameFromFiber(currentlyRenderingFiber);
+        if (!didWarnAboutMismatchedHooksForComponent.has(componentName) && (didWarnAboutMismatchedHooksForComponent.add(componentName), null !== hookTypesDev)) {
+          for (var table = "", i = 0; i <= hookTypesUpdateIndexDev; i++) {
+            var oldHookName = hookTypesDev[i],
+              newHookName = i === hookTypesUpdateIndexDev ? hookName : oldHookName;
+            for (oldHookName = i + 1 + ". " + oldHookName; 30 > oldHookName.length;) oldHookName += " ";
+            oldHookName += newHookName + "\n";
+            table += oldHookName;
+          }
+          console.error("React has detected a change in the order of Hooks called by %s. This will lead to bugs and errors if not fixed. For more information, read the Rules of Hooks: https://react.dev/link/rules-of-hooks\n\n   Previous render            Next render\n   ------------------------------------------------------\n%s   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", componentName, table);
+        }
+      }
+    }
+    function checkDepsAreArrayDev(deps) {
+      void 0 === deps || null === deps || isArrayImpl(deps) || console.error("%s received a final argument that is not an array (instead, received `%s`). When specified, the final argument must be an array.", currentHookNameInDev, typeof deps);
+    }
+    function warnOnUseFormStateInDev() {
+      var componentName = getComponentNameFromFiber(currentlyRenderingFiber);
+      didWarnAboutUseFormState.has(componentName) || (didWarnAboutUseFormState.add(componentName), console.error("ReactDOM.useFormState has been renamed to React.useActionState. Please update %s to use React.useActionState.", componentName));
+    }
+    function throwInvalidHookError() {
+      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://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.");
+    }
+    function areHookInputsEqual(nextDeps, prevDeps) {
+      if (ignorePreviousDependencies) return !1;
+      if (null === prevDeps) return console.error("%s received a final argument during this render, but not during the previous render. Even though the final argument is optional, its type cannot change between renders.", currentHookNameInDev), !1;
+      nextDeps.length !== prevDeps.length && console.error("The final argument passed to %s changed size between renders. The order and size of this array must remain constant.\n\nPrevious: %s\nIncoming: %s", currentHookNameInDev, "[" + prevDeps.join(", ") + "]", "[" + nextDeps.join(", ") + "]");
+      for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) if (!objectIs(nextDeps[i], prevDeps[i])) return !1;
+      return !0;
+    }
+    function renderWithHooks(current, workInProgress, Component, props, secondArg, nextRenderLanes) {
+      renderLanes = nextRenderLanes;
+      currentlyRenderingFiber = workInProgress;
+      hookTypesDev = null !== current ? current._debugHookTypes : null;
+      hookTypesUpdateIndexDev = -1;
+      ignorePreviousDependencies = null !== current && current.type !== workInProgress.type;
+      if ("[object AsyncFunction]" === Object.prototype.toString.call(Component) || "[object AsyncGeneratorFunction]" === Object.prototype.toString.call(Component)) nextRenderLanes = getComponentNameFromFiber(currentlyRenderingFiber), didWarnAboutAsyncClientComponent.has(nextRenderLanes) || (didWarnAboutAsyncClientComponent.add(nextRenderLanes), console.error("%s is an async Client Component. Only Server Components can be async at the moment. This error is often caused by accidentally adding `'use client'` to a module that was originally written for the server.", null === nextRenderLanes ? "An unknown Component" : "<" + nextRenderLanes + ">"));
+      workInProgress.memoizedState = null;
+      workInProgress.updateQueue = null;
+      workInProgress.lanes = 0;
+      ReactSharedInternals.H = null !== current && null !== current.memoizedState ? HooksDispatcherOnUpdateInDEV : null !== hookTypesDev ? HooksDispatcherOnMountWithHookTypesInDEV : HooksDispatcherOnMountInDEV;
+      shouldDoubleInvokeUserFnsInHooksDEV = nextRenderLanes = 0 !== (workInProgress.mode & 8);
+      var children = callComponentInDEV(Component, props, secondArg);
+      shouldDoubleInvokeUserFnsInHooksDEV = !1;
+      didScheduleRenderPhaseUpdateDuringThisPass && (children = renderWithHooksAgain(workInProgress, Component, props, secondArg));
+      if (nextRenderLanes) {
+        setIsStrictModeForDevtools(!0);
+        try {
+          children = renderWithHooksAgain(workInProgress, Component, props, secondArg);
+        } finally {
+          setIsStrictModeForDevtools(!1);
+        }
+      }
+      finishRenderingHooks(current, workInProgress);
+      return children;
+    }
+    function finishRenderingHooks(current, workInProgress) {
+      workInProgress._debugHookTypes = hookTypesDev;
+      null === workInProgress.dependencies ? null !== thenableState$1 && (workInProgress.dependencies = {
+        lanes: 0,
+        firstContext: null,
+        _debugThenableState: thenableState$1
+      }) : workInProgress.dependencies._debugThenableState = thenableState$1;
+      ReactSharedInternals.H = ContextOnlyDispatcher;
+      var didRenderTooFewHooks = null !== currentHook && null !== currentHook.next;
+      renderLanes = 0;
+      hookTypesDev = currentHookNameInDev = workInProgressHook = currentHook = currentlyRenderingFiber = null;
+      hookTypesUpdateIndexDev = -1;
+      null !== current && (current.flags & 65011712) !== (workInProgress.flags & 65011712) && 0 !== (current.mode & 1) && console.error("Internal React error: Expected static flag was missing. Please notify the React team.");
+      didScheduleRenderPhaseUpdate = !1;
+      thenableIndexCounter$1 = 0;
+      thenableState$1 = null;
+      if (didRenderTooFewHooks) throw Error("Rendered fewer hooks than expected. This may be caused by an accidental early return statement.");
+      null === current || didReceiveUpdate || (current = current.dependencies, null !== current && checkIfContextChanged(current) && (didReceiveUpdate = !0));
+      needsToResetSuspendedThenableDEV ? (needsToResetSuspendedThenableDEV = !1, current = !0) : current = !1;
+      current && (workInProgress = getComponentNameFromFiber(workInProgress) || "Unknown", didWarnAboutUseWrappedInTryCatch.has(workInProgress) || didWarnAboutAsyncClientComponent.has(workInProgress) || (didWarnAboutUseWrappedInTryCatch.add(workInProgress), console.error("`use` was called from inside a try/catch block. This is not allowed and can lead to unexpected behavior. To handle errors triggered by `use`, wrap your component in a error boundary.")));
+    }
+    function renderWithHooksAgain(workInProgress, Component, props, secondArg) {
+      currentlyRenderingFiber = workInProgress;
+      var numberOfReRenders = 0;
+      do {
+        didScheduleRenderPhaseUpdateDuringThisPass && (thenableState$1 = null);
+        thenableIndexCounter$1 = 0;
+        didScheduleRenderPhaseUpdateDuringThisPass = !1;
+        if (numberOfReRenders >= RE_RENDER_LIMIT) throw Error("Too many re-renders. React limits the number of renders to prevent an infinite loop.");
+        numberOfReRenders += 1;
+        ignorePreviousDependencies = !1;
+        workInProgressHook = currentHook = null;
+        if (null != workInProgress.updateQueue) {
+          var children = workInProgress.updateQueue;
+          children.lastEffect = null;
+          children.events = null;
+          children.stores = null;
+          null != children.memoCache && (children.memoCache.index = 0);
+        }
+        hookTypesUpdateIndexDev = -1;
+        ReactSharedInternals.H = HooksDispatcherOnRerenderInDEV;
+        children = callComponentInDEV(Component, props, secondArg);
+      } while (didScheduleRenderPhaseUpdateDuringThisPass);
+      return children;
+    }
+    function TransitionAwareHostComponent() {
+      var dispatcher = ReactSharedInternals.H,
+        maybeThenable = dispatcher.useState()[0];
+      maybeThenable = "function" === typeof maybeThenable.then ? useThenable(maybeThenable) : maybeThenable;
+      dispatcher = dispatcher.useState()[0];
+      (null !== currentHook ? currentHook.memoizedState : null) !== dispatcher && (currentlyRenderingFiber.flags |= 1024);
+      return maybeThenable;
+    }
+    function bailoutHooks(current, workInProgress, lanes) {
+      workInProgress.updateQueue = current.updateQueue;
+      workInProgress.flags = 0 !== (workInProgress.mode & 16) ? workInProgress.flags & -402655237 : workInProgress.flags & -2053;
+      current.lanes &= ~lanes;
+    }
+    function resetHooksOnUnwind(workInProgress) {
+      if (didScheduleRenderPhaseUpdate) {
+        for (workInProgress = workInProgress.memoizedState; null !== workInProgress;) {
+          var queue = workInProgress.queue;
+          null !== queue && (queue.pending = null);
+          workInProgress = workInProgress.next;
+        }
+        didScheduleRenderPhaseUpdate = !1;
+      }
+      renderLanes = 0;
+      hookTypesDev = workInProgressHook = currentHook = currentlyRenderingFiber = null;
+      hookTypesUpdateIndexDev = -1;
+      currentHookNameInDev = null;
+      didScheduleRenderPhaseUpdateDuringThisPass = !1;
+      thenableIndexCounter$1 = 0;
+      thenableState$1 = null;
+    }
+    function mountWorkInProgressHook() {
+      var hook = {
+        memoizedState: null,
+        baseState: null,
+        baseQueue: null,
+        queue: null,
+        next: null
+      };
+      null === workInProgressHook ? currentlyRenderingFiber.memoizedState = workInProgressHook = hook : workInProgressHook = workInProgressHook.next = hook;
+      return workInProgressHook;
+    }
+    function updateWorkInProgressHook() {
+      if (null === currentHook) {
+        var nextCurrentHook = currentlyRenderingFiber.alternate;
+        nextCurrentHook = null !== nextCurrentHook ? nextCurrentHook.memoizedState : null;
+      } else nextCurrentHook = currentHook.next;
+      var nextWorkInProgressHook = null === workInProgressHook ? currentlyRenderingFiber.memoizedState : workInProgressHook.next;
+      if (null !== nextWorkInProgressHook) workInProgressHook = nextWorkInProgressHook, currentHook = nextCurrentHook;else {
+        if (null === nextCurrentHook) {
+          if (null === currentlyRenderingFiber.alternate) throw Error("Update hook called on initial render. This is likely a bug in React. Please file an issue.");
+          throw Error("Rendered more hooks than during the previous render.");
+        }
+        currentHook = nextCurrentHook;
+        nextCurrentHook = {
+          memoizedState: currentHook.memoizedState,
+          baseState: currentHook.baseState,
+          baseQueue: currentHook.baseQueue,
+          queue: currentHook.queue,
+          next: null
+        };
+        null === workInProgressHook ? currentlyRenderingFiber.memoizedState = workInProgressHook = nextCurrentHook : workInProgressHook = workInProgressHook.next = nextCurrentHook;
+      }
+      return workInProgressHook;
+    }
+    function createFunctionComponentUpdateQueue() {
+      return {
+        lastEffect: null,
+        events: null,
+        stores: null,
+        memoCache: null
+      };
+    }
+    function useThenable(thenable) {
+      var index = thenableIndexCounter$1;
+      thenableIndexCounter$1 += 1;
+      null === thenableState$1 && (thenableState$1 = createThenableState());
+      thenable = trackUsedThenable(thenableState$1, thenable, index);
+      index = currentlyRenderingFiber;
+      null === (null === workInProgressHook ? index.memoizedState : workInProgressHook.next) && (index = index.alternate, ReactSharedInternals.H = null !== index && null !== index.memoizedState ? HooksDispatcherOnUpdateInDEV : HooksDispatcherOnMountInDEV);
+      return thenable;
+    }
+    function _use(usable) {
+      if (null !== usable && "object" === typeof usable) {
+        if ("function" === typeof usable.then) return useThenable(usable);
+        if (usable.$$typeof === REACT_CONTEXT_TYPE) return _readContext(usable);
+      }
+      throw Error("An unsupported type was passed to use(): " + String(usable));
+    }
+    function _useMemoCache(size) {
+      var memoCache = null,
+        updateQueue = currentlyRenderingFiber.updateQueue;
+      null !== updateQueue && (memoCache = updateQueue.memoCache);
+      if (null == memoCache) {
+        var current = currentlyRenderingFiber.alternate;
+        null !== current && (current = current.updateQueue, null !== current && (current = current.memoCache, null != current && (memoCache = {
+          data: current.data.map(function (array) {
+            return array.slice();
+          }),
+          index: 0
+        })));
+      }
+      null == memoCache && (memoCache = {
+        data: [],
+        index: 0
+      });
+      null === updateQueue && (updateQueue = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = updateQueue);
+      updateQueue.memoCache = memoCache;
+      updateQueue = memoCache.data[memoCache.index];
+      if (void 0 === updateQueue || ignorePreviousDependencies) for (updateQueue = memoCache.data[memoCache.index] = Array(size), current = 0; current < size; current++) updateQueue[current] = REACT_MEMO_CACHE_SENTINEL;else updateQueue.length !== size && console.error("Expected a constant size argument for each invocation of useMemoCache. The previous cache was allocated with size %s but size %s was requested.", updateQueue.length, size);
+      memoCache.index++;
+      return updateQueue;
+    }
+    function basicStateReducer(state, action) {
+      return "function" === typeof action ? action(state) : action;
+    }
+    function mountReducer(reducer, initialArg, init) {
+      var hook = mountWorkInProgressHook();
+      if (void 0 !== init) {
+        var initialState = init(initialArg);
+        if (shouldDoubleInvokeUserFnsInHooksDEV) {
+          setIsStrictModeForDevtools(!0);
+          try {
+            init(initialArg);
+          } finally {
+            setIsStrictModeForDevtools(!1);
+          }
+        }
+      } else initialState = initialArg;
+      hook.memoizedState = hook.baseState = initialState;
+      reducer = {
+        pending: null,
+        lanes: 0,
+        dispatch: null,
+        lastRenderedReducer: reducer,
+        lastRenderedState: initialState
+      };
+      hook.queue = reducer;
+      reducer = reducer.dispatch = dispatchReducerAction.bind(null, currentlyRenderingFiber, reducer);
+      return [hook.memoizedState, reducer];
+    }
+    function updateReducer(reducer) {
+      var hook = updateWorkInProgressHook();
+      return updateReducerImpl(hook, currentHook, reducer);
+    }
+    function updateReducerImpl(hook, current, reducer) {
+      var queue = hook.queue;
+      if (null === queue) throw Error("Should have a queue. You are likely calling Hooks conditionally, which is not allowed. (https://react.dev/link/invalid-hook-call)");
+      queue.lastRenderedReducer = reducer;
+      var baseQueue = hook.baseQueue,
+        pendingQueue = queue.pending;
+      if (null !== pendingQueue) {
+        if (null !== baseQueue) {
+          var baseFirst = baseQueue.next;
+          baseQueue.next = pendingQueue.next;
+          pendingQueue.next = baseFirst;
+        }
+        current.baseQueue !== baseQueue && console.error("Internal error: Expected work-in-progress queue to be a clone. This is a bug in React.");
+        current.baseQueue = baseQueue = pendingQueue;
+        queue.pending = null;
+      }
+      pendingQueue = hook.baseState;
+      if (null === baseQueue) hook.memoizedState = pendingQueue;else {
+        current = baseQueue.next;
+        var newBaseQueueFirst = baseFirst = null,
+          newBaseQueueLast = null,
+          update = current,
+          didReadFromEntangledAsyncAction = !1;
+        do {
+          var updateLane = update.lane & -536870913;
+          if (updateLane !== update.lane ? (workInProgressRootRenderLanes & updateLane) === updateLane : (renderLanes & updateLane) === updateLane) {
+            var revertLane = update.revertLane;
+            if (0 === revertLane) null !== newBaseQueueLast && (newBaseQueueLast = newBaseQueueLast.next = {
+              lane: 0,
+              revertLane: 0,
+              action: update.action,
+              hasEagerState: update.hasEagerState,
+              eagerState: update.eagerState,
+              next: null
+            }), updateLane === currentEntangledLane && (didReadFromEntangledAsyncAction = !0);else if ((renderLanes & revertLane) === revertLane) {
+              update = update.next;
+              revertLane === currentEntangledLane && (didReadFromEntangledAsyncAction = !0);
+              continue;
+            } else updateLane = {
+              lane: 0,
+              revertLane: update.revertLane,
+              action: update.action,
+              hasEagerState: update.hasEagerState,
+              eagerState: update.eagerState,
+              next: null
+            }, null === newBaseQueueLast ? (newBaseQueueFirst = newBaseQueueLast = updateLane, baseFirst = pendingQueue) : newBaseQueueLast = newBaseQueueLast.next = updateLane, currentlyRenderingFiber.lanes |= revertLane, workInProgressRootSkippedLanes |= revertLane;
+            updateLane = update.action;
+            shouldDoubleInvokeUserFnsInHooksDEV && reducer(pendingQueue, updateLane);
+            pendingQueue = update.hasEagerState ? update.eagerState : reducer(pendingQueue, updateLane);
+          } else revertLane = {
+            lane: updateLane,
+            revertLane: update.revertLane,
+            action: update.action,
+            hasEagerState: update.hasEagerState,
+            eagerState: update.eagerState,
+            next: null
+          }, null === newBaseQueueLast ? (newBaseQueueFirst = newBaseQueueLast = revertLane, baseFirst = pendingQueue) : newBaseQueueLast = newBaseQueueLast.next = revertLane, currentlyRenderingFiber.lanes |= updateLane, workInProgressRootSkippedLanes |= updateLane;
+          update = update.next;
+        } while (null !== update && update !== current);
+        null === newBaseQueueLast ? baseFirst = pendingQueue : newBaseQueueLast.next = newBaseQueueFirst;
+        if (!objectIs(pendingQueue, hook.memoizedState) && (didReceiveUpdate = !0, didReadFromEntangledAsyncAction && (reducer = currentEntangledActionThenable, null !== reducer))) throw reducer;
+        hook.memoizedState = pendingQueue;
+        hook.baseState = baseFirst;
+        hook.baseQueue = newBaseQueueLast;
+        queue.lastRenderedState = pendingQueue;
+      }
+      null === baseQueue && (queue.lanes = 0);
+      return [hook.memoizedState, queue.dispatch];
+    }
+    function rerenderReducer(reducer) {
+      var hook = updateWorkInProgressHook(),
+        queue = hook.queue;
+      if (null === queue) throw Error("Should have a queue. You are likely calling Hooks conditionally, which is not allowed. (https://react.dev/link/invalid-hook-call)");
+      queue.lastRenderedReducer = reducer;
+      var dispatch = queue.dispatch,
+        lastRenderPhaseUpdate = queue.pending,
+        newState = hook.memoizedState;
+      if (null !== lastRenderPhaseUpdate) {
+        queue.pending = null;
+        var update = lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+        do newState = reducer(newState, update.action), update = update.next; while (update !== lastRenderPhaseUpdate);
+        objectIs(newState, hook.memoizedState) || (didReceiveUpdate = !0);
+        hook.memoizedState = newState;
+        null === hook.baseQueue && (hook.baseState = newState);
+        queue.lastRenderedState = newState;
+      }
+      return [newState, dispatch];
+    }
+    function mountSyncExternalStore(subscribe, getSnapshot) {
+      var fiber = currentlyRenderingFiber,
+        hook = mountWorkInProgressHook();
+      var nextSnapshot = getSnapshot();
+      if (!didWarnUncachedGetSnapshot) {
+        var cachedSnapshot = getSnapshot();
+        objectIs(nextSnapshot, cachedSnapshot) || (console.error("The result of getSnapshot should be cached to avoid an infinite loop"), didWarnUncachedGetSnapshot = !0);
+      }
+      if (null === workInProgressRoot) throw Error("Expected a work-in-progress root. This is a bug in React. Please file an issue.");
+      0 !== (workInProgressRootRenderLanes & 124) || pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+      hook.memoizedState = nextSnapshot;
+      cachedSnapshot = {
+        value: nextSnapshot,
+        getSnapshot: getSnapshot
+      };
+      hook.queue = cachedSnapshot;
+      mountEffect(subscribeToStore.bind(null, fiber, cachedSnapshot, subscribe), [subscribe]);
+      fiber.flags |= 2048;
+      pushSimpleEffect(HasEffect | Passive, createEffectInstance(), updateStoreInstance.bind(null, fiber, cachedSnapshot, nextSnapshot, getSnapshot), null);
+      return nextSnapshot;
+    }
+    function updateSyncExternalStore(subscribe, getSnapshot) {
+      var fiber = currentlyRenderingFiber,
+        hook = updateWorkInProgressHook();
+      var nextSnapshot = getSnapshot();
+      if (!didWarnUncachedGetSnapshot) {
+        var cachedSnapshot = getSnapshot();
+        objectIs(nextSnapshot, cachedSnapshot) || (console.error("The result of getSnapshot should be cached to avoid an infinite loop"), didWarnUncachedGetSnapshot = !0);
+      }
+      if (cachedSnapshot = !objectIs((currentHook || hook).memoizedState, nextSnapshot)) hook.memoizedState = nextSnapshot, didReceiveUpdate = !0;
+      hook = hook.queue;
+      var create = subscribeToStore.bind(null, fiber, hook, subscribe);
+      updateEffectImpl(2048, Passive, create, [subscribe]);
+      if (hook.getSnapshot !== getSnapshot || cachedSnapshot || null !== workInProgressHook && workInProgressHook.memoizedState.tag & HasEffect) {
+        fiber.flags |= 2048;
+        pushSimpleEffect(HasEffect | Passive, createEffectInstance(), updateStoreInstance.bind(null, fiber, hook, nextSnapshot, getSnapshot), null);
+        if (null === workInProgressRoot) throw Error("Expected a work-in-progress root. This is a bug in React. Please file an issue.");
+        0 !== (renderLanes & 124) || pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+      }
+      return nextSnapshot;
+    }
+    function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
+      fiber.flags |= 16384;
+      fiber = {
+        getSnapshot: getSnapshot,
+        value: renderedSnapshot
+      };
+      getSnapshot = currentlyRenderingFiber.updateQueue;
+      null === getSnapshot ? (getSnapshot = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = getSnapshot, getSnapshot.stores = [fiber]) : (renderedSnapshot = getSnapshot.stores, null === renderedSnapshot ? getSnapshot.stores = [fiber] : renderedSnapshot.push(fiber));
+    }
+    function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
+      inst.value = nextSnapshot;
+      inst.getSnapshot = getSnapshot;
+      checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
+    }
+    function subscribeToStore(fiber, inst, subscribe) {
+      return subscribe(function () {
+        checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
+      });
+    }
+    function checkIfSnapshotChanged(inst) {
+      var latestGetSnapshot = inst.getSnapshot;
+      inst = inst.value;
+      try {
+        var nextValue = latestGetSnapshot();
+        return !objectIs(inst, nextValue);
+      } catch (error) {
+        return !0;
+      }
+    }
+    function forceStoreRerender(fiber) {
+      var root = enqueueConcurrentRenderForLane(fiber, 2);
+      null !== root && scheduleUpdateOnFiber(root, fiber, 2);
+    }
+    function mountStateImpl(initialState) {
+      var hook = mountWorkInProgressHook();
+      if ("function" === typeof initialState) {
+        var initialStateInitializer = initialState;
+        initialState = initialStateInitializer();
+        if (shouldDoubleInvokeUserFnsInHooksDEV) {
+          setIsStrictModeForDevtools(!0);
+          try {
+            initialStateInitializer();
+          } finally {
+            setIsStrictModeForDevtools(!1);
+          }
+        }
+      }
+      hook.memoizedState = hook.baseState = initialState;
+      hook.queue = {
+        pending: null,
+        lanes: 0,
+        dispatch: null,
+        lastRenderedReducer: basicStateReducer,
+        lastRenderedState: initialState
+      };
+      return hook;
+    }
+    function mountState(initialState) {
+      initialState = mountStateImpl(initialState);
+      var queue = initialState.queue,
+        dispatch = dispatchSetState.bind(null, currentlyRenderingFiber, queue);
+      queue.dispatch = dispatch;
+      return [initialState.memoizedState, dispatch];
+    }
+    function mountOptimistic(passthrough) {
+      var hook = mountWorkInProgressHook();
+      hook.memoizedState = hook.baseState = passthrough;
+      var queue = {
+        pending: null,
+        lanes: 0,
+        dispatch: null,
+        lastRenderedReducer: null,
+        lastRenderedState: null
+      };
+      hook.queue = queue;
+      hook = dispatchOptimisticSetState.bind(null, currentlyRenderingFiber, !0, queue);
+      queue.dispatch = hook;
+      return [passthrough, hook];
+    }
+    function updateOptimistic(passthrough, reducer) {
+      var hook = updateWorkInProgressHook();
+      return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
+    }
+    function updateOptimisticImpl(hook, current, passthrough, reducer) {
+      hook.baseState = passthrough;
+      return updateReducerImpl(hook, currentHook, "function" === typeof reducer ? reducer : basicStateReducer);
+    }
+    function rerenderOptimistic(passthrough, reducer) {
+      var hook = updateWorkInProgressHook();
+      if (null !== currentHook) return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
+      hook.baseState = passthrough;
+      return [passthrough, hook.queue.dispatch];
+    }
+    function dispatchActionState(fiber, actionQueue, setPendingState, setState, payload) {
+      if (isRenderPhaseUpdate(fiber)) throw Error("Cannot update form state while rendering.");
+      fiber = actionQueue.action;
+      if (null !== fiber) {
+        var actionNode = {
+          payload: payload,
+          action: fiber,
+          next: null,
+          isTransition: !0,
+          status: "pending",
+          value: null,
+          reason: null,
+          listeners: [],
+          then: function then(listener) {
+            actionNode.listeners.push(listener);
+          }
+        };
+        null !== ReactSharedInternals.T ? setPendingState(!0) : actionNode.isTransition = !1;
+        setState(actionNode);
+        setPendingState = actionQueue.pending;
+        null === setPendingState ? (actionNode.next = actionQueue.pending = actionNode, runActionStateAction(actionQueue, actionNode)) : (actionNode.next = setPendingState.next, actionQueue.pending = setPendingState.next = actionNode);
+      }
+    }
+    function runActionStateAction(actionQueue, node) {
+      var action = node.action,
+        payload = node.payload,
+        prevState = actionQueue.state;
+      if (node.isTransition) {
+        var prevTransition = ReactSharedInternals.T,
+          currentTransition = {};
+        ReactSharedInternals.T = currentTransition;
+        ReactSharedInternals.T._updatedFibers = new Set();
+        try {
+          var returnValue = action(prevState, payload),
+            onStartTransitionFinish = ReactSharedInternals.S;
+          null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
+          handleActionReturnValue(actionQueue, node, returnValue);
+        } catch (error) {
+          onActionError(actionQueue, node, error);
+        } finally {
+          ReactSharedInternals.T = prevTransition, null === prevTransition && currentTransition._updatedFibers && (actionQueue = currentTransition._updatedFibers.size, currentTransition._updatedFibers.clear(), 10 < actionQueue && console.warn("Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table."));
+        }
+      } else try {
+        currentTransition = action(prevState, payload), handleActionReturnValue(actionQueue, node, currentTransition);
+      } catch (error$3) {
+        onActionError(actionQueue, node, error$3);
+      }
+    }
+    function handleActionReturnValue(actionQueue, node, returnValue) {
+      null !== returnValue && "object" === typeof returnValue && "function" === typeof returnValue.then ? (returnValue.then(function (nextState) {
+        onActionSuccess(actionQueue, node, nextState);
+      }, function (error) {
+        return onActionError(actionQueue, node, error);
+      }), node.isTransition || console.error("An async function with useActionState was called outside of a transition. This is likely not what you intended (for example, isPending will not update correctly). Either call the returned function inside startTransition, or pass it to an `action` or `formAction` prop.")) : onActionSuccess(actionQueue, node, returnValue);
+    }
+    function onActionSuccess(actionQueue, actionNode, nextState) {
+      actionNode.status = "fulfilled";
+      actionNode.value = nextState;
+      notifyActionListeners(actionNode);
+      actionQueue.state = nextState;
+      actionNode = actionQueue.pending;
+      null !== actionNode && (nextState = actionNode.next, nextState === actionNode ? actionQueue.pending = null : (nextState = nextState.next, actionNode.next = nextState, runActionStateAction(actionQueue, nextState)));
+    }
+    function onActionError(actionQueue, actionNode, error) {
+      var last = actionQueue.pending;
+      actionQueue.pending = null;
+      if (null !== last) {
+        last = last.next;
+        do actionNode.status = "rejected", actionNode.reason = error, notifyActionListeners(actionNode), actionNode = actionNode.next; while (actionNode !== last);
+      }
+      actionQueue.action = null;
+    }
+    function notifyActionListeners(actionNode) {
+      actionNode = actionNode.listeners;
+      for (var i = 0; i < actionNode.length; i++) (0, actionNode[i])();
+    }
+    function actionStateReducer(oldState, newState) {
+      return newState;
+    }
+    function mountActionState(action, initialStateProp) {
+      var stateHook = mountWorkInProgressHook();
+      stateHook.memoizedState = stateHook.baseState = initialStateProp;
+      var stateQueue = {
+        pending: null,
+        lanes: 0,
+        dispatch: null,
+        lastRenderedReducer: actionStateReducer,
+        lastRenderedState: initialStateProp
+      };
+      stateHook.queue = stateQueue;
+      stateHook = dispatchSetState.bind(null, currentlyRenderingFiber, stateQueue);
+      stateQueue.dispatch = stateHook;
+      stateQueue = mountStateImpl(!1);
+      var setPendingState = dispatchOptimisticSetState.bind(null, currentlyRenderingFiber, !1, stateQueue.queue);
+      stateQueue = mountWorkInProgressHook();
+      var actionQueue = {
+        state: initialStateProp,
+        dispatch: null,
+        action: action,
+        pending: null
+      };
+      stateQueue.queue = actionQueue;
+      stateHook = dispatchActionState.bind(null, currentlyRenderingFiber, actionQueue, setPendingState, stateHook);
+      actionQueue.dispatch = stateHook;
+      stateQueue.memoizedState = action;
+      return [initialStateProp, stateHook, !1];
+    }
+    function updateActionState(action) {
+      var stateHook = updateWorkInProgressHook();
+      return updateActionStateImpl(stateHook, currentHook, action);
+    }
+    function updateActionStateImpl(stateHook, currentStateHook, action) {
+      currentStateHook = updateReducerImpl(stateHook, currentStateHook, actionStateReducer)[0];
+      stateHook = updateReducer(basicStateReducer)[0];
+      if ("object" === typeof currentStateHook && null !== currentStateHook && "function" === typeof currentStateHook.then) try {
+        var state = useThenable(currentStateHook);
+      } catch (x) {
+        if (x === SuspenseException) throw SuspenseActionException;
+        throw x;
+      } else state = currentStateHook;
+      currentStateHook = updateWorkInProgressHook();
+      var actionQueue = currentStateHook.queue,
+        dispatch = actionQueue.dispatch;
+      action !== currentStateHook.memoizedState && (currentlyRenderingFiber.flags |= 2048, pushSimpleEffect(HasEffect | Passive, createEffectInstance(), actionStateActionEffect.bind(null, actionQueue, action), null));
+      return [state, dispatch, stateHook];
+    }
+    function actionStateActionEffect(actionQueue, action) {
+      actionQueue.action = action;
+    }
+    function rerenderActionState(action) {
+      var stateHook = updateWorkInProgressHook(),
+        currentStateHook = currentHook;
+      if (null !== currentStateHook) return updateActionStateImpl(stateHook, currentStateHook, action);
+      updateWorkInProgressHook();
+      stateHook = stateHook.memoizedState;
+      currentStateHook = updateWorkInProgressHook();
+      var dispatch = currentStateHook.queue.dispatch;
+      currentStateHook.memoizedState = action;
+      return [stateHook, dispatch, !1];
+    }
+    function pushSimpleEffect(tag, inst, create, createDeps) {
+      tag = {
+        tag: tag,
+        create: create,
+        deps: createDeps,
+        inst: inst,
+        next: null
+      };
+      inst = currentlyRenderingFiber.updateQueue;
+      null === inst && (inst = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = inst);
+      create = inst.lastEffect;
+      null === create ? inst.lastEffect = tag.next = tag : (createDeps = create.next, create.next = tag, tag.next = createDeps, inst.lastEffect = tag);
+      return tag;
+    }
+    function createEffectInstance() {
+      return {
+        destroy: void 0,
+        resource: void 0
+      };
+    }
+    function mountRef(initialValue) {
+      var hook = mountWorkInProgressHook();
+      initialValue = {
+        current: initialValue
+      };
+      return hook.memoizedState = initialValue;
+    }
+    function mountEffectImpl(fiberFlags, hookFlags, create, createDeps) {
+      var hook = mountWorkInProgressHook();
+      createDeps = void 0 === createDeps ? null : createDeps;
+      currentlyRenderingFiber.flags |= fiberFlags;
+      hook.memoizedState = pushSimpleEffect(HasEffect | hookFlags, createEffectInstance(), create, createDeps);
+    }
+    function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
+      var hook = updateWorkInProgressHook();
+      deps = void 0 === deps ? null : deps;
+      var inst = hook.memoizedState.inst;
+      null !== currentHook && null !== deps && areHookInputsEqual(deps, currentHook.memoizedState.deps) ? hook.memoizedState = pushSimpleEffect(hookFlags, inst, create, deps) : (currentlyRenderingFiber.flags |= fiberFlags, hook.memoizedState = pushSimpleEffect(HasEffect | hookFlags, inst, create, deps));
+    }
+    function mountEffect(create, createDeps) {
+      0 !== (currentlyRenderingFiber.mode & 16) && 0 === (currentlyRenderingFiber.mode & 64) ? mountEffectImpl(276826112, Passive, create, createDeps) : mountEffectImpl(8390656, Passive, create, createDeps);
+    }
+    function mountLayoutEffect(create, deps) {
+      var fiberFlags = 4194308;
+      0 !== (currentlyRenderingFiber.mode & 16) && (fiberFlags |= 134217728);
+      return mountEffectImpl(fiberFlags, Layout, create, deps);
+    }
+    function imperativeHandleEffect(create, ref) {
+      if ("function" === typeof ref) {
+        create = create();
+        var refCleanup = ref(create);
+        return function () {
+          "function" === typeof refCleanup ? refCleanup() : ref(null);
+        };
+      }
+      if (null !== ref && void 0 !== ref) return ref.hasOwnProperty("current") || console.error("Expected useImperativeHandle() first argument to either be a ref callback or React.createRef() object. Instead received: %s.", "an object with keys {" + Object.keys(ref).join(", ") + "}"), create = create(), ref.current = create, function () {
+        ref.current = null;
+      };
+    }
+    function mountImperativeHandle(ref, create, deps) {
+      "function" !== typeof create && console.error("Expected useImperativeHandle() second argument to be a function that creates a handle. Instead received: %s.", null !== create ? typeof create : "null");
+      deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+      var fiberFlags = 4194308;
+      0 !== (currentlyRenderingFiber.mode & 16) && (fiberFlags |= 134217728);
+      mountEffectImpl(fiberFlags, Layout, imperativeHandleEffect.bind(null, create, ref), deps);
+    }
+    function updateImperativeHandle(ref, create, deps) {
+      "function" !== typeof create && console.error("Expected useImperativeHandle() second argument to be a function that creates a handle. Instead received: %s.", null !== create ? typeof create : "null");
+      deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+      updateEffectImpl(4, Layout, imperativeHandleEffect.bind(null, create, ref), deps);
+    }
+    function mountCallback(callback, deps) {
+      mountWorkInProgressHook().memoizedState = [callback, void 0 === deps ? null : deps];
+      return callback;
+    }
+    function updateCallback(callback, deps) {
+      var hook = updateWorkInProgressHook();
+      deps = void 0 === deps ? null : deps;
+      var prevState = hook.memoizedState;
+      if (null !== deps && areHookInputsEqual(deps, prevState[1])) return prevState[0];
+      hook.memoizedState = [callback, deps];
+      return callback;
+    }
+    function mountMemo(nextCreate, deps) {
+      var hook = mountWorkInProgressHook();
+      deps = void 0 === deps ? null : deps;
+      var nextValue = nextCreate();
+      if (shouldDoubleInvokeUserFnsInHooksDEV) {
+        setIsStrictModeForDevtools(!0);
+        try {
+          nextCreate();
+        } finally {
+          setIsStrictModeForDevtools(!1);
+        }
+      }
+      hook.memoizedState = [nextValue, deps];
+      return nextValue;
+    }
+    function updateMemo(nextCreate, deps) {
+      var hook = updateWorkInProgressHook();
+      deps = void 0 === deps ? null : deps;
+      var prevState = hook.memoizedState;
+      if (null !== deps && areHookInputsEqual(deps, prevState[1])) return prevState[0];
+      prevState = nextCreate();
+      if (shouldDoubleInvokeUserFnsInHooksDEV) {
+        setIsStrictModeForDevtools(!0);
+        try {
+          nextCreate();
+        } finally {
+          setIsStrictModeForDevtools(!1);
+        }
+      }
+      hook.memoizedState = [prevState, deps];
+      return prevState;
+    }
+    function mountDeferredValue(value, initialValue) {
+      var hook = mountWorkInProgressHook();
+      return mountDeferredValueImpl(hook, value, initialValue);
+    }
+    function updateDeferredValue(value, initialValue) {
+      var hook = updateWorkInProgressHook();
+      return updateDeferredValueImpl(hook, currentHook.memoizedState, value, initialValue);
+    }
+    function rerenderDeferredValue(value, initialValue) {
+      var hook = updateWorkInProgressHook();
+      return null === currentHook ? mountDeferredValueImpl(hook, value, initialValue) : updateDeferredValueImpl(hook, currentHook.memoizedState, value, initialValue);
+    }
+    function mountDeferredValueImpl(hook, value, initialValue) {
+      if (void 0 === initialValue || 0 !== (renderLanes & 1073741824)) return hook.memoizedState = value;
+      hook.memoizedState = initialValue;
+      hook = requestDeferredLane();
+      currentlyRenderingFiber.lanes |= hook;
+      workInProgressRootSkippedLanes |= hook;
+      return initialValue;
+    }
+    function updateDeferredValueImpl(hook, prevValue, value, initialValue) {
+      if (objectIs(value, prevValue)) return value;
+      if (null !== currentTreeHiddenStackCursor.current) return hook = mountDeferredValueImpl(hook, value, initialValue), objectIs(hook, prevValue) || (didReceiveUpdate = !0), hook;
+      if (0 === (renderLanes & 42)) return didReceiveUpdate = !0, hook.memoizedState = value;
+      hook = requestDeferredLane();
+      currentlyRenderingFiber.lanes |= hook;
+      workInProgressRootSkippedLanes |= hook;
+      return prevValue;
+    }
+    function startTransition(fiber, queue, pendingState, finishedState, callback) {
+      var previousPriority = currentUpdatePriority;
+      currentUpdatePriority = 0 !== previousPriority && previousPriority < ContinuousEventPriority ? previousPriority : ContinuousEventPriority;
+      var prevTransition = ReactSharedInternals.T,
+        currentTransition = {};
+      ReactSharedInternals.T = currentTransition;
+      dispatchOptimisticSetState(fiber, !1, queue, pendingState);
+      currentTransition._updatedFibers = new Set();
+      try {
+        var returnValue = callback(),
+          onStartTransitionFinish = ReactSharedInternals.S;
+        null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
+        if (null !== returnValue && "object" === typeof returnValue && "function" === typeof returnValue.then) {
+          var thenableForFinishedState = chainThenableValue(returnValue, finishedState);
+          dispatchSetStateInternal(fiber, queue, thenableForFinishedState, requestUpdateLane(fiber));
+        } else dispatchSetStateInternal(fiber, queue, finishedState, requestUpdateLane(fiber));
+      } catch (error) {
+        dispatchSetStateInternal(fiber, queue, {
+          then: function then() {},
+          status: "rejected",
+          reason: error
+        }, requestUpdateLane(fiber));
+      } finally {
+        currentUpdatePriority = previousPriority, ReactSharedInternals.T = prevTransition, null === prevTransition && currentTransition._updatedFibers && (fiber = currentTransition._updatedFibers.size, currentTransition._updatedFibers.clear(), 10 < fiber && console.warn("Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table."));
+      }
+    }
+    function mountTransition() {
+      var stateHook = mountStateImpl(!1);
+      stateHook = startTransition.bind(null, currentlyRenderingFiber, stateHook.queue, !0, !1);
+      mountWorkInProgressHook().memoizedState = stateHook;
+      return [!1, stateHook];
+    }
+    function updateTransition() {
+      var booleanOrThenable = updateReducer(basicStateReducer)[0],
+        start = updateWorkInProgressHook().memoizedState;
+      return ["boolean" === typeof booleanOrThenable ? booleanOrThenable : useThenable(booleanOrThenable), start];
+    }
+    function rerenderTransition() {
+      var booleanOrThenable = rerenderReducer(basicStateReducer)[0],
+        start = updateWorkInProgressHook().memoizedState;
+      return ["boolean" === typeof booleanOrThenable ? booleanOrThenable : useThenable(booleanOrThenable), start];
+    }
+    function useHostTransitionStatus() {
+      return _readContext(HostTransitionContext);
+    }
+    function mountId() {
+      var hook = mountWorkInProgressHook(),
+        identifierPrefix = workInProgressRoot.identifierPrefix,
+        globalClientId = globalClientIdCounter++;
+      identifierPrefix = "\xAB" + identifierPrefix + "r" + globalClientId.toString(32) + "\xBB";
+      return hook.memoizedState = identifierPrefix;
+    }
+    function mountRefresh() {
+      return mountWorkInProgressHook().memoizedState = refreshCache.bind(null, currentlyRenderingFiber);
+    }
+    function refreshCache(fiber, seedKey) {
+      for (var provider = fiber.return; null !== provider;) {
+        switch (provider.tag) {
+          case 24:
+          case 3:
+            var lane = requestUpdateLane(provider);
+            fiber = createUpdate(lane);
+            var root = enqueueUpdate(provider, fiber, lane);
+            null !== root && (scheduleUpdateOnFiber(root, provider, lane), entangleTransitions(root, provider, lane));
+            provider = createCache();
+            null !== seedKey && void 0 !== seedKey && null !== root && console.error("The seed argument is not enabled outside experimental channels.");
+            fiber.payload = {
+              cache: provider
+            };
+            return;
+        }
+        provider = provider.return;
+      }
+    }
+    function dispatchReducerAction(fiber, queue, action) {
+      var args = arguments;
+      "function" === typeof args[3] && console.error("State updates from the useState() and useReducer() Hooks don't support the second callback argument. To execute a side effect after rendering, declare it in the component body with useEffect().");
+      args = requestUpdateLane(fiber);
+      var update = {
+        lane: args,
+        revertLane: 0,
+        action: action,
+        hasEagerState: !1,
+        eagerState: null,
+        next: null
+      };
+      isRenderPhaseUpdate(fiber) ? enqueueRenderPhaseUpdate(queue, update) : (update = enqueueConcurrentHookUpdate(fiber, queue, update, args), null !== update && (scheduleUpdateOnFiber(update, fiber, args), entangleTransitionUpdate(update, queue, args)));
+      markStateUpdateScheduled(fiber, args);
+    }
+    function dispatchSetState(fiber, queue, action) {
+      var args = arguments;
+      "function" === typeof args[3] && console.error("State updates from the useState() and useReducer() Hooks don't support the second callback argument. To execute a side effect after rendering, declare it in the component body with useEffect().");
+      args = requestUpdateLane(fiber);
+      dispatchSetStateInternal(fiber, queue, action, args);
+      markStateUpdateScheduled(fiber, args);
+    }
+    function dispatchSetStateInternal(fiber, queue, action, lane) {
+      var update = {
+        lane: lane,
+        revertLane: 0,
+        action: action,
+        hasEagerState: !1,
+        eagerState: null,
+        next: null
+      };
+      if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, update);else {
+        var alternate = fiber.alternate;
+        if (0 === fiber.lanes && (null === alternate || 0 === alternate.lanes) && (alternate = queue.lastRenderedReducer, null !== alternate)) {
+          var prevDispatcher = ReactSharedInternals.H;
+          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
+          try {
+            var currentState = queue.lastRenderedState,
+              eagerState = alternate(currentState, action);
+            update.hasEagerState = !0;
+            update.eagerState = eagerState;
+            if (objectIs(eagerState, currentState)) return enqueueUpdate$1(fiber, queue, update, 0), null === workInProgressRoot && finishQueueingConcurrentUpdates(), !1;
+          } catch (error) {} finally {
+            ReactSharedInternals.H = prevDispatcher;
+          }
+        }
+        action = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
+        if (null !== action) return scheduleUpdateOnFiber(action, fiber, lane), entangleTransitionUpdate(action, queue, lane), !0;
+      }
+      return !1;
+    }
+    function dispatchOptimisticSetState(fiber, throwIfDuringRender, queue, action) {
+      null === ReactSharedInternals.T && 0 === currentEntangledLane && console.error("An optimistic state update occurred outside a transition or action. To fix, move the update to an action, or wrap with startTransition.");
+      action = {
+        lane: 2,
+        revertLane: requestTransitionLane(),
+        action: action,
+        hasEagerState: !1,
+        eagerState: null,
+        next: null
+      };
+      if (isRenderPhaseUpdate(fiber)) {
+        if (throwIfDuringRender) throw Error("Cannot update optimistic state while rendering.");
+        console.error("Cannot call startTransition while rendering.");
+      } else throwIfDuringRender = enqueueConcurrentHookUpdate(fiber, queue, action, 2), null !== throwIfDuringRender && scheduleUpdateOnFiber(throwIfDuringRender, fiber, 2);
+      markStateUpdateScheduled(fiber, 2);
+    }
+    function isRenderPhaseUpdate(fiber) {
+      var alternate = fiber.alternate;
+      return fiber === currentlyRenderingFiber || null !== alternate && alternate === currentlyRenderingFiber;
+    }
+    function enqueueRenderPhaseUpdate(queue, update) {
+      didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate = !0;
+      var pending = queue.pending;
+      null === pending ? update.next = update : (update.next = pending.next, pending.next = update);
+      queue.pending = update;
+    }
+    function entangleTransitionUpdate(root, queue, lane) {
+      if (0 !== (lane & 4194048)) {
+        var queueLanes = queue.lanes;
+        queueLanes &= root.pendingLanes;
+        lane |= queueLanes;
+        queue.lanes = lane;
+        markRootEntangled(root, lane);
+      }
+    }
+    function pushDebugInfo(debugInfo) {
+      var previousDebugInfo = currentDebugInfo;
+      null != debugInfo && (currentDebugInfo = null === previousDebugInfo ? debugInfo : previousDebugInfo.concat(debugInfo));
+      return previousDebugInfo;
+    }
+    function validateFragmentProps(element, fiber, returnFiber) {
+      for (var keys = Object.keys(element.props), i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        if ("children" !== key && "key" !== key) {
+          null === fiber && (fiber = createFiberFromElement(element, returnFiber.mode, 0), fiber._debugInfo = currentDebugInfo, fiber.return = returnFiber);
+          runWithFiberInDEV(fiber, function (erroredKey) {
+            console.error("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", erroredKey);
+          }, key);
+          break;
+        }
+      }
+    }
+    function unwrapThenable(thenable) {
+      var index = thenableIndexCounter;
+      thenableIndexCounter += 1;
+      null === thenableState && (thenableState = createThenableState());
+      return trackUsedThenable(thenableState, thenable, index);
+    }
+    function coerceRef(workInProgress, element) {
+      element = element.props.ref;
+      workInProgress.ref = void 0 !== element ? element : null;
+    }
+    function throwOnInvalidObjectType(returnFiber, newChild) {
+      if (newChild.$$typeof === REACT_LEGACY_ELEMENT_TYPE) throw Error('A React Element from an older version of React was rendered. This is not supported. It can happen if:\n- Multiple copies of the "react" package is used.\n- A library pre-bundled an old copy of "react" or "react/jsx-runtime".\n- A compiler tries to "inline" JSX instead of using the runtime.');
+      returnFiber = Object.prototype.toString.call(newChild);
+      throw Error("Objects are not valid as a React child (found: " + ("[object Object]" === returnFiber ? "object with keys {" + Object.keys(newChild).join(", ") + "}" : returnFiber) + "). If you meant to render a collection of children, use an array instead.");
+    }
+    function warnOnFunctionType(returnFiber, invalidChild) {
+      var parentName = getComponentNameFromFiber(returnFiber) || "Component";
+      ownerHasFunctionTypeWarning[parentName] || (ownerHasFunctionTypeWarning[parentName] = !0, invalidChild = invalidChild.displayName || invalidChild.name || "Component", 3 === returnFiber.tag ? console.error("Functions are not valid as a React child. This may happen if you return %s instead of <%s /> from render. Or maybe you meant to call this function rather than return it.\n  root.render(%s)", invalidChild, invalidChild, invalidChild) : console.error("Functions are not valid as a React child. This may happen if you return %s instead of <%s /> from render. Or maybe you meant to call this function rather than return it.\n  <%s>{%s}</%s>", invalidChild, invalidChild, parentName, invalidChild, parentName));
+    }
+    function warnOnSymbolType(returnFiber, invalidChild) {
+      var parentName = getComponentNameFromFiber(returnFiber) || "Component";
+      ownerHasSymbolTypeWarning[parentName] || (ownerHasSymbolTypeWarning[parentName] = !0, invalidChild = String(invalidChild), 3 === returnFiber.tag ? console.error("Symbols are not valid as a React child.\n  root.render(%s)", invalidChild) : console.error("Symbols are not valid as a React child.\n  <%s>%s</%s>", parentName, invalidChild, parentName));
+    }
+    function createChildReconciler(shouldTrackSideEffects) {
+      function deleteChild(returnFiber, childToDelete) {
+        if (shouldTrackSideEffects) {
+          var deletions = returnFiber.deletions;
+          null === deletions ? (returnFiber.deletions = [childToDelete], returnFiber.flags |= 16) : deletions.push(childToDelete);
+        }
+      }
+      function deleteRemainingChildren(returnFiber, currentFirstChild) {
+        if (!shouldTrackSideEffects) return null;
+        for (; null !== currentFirstChild;) deleteChild(returnFiber, currentFirstChild), currentFirstChild = currentFirstChild.sibling;
+        return null;
+      }
+      function mapRemainingChildren(currentFirstChild) {
+        for (var existingChildren = new Map(); null !== currentFirstChild;) null !== currentFirstChild.key ? existingChildren.set(currentFirstChild.key, currentFirstChild) : existingChildren.set(currentFirstChild.index, currentFirstChild), currentFirstChild = currentFirstChild.sibling;
+        return existingChildren;
+      }
+      function useFiber(fiber, pendingProps) {
+        fiber = createWorkInProgress(fiber, pendingProps);
+        fiber.index = 0;
+        fiber.sibling = null;
+        return fiber;
+      }
+      function placeChild(newFiber, lastPlacedIndex, newIndex) {
+        newFiber.index = newIndex;
+        if (!shouldTrackSideEffects) return newFiber.flags |= 1048576, lastPlacedIndex;
+        newIndex = newFiber.alternate;
+        if (null !== newIndex) return newIndex = newIndex.index, newIndex < lastPlacedIndex ? (newFiber.flags |= 67108866, lastPlacedIndex) : newIndex;
+        newFiber.flags |= 67108866;
+        return lastPlacedIndex;
+      }
+      function placeSingleChild(newFiber) {
+        shouldTrackSideEffects && null === newFiber.alternate && (newFiber.flags |= 67108866);
+        return newFiber;
+      }
+      function updateTextNode(returnFiber, current, textContent, lanes) {
+        if (null === current || 6 !== current.tag) return current = createFiberFromText(textContent, returnFiber.mode, lanes), current.return = returnFiber, current._debugOwner = returnFiber, current._debugTask = returnFiber._debugTask, current._debugInfo = currentDebugInfo, current;
+        current = useFiber(current, textContent);
+        current.return = returnFiber;
+        current._debugInfo = currentDebugInfo;
+        return current;
+      }
+      function updateElement(returnFiber, current, element, lanes) {
+        var elementType = element.type;
+        if (elementType === REACT_FRAGMENT_TYPE) return current = updateFragment(returnFiber, current, element.props.children, lanes, element.key), validateFragmentProps(element, current, returnFiber), current;
+        if (null !== current && (current.elementType === elementType || isCompatibleFamilyForHotReloading(current, element) || "object" === typeof elementType && null !== elementType && elementType.$$typeof === REACT_LAZY_TYPE && callLazyInitInDEV(elementType) === current.type)) return current = useFiber(current, element.props), coerceRef(current, element), current.return = returnFiber, current._debugOwner = element._owner, current._debugInfo = currentDebugInfo, current;
+        current = createFiberFromElement(element, returnFiber.mode, lanes);
+        coerceRef(current, element);
+        current.return = returnFiber;
+        current._debugInfo = currentDebugInfo;
+        return current;
+      }
+      function updatePortal(returnFiber, current, portal, lanes) {
+        if (null === current || 4 !== current.tag || current.stateNode.containerInfo !== portal.containerInfo || current.stateNode.implementation !== portal.implementation) return current = createFiberFromPortal(portal, returnFiber.mode, lanes), current.return = returnFiber, current._debugInfo = currentDebugInfo, current;
+        current = useFiber(current, portal.children || []);
+        current.return = returnFiber;
+        current._debugInfo = currentDebugInfo;
+        return current;
+      }
+      function updateFragment(returnFiber, current, fragment, lanes, key) {
+        if (null === current || 7 !== current.tag) return current = createFiberFromFragment(fragment, returnFiber.mode, lanes, key), current.return = returnFiber, current._debugOwner = returnFiber, current._debugTask = returnFiber._debugTask, current._debugInfo = currentDebugInfo, current;
+        current = useFiber(current, fragment);
+        current.return = returnFiber;
+        current._debugInfo = currentDebugInfo;
+        return current;
+      }
+      function createChild(returnFiber, newChild, lanes) {
+        if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild) return newChild = createFiberFromText("" + newChild, returnFiber.mode, lanes), newChild.return = returnFiber, newChild._debugOwner = returnFiber, newChild._debugTask = returnFiber._debugTask, newChild._debugInfo = currentDebugInfo, newChild;
+        if ("object" === typeof newChild && null !== newChild) {
+          switch (newChild.$$typeof) {
+            case REACT_ELEMENT_TYPE:
+              return lanes = createFiberFromElement(newChild, returnFiber.mode, lanes), coerceRef(lanes, newChild), lanes.return = returnFiber, returnFiber = pushDebugInfo(newChild._debugInfo), lanes._debugInfo = currentDebugInfo, currentDebugInfo = returnFiber, lanes;
+            case REACT_PORTAL_TYPE:
+              return newChild = createFiberFromPortal(newChild, returnFiber.mode, lanes), newChild.return = returnFiber, newChild._debugInfo = currentDebugInfo, newChild;
+            case REACT_LAZY_TYPE:
+              var _prevDebugInfo = pushDebugInfo(newChild._debugInfo);
+              newChild = callLazyInitInDEV(newChild);
+              returnFiber = createChild(returnFiber, newChild, lanes);
+              currentDebugInfo = _prevDebugInfo;
+              return returnFiber;
+          }
+          if (isArrayImpl(newChild) || getIteratorFn(newChild)) return lanes = createFiberFromFragment(newChild, returnFiber.mode, lanes, null), lanes.return = returnFiber, lanes._debugOwner = returnFiber, lanes._debugTask = returnFiber._debugTask, returnFiber = pushDebugInfo(newChild._debugInfo), lanes._debugInfo = currentDebugInfo, currentDebugInfo = returnFiber, lanes;
+          if ("function" === typeof newChild.then) return _prevDebugInfo = pushDebugInfo(newChild._debugInfo), returnFiber = createChild(returnFiber, unwrapThenable(newChild), lanes), currentDebugInfo = _prevDebugInfo, returnFiber;
+          if (newChild.$$typeof === REACT_CONTEXT_TYPE) return createChild(returnFiber, readContextDuringReconciliation(returnFiber, newChild), lanes);
+          throwOnInvalidObjectType(returnFiber, newChild);
+        }
+        "function" === typeof newChild && warnOnFunctionType(returnFiber, newChild);
+        "symbol" === typeof newChild && warnOnSymbolType(returnFiber, newChild);
+        return null;
+      }
+      function updateSlot(returnFiber, oldFiber, newChild, lanes) {
+        var key = null !== oldFiber ? oldFiber.key : null;
+        if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild) return null !== key ? null : updateTextNode(returnFiber, oldFiber, "" + newChild, lanes);
+        if ("object" === typeof newChild && null !== newChild) {
+          switch (newChild.$$typeof) {
+            case REACT_ELEMENT_TYPE:
+              return newChild.key === key ? (key = pushDebugInfo(newChild._debugInfo), returnFiber = updateElement(returnFiber, oldFiber, newChild, lanes), currentDebugInfo = key, returnFiber) : null;
+            case REACT_PORTAL_TYPE:
+              return newChild.key === key ? updatePortal(returnFiber, oldFiber, newChild, lanes) : null;
+            case REACT_LAZY_TYPE:
+              return key = pushDebugInfo(newChild._debugInfo), newChild = callLazyInitInDEV(newChild), returnFiber = updateSlot(returnFiber, oldFiber, newChild, lanes), currentDebugInfo = key, returnFiber;
+          }
+          if (isArrayImpl(newChild) || getIteratorFn(newChild)) {
+            if (null !== key) return null;
+            key = pushDebugInfo(newChild._debugInfo);
+            returnFiber = updateFragment(returnFiber, oldFiber, newChild, lanes, null);
+            currentDebugInfo = key;
+            return returnFiber;
+          }
+          if ("function" === typeof newChild.then) return key = pushDebugInfo(newChild._debugInfo), returnFiber = updateSlot(returnFiber, oldFiber, unwrapThenable(newChild), lanes), currentDebugInfo = key, returnFiber;
+          if (newChild.$$typeof === REACT_CONTEXT_TYPE) return updateSlot(returnFiber, oldFiber, readContextDuringReconciliation(returnFiber, newChild), lanes);
+          throwOnInvalidObjectType(returnFiber, newChild);
+        }
+        "function" === typeof newChild && warnOnFunctionType(returnFiber, newChild);
+        "symbol" === typeof newChild && warnOnSymbolType(returnFiber, newChild);
+        return null;
+      }
+      function updateFromMap(existingChildren, returnFiber, newIdx, newChild, lanes) {
+        if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild) return existingChildren = existingChildren.get(newIdx) || null, updateTextNode(returnFiber, existingChildren, "" + newChild, lanes);
+        if ("object" === typeof newChild && null !== newChild) {
+          switch (newChild.$$typeof) {
+            case REACT_ELEMENT_TYPE:
+              return newIdx = existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, existingChildren = pushDebugInfo(newChild._debugInfo), returnFiber = updateElement(returnFiber, newIdx, newChild, lanes), currentDebugInfo = existingChildren, returnFiber;
+            case REACT_PORTAL_TYPE:
+              return existingChildren = existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, updatePortal(returnFiber, existingChildren, newChild, lanes);
+            case REACT_LAZY_TYPE:
+              var _prevDebugInfo7 = pushDebugInfo(newChild._debugInfo);
+              newChild = callLazyInitInDEV(newChild);
+              returnFiber = updateFromMap(existingChildren, returnFiber, newIdx, newChild, lanes);
+              currentDebugInfo = _prevDebugInfo7;
+              return returnFiber;
+          }
+          if (isArrayImpl(newChild) || getIteratorFn(newChild)) return newIdx = existingChildren.get(newIdx) || null, existingChildren = pushDebugInfo(newChild._debugInfo), returnFiber = updateFragment(returnFiber, newIdx, newChild, lanes, null), currentDebugInfo = existingChildren, returnFiber;
+          if ("function" === typeof newChild.then) return _prevDebugInfo7 = pushDebugInfo(newChild._debugInfo), returnFiber = updateFromMap(existingChildren, returnFiber, newIdx, unwrapThenable(newChild), lanes), currentDebugInfo = _prevDebugInfo7, returnFiber;
+          if (newChild.$$typeof === REACT_CONTEXT_TYPE) return updateFromMap(existingChildren, returnFiber, newIdx, readContextDuringReconciliation(returnFiber, newChild), lanes);
+          throwOnInvalidObjectType(returnFiber, newChild);
+        }
+        "function" === typeof newChild && warnOnFunctionType(returnFiber, newChild);
+        "symbol" === typeof newChild && warnOnSymbolType(returnFiber, newChild);
+        return null;
+      }
+      function warnOnInvalidKey(returnFiber, workInProgress, child, knownKeys) {
+        if ("object" !== typeof child || null === child) return knownKeys;
+        switch (child.$$typeof) {
+          case REACT_ELEMENT_TYPE:
+          case REACT_PORTAL_TYPE:
+            warnForMissingKey(returnFiber, workInProgress, child);
+            var key = child.key;
+            if ("string" !== typeof key) break;
+            if (null === knownKeys) {
+              knownKeys = new Set();
+              knownKeys.add(key);
+              break;
+            }
+            if (!knownKeys.has(key)) {
+              knownKeys.add(key);
+              break;
+            }
+            runWithFiberInDEV(workInProgress, function () {
+              console.error("Encountered two children with the same key, `%s`. Keys should be unique so that components maintain their identity across updates. Non-unique keys may cause children to be duplicated and/or omitted \u2014 the behavior is unsupported and could change in a future version.", key);
+            });
+            break;
+          case REACT_LAZY_TYPE:
+            child = callLazyInitInDEV(child), warnOnInvalidKey(returnFiber, workInProgress, child, knownKeys);
+        }
+        return knownKeys;
+      }
+      function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, lanes) {
+        for (var knownKeys = null, resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null; null !== oldFiber && newIdx < newChildren.length; newIdx++) {
+          oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
+          var newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], lanes);
+          if (null === newFiber) {
+            null === oldFiber && (oldFiber = nextOldFiber);
+            break;
+          }
+          knownKeys = warnOnInvalidKey(returnFiber, newFiber, newChildren[newIdx], knownKeys);
+          shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
+          currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
+          null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber;
+          previousNewFiber = newFiber;
+          oldFiber = nextOldFiber;
+        }
+        if (newIdx === newChildren.length) return deleteRemainingChildren(returnFiber, oldFiber), resultingFirstChild;
+        if (null === oldFiber) {
+          for (; newIdx < newChildren.length; newIdx++) oldFiber = createChild(returnFiber, newChildren[newIdx], lanes), null !== oldFiber && (knownKeys = warnOnInvalidKey(returnFiber, oldFiber, newChildren[newIdx], knownKeys), currentFirstChild = placeChild(oldFiber, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = oldFiber : previousNewFiber.sibling = oldFiber, previousNewFiber = oldFiber);
+          return resultingFirstChild;
+        }
+        for (oldFiber = mapRemainingChildren(oldFiber); newIdx < newChildren.length; newIdx++) nextOldFiber = updateFromMap(oldFiber, returnFiber, newIdx, newChildren[newIdx], lanes), null !== nextOldFiber && (knownKeys = warnOnInvalidKey(returnFiber, nextOldFiber, newChildren[newIdx], knownKeys), shouldTrackSideEffects && null !== nextOldFiber.alternate && oldFiber.delete(null === nextOldFiber.key ? newIdx : nextOldFiber.key), currentFirstChild = placeChild(nextOldFiber, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = nextOldFiber : previousNewFiber.sibling = nextOldFiber, previousNewFiber = nextOldFiber);
+        shouldTrackSideEffects && oldFiber.forEach(function (child) {
+          return deleteChild(returnFiber, child);
+        });
+        return resultingFirstChild;
+      }
+      function reconcileChildrenIterator(returnFiber, currentFirstChild, newChildren, lanes) {
+        if (null == newChildren) throw Error("An iterable object provided no iterator.");
+        for (var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null, knownKeys = null, step = newChildren.next(); null !== oldFiber && !step.done; newIdx++, step = newChildren.next()) {
+          oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
+          var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
+          if (null === newFiber) {
+            null === oldFiber && (oldFiber = nextOldFiber);
+            break;
+          }
+          knownKeys = warnOnInvalidKey(returnFiber, newFiber, step.value, knownKeys);
+          shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
+          currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
+          null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber;
+          previousNewFiber = newFiber;
+          oldFiber = nextOldFiber;
+        }
+        if (step.done) return deleteRemainingChildren(returnFiber, oldFiber), resultingFirstChild;
+        if (null === oldFiber) {
+          for (; !step.done; newIdx++, step = newChildren.next()) oldFiber = createChild(returnFiber, step.value, lanes), null !== oldFiber && (knownKeys = warnOnInvalidKey(returnFiber, oldFiber, step.value, knownKeys), currentFirstChild = placeChild(oldFiber, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = oldFiber : previousNewFiber.sibling = oldFiber, previousNewFiber = oldFiber);
+          return resultingFirstChild;
+        }
+        for (oldFiber = mapRemainingChildren(oldFiber); !step.done; newIdx++, step = newChildren.next()) nextOldFiber = updateFromMap(oldFiber, returnFiber, newIdx, step.value, lanes), null !== nextOldFiber && (knownKeys = warnOnInvalidKey(returnFiber, nextOldFiber, step.value, knownKeys), shouldTrackSideEffects && null !== nextOldFiber.alternate && oldFiber.delete(null === nextOldFiber.key ? newIdx : nextOldFiber.key), currentFirstChild = placeChild(nextOldFiber, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = nextOldFiber : previousNewFiber.sibling = nextOldFiber, previousNewFiber = nextOldFiber);
+        shouldTrackSideEffects && oldFiber.forEach(function (child) {
+          return deleteChild(returnFiber, child);
+        });
+        return resultingFirstChild;
+      }
+      function reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes) {
+        "object" === typeof newChild && null !== newChild && newChild.type === REACT_FRAGMENT_TYPE && null === newChild.key && (validateFragmentProps(newChild, null, returnFiber), newChild = newChild.props.children);
+        if ("object" === typeof newChild && null !== newChild) {
+          switch (newChild.$$typeof) {
+            case REACT_ELEMENT_TYPE:
+              var prevDebugInfo = pushDebugInfo(newChild._debugInfo);
+              a: {
+                for (var key = newChild.key; null !== currentFirstChild;) {
+                  if (currentFirstChild.key === key) {
+                    key = newChild.type;
+                    if (key === REACT_FRAGMENT_TYPE) {
+                      if (7 === currentFirstChild.tag) {
+                        deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+                        lanes = useFiber(currentFirstChild, newChild.props.children);
+                        lanes.return = returnFiber;
+                        lanes._debugOwner = newChild._owner;
+                        lanes._debugInfo = currentDebugInfo;
+                        validateFragmentProps(newChild, lanes, returnFiber);
+                        returnFiber = lanes;
+                        break a;
+                      }
+                    } else if (currentFirstChild.elementType === key || isCompatibleFamilyForHotReloading(currentFirstChild, newChild) || "object" === typeof key && null !== key && key.$$typeof === REACT_LAZY_TYPE && callLazyInitInDEV(key) === currentFirstChild.type) {
+                      deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+                      lanes = useFiber(currentFirstChild, newChild.props);
+                      coerceRef(lanes, newChild);
+                      lanes.return = returnFiber;
+                      lanes._debugOwner = newChild._owner;
+                      lanes._debugInfo = currentDebugInfo;
+                      returnFiber = lanes;
+                      break a;
+                    }
+                    deleteRemainingChildren(returnFiber, currentFirstChild);
+                    break;
+                  } else deleteChild(returnFiber, currentFirstChild);
+                  currentFirstChild = currentFirstChild.sibling;
+                }
+                newChild.type === REACT_FRAGMENT_TYPE ? (lanes = createFiberFromFragment(newChild.props.children, returnFiber.mode, lanes, newChild.key), lanes.return = returnFiber, lanes._debugOwner = returnFiber, lanes._debugTask = returnFiber._debugTask, lanes._debugInfo = currentDebugInfo, validateFragmentProps(newChild, lanes, returnFiber), returnFiber = lanes) : (lanes = createFiberFromElement(newChild, returnFiber.mode, lanes), coerceRef(lanes, newChild), lanes.return = returnFiber, lanes._debugInfo = currentDebugInfo, returnFiber = lanes);
+              }
+              returnFiber = placeSingleChild(returnFiber);
+              currentDebugInfo = prevDebugInfo;
+              return returnFiber;
+            case REACT_PORTAL_TYPE:
+              a: {
+                prevDebugInfo = newChild;
+                for (newChild = prevDebugInfo.key; null !== currentFirstChild;) {
+                  if (currentFirstChild.key === newChild) {
+                    if (4 === currentFirstChild.tag && currentFirstChild.stateNode.containerInfo === prevDebugInfo.containerInfo && currentFirstChild.stateNode.implementation === prevDebugInfo.implementation) {
+                      deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+                      lanes = useFiber(currentFirstChild, prevDebugInfo.children || []);
+                      lanes.return = returnFiber;
+                      returnFiber = lanes;
+                      break a;
+                    } else {
+                      deleteRemainingChildren(returnFiber, currentFirstChild);
+                      break;
+                    }
+                  } else deleteChild(returnFiber, currentFirstChild);
+                  currentFirstChild = currentFirstChild.sibling;
+                }
+                lanes = createFiberFromPortal(prevDebugInfo, returnFiber.mode, lanes);
+                lanes.return = returnFiber;
+                returnFiber = lanes;
+              }
+              return placeSingleChild(returnFiber);
+            case REACT_LAZY_TYPE:
+              return prevDebugInfo = pushDebugInfo(newChild._debugInfo), newChild = callLazyInitInDEV(newChild), returnFiber = reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes), currentDebugInfo = prevDebugInfo, returnFiber;
+          }
+          if (isArrayImpl(newChild)) return prevDebugInfo = pushDebugInfo(newChild._debugInfo), returnFiber = reconcileChildrenArray(returnFiber, currentFirstChild, newChild, lanes), currentDebugInfo = prevDebugInfo, returnFiber;
+          if (getIteratorFn(newChild)) {
+            prevDebugInfo = pushDebugInfo(newChild._debugInfo);
+            key = getIteratorFn(newChild);
+            if ("function" !== typeof key) throw Error("An object is not an iterable. This error is likely caused by a bug in React. Please file an issue.");
+            var newChildren = key.call(newChild);
+            if (newChildren === newChild) {
+              if (0 !== returnFiber.tag || "[object GeneratorFunction]" !== Object.prototype.toString.call(returnFiber.type) || "[object Generator]" !== Object.prototype.toString.call(newChildren)) didWarnAboutGenerators || console.error("Using Iterators as children is unsupported and will likely yield unexpected results because enumerating a generator mutates it. You may convert it to an array with `Array.from()` or the `[...spread]` operator before rendering. You can also use an Iterable that can iterate multiple times over the same items."), didWarnAboutGenerators = !0;
+            } else newChild.entries !== key || didWarnAboutMaps || (console.error("Using Maps as children is not supported. Use an array of keyed ReactElements instead."), didWarnAboutMaps = !0);
+            returnFiber = reconcileChildrenIterator(returnFiber, currentFirstChild, newChildren, lanes);
+            currentDebugInfo = prevDebugInfo;
+            return returnFiber;
+          }
+          if ("function" === typeof newChild.then) return prevDebugInfo = pushDebugInfo(newChild._debugInfo), returnFiber = reconcileChildFibersImpl(returnFiber, currentFirstChild, unwrapThenable(newChild), lanes), currentDebugInfo = prevDebugInfo, returnFiber;
+          if (newChild.$$typeof === REACT_CONTEXT_TYPE) return reconcileChildFibersImpl(returnFiber, currentFirstChild, readContextDuringReconciliation(returnFiber, newChild), lanes);
+          throwOnInvalidObjectType(returnFiber, newChild);
+        }
+        if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild) return prevDebugInfo = "" + newChild, null !== currentFirstChild && 6 === currentFirstChild.tag ? (deleteRemainingChildren(returnFiber, currentFirstChild.sibling), lanes = useFiber(currentFirstChild, prevDebugInfo), lanes.return = returnFiber, returnFiber = lanes) : (deleteRemainingChildren(returnFiber, currentFirstChild), lanes = createFiberFromText(prevDebugInfo, returnFiber.mode, lanes), lanes.return = returnFiber, lanes._debugOwner = returnFiber, lanes._debugTask = returnFiber._debugTask, lanes._debugInfo = currentDebugInfo, returnFiber = lanes), placeSingleChild(returnFiber);
+        "function" === typeof newChild && warnOnFunctionType(returnFiber, newChild);
+        "symbol" === typeof newChild && warnOnSymbolType(returnFiber, newChild);
+        return deleteRemainingChildren(returnFiber, currentFirstChild);
+      }
+      return function (returnFiber, currentFirstChild, newChild, lanes) {
+        var prevDebugInfo = currentDebugInfo;
+        currentDebugInfo = null;
+        try {
+          thenableIndexCounter = 0;
+          var firstChildFiber = reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes);
+          thenableState = null;
+          return firstChildFiber;
+        } catch (x) {
+          if (x === SuspenseException || x === SuspenseActionException || 0 === (returnFiber.mode & 1) && "object" === typeof x && null !== x && "function" === typeof x.then) throw x;
+          var fiber = createFiber(29, x, null, returnFiber.mode);
+          fiber.lanes = lanes;
+          fiber.return = returnFiber;
+          var debugInfo = fiber._debugInfo = currentDebugInfo;
+          fiber._debugOwner = returnFiber._debugOwner;
+          fiber._debugTask = returnFiber._debugTask;
+          if (null != debugInfo) for (var i = debugInfo.length - 1; 0 <= i; i--) if ("string" === typeof debugInfo[i].stack) {
+            fiber._debugOwner = debugInfo[i];
+            fiber._debugTask = debugInfo[i].debugTask;
+            break;
+          }
+          return fiber;
+        } finally {
+          currentDebugInfo = prevDebugInfo;
+        }
+      };
+    }
+    function pushPrimaryTreeSuspenseHandler(handler) {
+      var current = handler.alternate;
+      push(suspenseStackCursor, suspenseStackCursor.current & SubtreeSuspenseContextMask, handler);
+      push(suspenseHandlerStackCursor, handler, handler);
+      null === shellBoundary && (null === current || null !== currentTreeHiddenStackCursor.current ? shellBoundary = handler : null !== current.memoizedState && (shellBoundary = handler));
+    }
+    function pushOffscreenSuspenseHandler(fiber) {
+      if (22 === fiber.tag) {
+        if (push(suspenseStackCursor, suspenseStackCursor.current, fiber), push(suspenseHandlerStackCursor, fiber, fiber), null === shellBoundary) {
+          var current = fiber.alternate;
+          null !== current && null !== current.memoizedState && (shellBoundary = fiber);
+        }
+      } else reuseSuspenseHandlerOnStack(fiber);
+    }
+    function reuseSuspenseHandlerOnStack(fiber) {
+      push(suspenseStackCursor, suspenseStackCursor.current, fiber);
+      push(suspenseHandlerStackCursor, suspenseHandlerStackCursor.current, fiber);
+    }
+    function popSuspenseHandler(fiber) {
+      pop(suspenseHandlerStackCursor, fiber);
+      shellBoundary === fiber && (shellBoundary = null);
+      pop(suspenseStackCursor, fiber);
+    }
+    function findFirstSuspended(row) {
+      for (var node = row; null !== node;) {
+        if (13 === node.tag) {
+          var state = node.memoizedState;
+          if (null !== state && (null === state.dehydrated || isSuspenseInstancePending() || isSuspenseInstanceFallback())) return node;
+        } else if (19 === node.tag && void 0 !== node.memoizedProps.revealOrder) {
+          if (0 !== (node.flags & 128)) return node;
+        } else if (null !== node.child) {
+          node.child.return = node;
+          node = node.child;
+          continue;
+        }
+        if (node === row) break;
+        for (; null === node.sibling;) {
+          if (null === node.return || node.return === row) return null;
+          node = node.return;
+        }
+        node.sibling.return = node.return;
+        node = node.sibling;
+      }
+      return null;
+    }
+    function warnOnInvalidCallback(callback) {
+      if (null !== callback && "function" !== typeof callback) {
+        var key = String(callback);
+        didWarnOnInvalidCallback.has(key) || (didWarnOnInvalidCallback.add(key), console.error("Expected the last optional `callback` argument to be a function. Instead received: %s.", callback));
+      }
+    }
+    function applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, nextProps) {
+      var prevState = workInProgress.memoizedState,
+        partialState = getDerivedStateFromProps(nextProps, prevState);
+      if (workInProgress.mode & 8) {
+        setIsStrictModeForDevtools(!0);
+        try {
+          partialState = getDerivedStateFromProps(nextProps, prevState);
+        } finally {
+          setIsStrictModeForDevtools(!1);
+        }
+      }
+      void 0 === partialState && (ctor = getComponentNameFromType(ctor) || "Component", didWarnAboutUndefinedDerivedState.has(ctor) || (didWarnAboutUndefinedDerivedState.add(ctor), console.error("%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. You have returned undefined.", ctor)));
+      prevState = null === partialState || void 0 === partialState ? prevState : assign({}, prevState, partialState);
+      workInProgress.memoizedState = prevState;
+      0 === workInProgress.lanes && (workInProgress.updateQueue.baseState = prevState);
+    }
+    function checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) {
+      var instance = workInProgress.stateNode;
+      if ("function" === typeof instance.shouldComponentUpdate) {
+        oldProps = instance.shouldComponentUpdate(newProps, newState, nextContext);
+        if (workInProgress.mode & 8) {
+          setIsStrictModeForDevtools(!0);
+          try {
+            oldProps = instance.shouldComponentUpdate(newProps, newState, nextContext);
+          } finally {
+            setIsStrictModeForDevtools(!1);
+          }
+        }
+        void 0 === oldProps && console.error("%s.shouldComponentUpdate(): Returned undefined instead of a boolean value. Make sure to return true or false.", getComponentNameFromType(ctor) || "Component");
+        return oldProps;
+      }
+      return ctor.prototype && ctor.prototype.isPureReactComponent ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState) : !0;
+    }
+    function constructClassInstance(workInProgress, ctor, props) {
+      var context = emptyContextObject,
+        contextType = ctor.contextType;
+      if ("contextType" in ctor && null !== contextType && (void 0 === contextType || contextType.$$typeof !== REACT_CONTEXT_TYPE) && !didWarnAboutInvalidateContextType.has(ctor)) {
+        didWarnAboutInvalidateContextType.add(ctor);
+        var addendum = void 0 === contextType ? " However, it is set to undefined. This can be caused by a typo or by mixing up named and default imports. This can also happen due to a circular dependency, so try moving the createContext() call to a separate file." : "object" !== typeof contextType ? " However, it is set to a " + typeof contextType + "." : contextType.$$typeof === REACT_CONSUMER_TYPE ? " Did you accidentally pass the Context.Consumer instead?" : " However, it is set to an object with keys {" + Object.keys(contextType).join(", ") + "}.";
+        console.error("%s defines an invalid contextType. contextType should point to the Context object returned by React.createContext().%s", getComponentNameFromType(ctor) || "Component", addendum);
+      }
+      "object" === typeof contextType && null !== contextType && (context = _readContext(contextType));
+      contextType = new ctor(props, context);
+      if (workInProgress.mode & 8) {
+        setIsStrictModeForDevtools(!0);
+        try {
+          contextType = new ctor(props, context);
+        } finally {
+          setIsStrictModeForDevtools(!1);
+        }
+      }
+      props = workInProgress.memoizedState = null !== contextType.state && void 0 !== contextType.state ? contextType.state : null;
+      contextType.updater = classComponentUpdater;
+      workInProgress.stateNode = contextType;
+      contextType._reactInternals = workInProgress;
+      contextType._reactInternalInstance = fakeInternalInstance;
+      "function" === typeof ctor.getDerivedStateFromProps && null === props && (workInProgress = getComponentNameFromType(ctor) || "Component", didWarnAboutUninitializedState.has(workInProgress) || (didWarnAboutUninitializedState.add(workInProgress), console.error("`%s` uses `getDerivedStateFromProps` but its initial state is %s. This is not recommended. Instead, define the initial state by assigning an object to `this.state` in the constructor of `%s`. This ensures that `getDerivedStateFromProps` arguments have a consistent shape.", workInProgress, null === contextType.state ? "null" : "undefined", workInProgress)));
+      if ("function" === typeof ctor.getDerivedStateFromProps || "function" === typeof contextType.getSnapshotBeforeUpdate) if (context = props = workInProgress = null, "function" === typeof contextType.componentWillMount && !0 !== contextType.componentWillMount.__suppressDeprecationWarning ? workInProgress = "componentWillMount" : "function" === typeof contextType.UNSAFE_componentWillMount && (workInProgress = "UNSAFE_componentWillMount"), "function" === typeof contextType.componentWillReceiveProps && !0 !== contextType.componentWillReceiveProps.__suppressDeprecationWarning ? props = "componentWillReceiveProps" : "function" === typeof contextType.UNSAFE_componentWillReceiveProps && (props = "UNSAFE_componentWillReceiveProps"), "function" === typeof contextType.componentWillUpdate && !0 !== contextType.componentWillUpdate.__suppressDeprecationWarning ? context = "componentWillUpdate" : "function" === typeof contextType.UNSAFE_componentWillUpdate && (context = "UNSAFE_componentWillUpdate"), null !== workInProgress || null !== props || null !== context) addendum = getComponentNameFromType(ctor) || "Component", ctor = "function" === typeof ctor.getDerivedStateFromProps ? "getDerivedStateFromProps()" : "getSnapshotBeforeUpdate()", didWarnAboutLegacyLifecyclesAndDerivedState.has(addendum) || (didWarnAboutLegacyLifecyclesAndDerivedState.add(addendum), console.error("Unsafe legacy lifecycles will not be called for components using new component APIs.\n\n%s uses %s but also contains the following legacy lifecycles:%s%s%s\n\nThe above lifecycles should be removed. Learn more about this warning here:\nhttps://react.dev/link/unsafe-component-lifecycles", addendum, ctor, null !== workInProgress ? "\n  " + workInProgress : "", null !== props ? "\n  " + props : "", null !== context ? "\n  " + context : ""));
+      return contextType;
+    }
+    function callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext) {
+      var oldState = instance.state;
+      "function" === typeof instance.componentWillReceiveProps && instance.componentWillReceiveProps(newProps, nextContext);
+      "function" === typeof instance.UNSAFE_componentWillReceiveProps && instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+      instance.state !== oldState && (workInProgress = getComponentNameFromFiber(workInProgress) || "Component", didWarnAboutStateAssignmentForComponent.has(workInProgress) || (didWarnAboutStateAssignmentForComponent.add(workInProgress), console.error("%s.componentWillReceiveProps(): Assigning directly to this.state is deprecated (except inside a component's constructor). Use setState instead.", workInProgress)), classComponentUpdater.enqueueReplaceState(instance, instance.state, null));
+    }
+    function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
+      var instance = workInProgress.stateNode,
+        name = getComponentNameFromType(ctor) || "Component";
+      instance.render || (ctor.prototype && "function" === typeof ctor.prototype.render ? console.error("No `render` method found on the %s instance: did you accidentally return an object from the constructor?", name) : console.error("No `render` method found on the %s instance: you may have forgotten to define `render`.", name));
+      !instance.getInitialState || instance.getInitialState.isReactClassApproved || instance.state || console.error("getInitialState was defined on %s, a plain JavaScript class. This is only supported for classes created using React.createClass. Did you mean to define a state property instead?", name);
+      instance.getDefaultProps && !instance.getDefaultProps.isReactClassApproved && console.error("getDefaultProps was defined on %s, a plain JavaScript class. This is only supported for classes created using React.createClass. Use a static property to define defaultProps instead.", name);
+      instance.contextType && console.error("contextType was defined as an instance property on %s. Use a static property to define contextType instead.", name);
+      ctor.childContextTypes && !didWarnAboutChildContextTypes.has(ctor) && (didWarnAboutChildContextTypes.add(ctor), console.error("%s uses the legacy childContextTypes API which was removed in React 19. Use React.createContext() instead. (https://react.dev/link/legacy-context)", name));
+      ctor.contextTypes && !didWarnAboutContextTypes$1.has(ctor) && (didWarnAboutContextTypes$1.add(ctor), console.error("%s uses the legacy contextTypes API which was removed in React 19. Use React.createContext() with static contextType instead. (https://react.dev/link/legacy-context)", name));
+      "function" === typeof instance.componentShouldUpdate && console.error("%s has a method called componentShouldUpdate(). Did you mean shouldComponentUpdate()? The name is phrased as a question because the function is expected to return a value.", name);
+      ctor.prototype && ctor.prototype.isPureReactComponent && "undefined" !== typeof instance.shouldComponentUpdate && console.error("%s has a method called shouldComponentUpdate(). shouldComponentUpdate should not be used when extending React.PureComponent. Please extend React.Component if shouldComponentUpdate is used.", getComponentNameFromType(ctor) || "A pure component");
+      "function" === typeof instance.componentDidUnmount && console.error("%s has a method called componentDidUnmount(). But there is no such lifecycle method. Did you mean componentWillUnmount()?", name);
+      "function" === typeof instance.componentDidReceiveProps && console.error("%s has a method called componentDidReceiveProps(). But there is no such lifecycle method. If you meant to update the state in response to changing props, use componentWillReceiveProps(). If you meant to fetch data or run side-effects or mutations after React has updated the UI, use componentDidUpdate().", name);
+      "function" === typeof instance.componentWillRecieveProps && console.error("%s has a method called componentWillRecieveProps(). Did you mean componentWillReceiveProps()?", name);
+      "function" === typeof instance.UNSAFE_componentWillRecieveProps && console.error("%s has a method called UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?", name);
+      var hasMutatedProps = instance.props !== newProps;
+      void 0 !== instance.props && hasMutatedProps && console.error("When calling super() in `%s`, make sure to pass up the same props that your component's constructor was passed.", name);
+      instance.defaultProps && console.error("Setting defaultProps as an instance property on %s is not supported and will be ignored. Instead, define defaultProps as a static property on %s.", name, name);
+      "function" !== typeof instance.getSnapshotBeforeUpdate || "function" === typeof instance.componentDidUpdate || didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.has(ctor) || (didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(ctor), console.error("%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). This component defines getSnapshotBeforeUpdate() only.", getComponentNameFromType(ctor)));
+      "function" === typeof instance.getDerivedStateFromProps && console.error("%s: getDerivedStateFromProps() is defined as an instance method and will be ignored. Instead, declare it as a static method.", name);
+      "function" === typeof instance.getDerivedStateFromError && console.error("%s: getDerivedStateFromError() is defined as an instance method and will be ignored. Instead, declare it as a static method.", name);
+      "function" === typeof ctor.getSnapshotBeforeUpdate && console.error("%s: getSnapshotBeforeUpdate() is defined as a static method and will be ignored. Instead, declare it as an instance method.", name);
+      (hasMutatedProps = instance.state) && ("object" !== typeof hasMutatedProps || isArrayImpl(hasMutatedProps)) && console.error("%s.state: must be set to an object or null", name);
+      "function" === typeof instance.getChildContext && "object" !== typeof ctor.childContextTypes && console.error("%s.getChildContext(): childContextTypes must be defined in order to use getChildContext().", name);
+      instance = workInProgress.stateNode;
+      instance.props = newProps;
+      instance.state = workInProgress.memoizedState;
+      instance.refs = {};
+      initializeUpdateQueue(workInProgress);
+      name = ctor.contextType;
+      instance.context = "object" === typeof name && null !== name ? _readContext(name) : emptyContextObject;
+      instance.state === newProps && (name = getComponentNameFromType(ctor) || "Component", didWarnAboutDirectlyAssigningPropsToState.has(name) || (didWarnAboutDirectlyAssigningPropsToState.add(name), console.error("%s: It is not recommended to assign props directly to state because updates to props won't be reflected in state. In most cases, it is better to use props directly.", name)));
+      workInProgress.mode & 8 && ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, instance);
+      ReactStrictModeWarnings.recordUnsafeLifecycleWarnings(workInProgress, instance);
+      instance.state = workInProgress.memoizedState;
+      name = ctor.getDerivedStateFromProps;
+      "function" === typeof name && (applyDerivedStateFromProps(workInProgress, ctor, name, newProps), instance.state = workInProgress.memoizedState);
+      "function" === typeof ctor.getDerivedStateFromProps || "function" === typeof instance.getSnapshotBeforeUpdate || "function" !== typeof instance.UNSAFE_componentWillMount && "function" !== typeof instance.componentWillMount || (ctor = instance.state, "function" === typeof instance.componentWillMount && instance.componentWillMount(), "function" === typeof instance.UNSAFE_componentWillMount && instance.UNSAFE_componentWillMount(), ctor !== instance.state && (console.error("%s.componentWillMount(): Assigning directly to this.state is deprecated (except inside a component's constructor). Use setState instead.", getComponentNameFromFiber(workInProgress) || "Component"), classComponentUpdater.enqueueReplaceState(instance, instance.state, null)), processUpdateQueue(workInProgress, newProps, instance, renderLanes), suspendIfUpdateReadFromEntangledAsyncAction(), instance.state = workInProgress.memoizedState);
+      "function" === typeof instance.componentDidMount && (workInProgress.flags |= 4194308);
+      0 !== (workInProgress.mode & 16) && (workInProgress.flags |= 134217728);
+    }
+    function resolveClassComponentProps(Component, baseProps) {
+      var newProps = baseProps;
+      if ("ref" in baseProps) {
+        newProps = {};
+        for (var propName in baseProps) "ref" !== propName && (newProps[propName] = baseProps[propName]);
+      }
+      if (Component = Component.defaultProps) {
+        newProps === baseProps && (newProps = assign({}, newProps));
+        for (var _propName in Component) void 0 === newProps[_propName] && (newProps[_propName] = Component[_propName]);
+      }
+      return newProps;
+    }
+    function defaultOnRecoverableError(error) {
+      reportGlobalError(error);
+    }
+    function logUncaughtError(root, errorInfo) {
+      try {
+        componentName = errorInfo.source ? getComponentNameFromFiber(errorInfo.source) : null;
+        errorBoundaryName = null;
+        var error = errorInfo.value;
+        if (null !== ReactSharedInternals.actQueue) ReactSharedInternals.thrownErrors.push(error);else {
+          var onUncaughtError = root.onUncaughtError;
+          onUncaughtError(error, {
+            componentStack: errorInfo.stack
+          });
+        }
+      } catch (e) {
+        setTimeout(function () {
+          throw e;
+        });
+      }
+    }
+    function logCaughtError(root, boundary, errorInfo) {
+      try {
+        componentName = errorInfo.source ? getComponentNameFromFiber(errorInfo.source) : null;
+        errorBoundaryName = getComponentNameFromFiber(boundary);
+        var onCaughtError = root.onCaughtError;
+        onCaughtError(errorInfo.value, {
+          componentStack: errorInfo.stack,
+          errorBoundary: 1 === boundary.tag ? boundary.stateNode : null
+        });
+      } catch (e) {
+        setTimeout(function () {
+          throw e;
+        });
+      }
+    }
+    function createRootErrorUpdate(root, errorInfo, lane) {
+      lane = createUpdate(lane);
+      lane.tag = CaptureUpdate;
+      lane.payload = {
+        element: null
+      };
+      lane.callback = function () {
+        runWithFiberInDEV(errorInfo.source, logUncaughtError, root, errorInfo);
+      };
+      return lane;
+    }
+    function createClassErrorUpdate(lane) {
+      lane = createUpdate(lane);
+      lane.tag = CaptureUpdate;
+      return lane;
+    }
+    function initializeClassErrorUpdate(update, root, fiber, errorInfo) {
+      var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+      if ("function" === typeof getDerivedStateFromError) {
+        var error = errorInfo.value;
+        update.payload = function () {
+          return getDerivedStateFromError(error);
+        };
+        update.callback = function () {
+          markFailedErrorBoundaryForHotReloading(fiber);
+          runWithFiberInDEV(errorInfo.source, logCaughtError, root, fiber, errorInfo);
+        };
+      }
+      var inst = fiber.stateNode;
+      null !== inst && "function" === typeof inst.componentDidCatch && (update.callback = function () {
+        markFailedErrorBoundaryForHotReloading(fiber);
+        runWithFiberInDEV(errorInfo.source, logCaughtError, root, fiber, errorInfo);
+        "function" !== typeof getDerivedStateFromError && (null === legacyErrorBoundariesThatAlreadyFailed ? legacyErrorBoundariesThatAlreadyFailed = new Set([this]) : legacyErrorBoundariesThatAlreadyFailed.add(this));
+        callComponentDidCatchInDEV(this, errorInfo);
+        "function" === typeof getDerivedStateFromError || 0 === (fiber.lanes & 2) && console.error("%s: Error boundaries should implement getDerivedStateFromError(). In that method, return a state update to display an error message or fallback UI.", getComponentNameFromFiber(fiber) || "Unknown");
+      });
+    }
+    function throwException(root, returnFiber, sourceFiber, value, rootRenderLanes) {
+      sourceFiber.flags |= 32768;
+      isDevToolsPresent && restorePendingUpdaters(root, rootRenderLanes);
+      if (null !== value && "object" === typeof value && "function" === typeof value.then) {
+        var currentSourceFiber = sourceFiber.alternate;
+        null !== currentSourceFiber && propagateParentContextChanges(currentSourceFiber, sourceFiber, rootRenderLanes, !0);
+        currentSourceFiber = sourceFiber.tag;
+        0 !== (sourceFiber.mode & 1) || 0 !== currentSourceFiber && 11 !== currentSourceFiber && 15 !== currentSourceFiber || ((currentSourceFiber = sourceFiber.alternate) ? (sourceFiber.updateQueue = currentSourceFiber.updateQueue, sourceFiber.memoizedState = currentSourceFiber.memoizedState, sourceFiber.lanes = currentSourceFiber.lanes) : (sourceFiber.updateQueue = null, sourceFiber.memoizedState = null));
+        currentSourceFiber = suspenseHandlerStackCursor.current;
+        if (null !== currentSourceFiber) {
+          switch (currentSourceFiber.tag) {
+            case 13:
+              return sourceFiber.mode & 1 && (null === shellBoundary ? renderDidSuspendDelayIfPossible() : null === currentSourceFiber.alternate && workInProgressRootExitStatus === RootInProgress && (workInProgressRootExitStatus = RootSuspended)), currentSourceFiber.flags &= -257, 0 === (currentSourceFiber.mode & 1) ? currentSourceFiber === returnFiber ? currentSourceFiber.flags |= 65536 : (currentSourceFiber.flags |= 128, sourceFiber.flags |= 131072, sourceFiber.flags &= -52805, 1 === sourceFiber.tag ? null === sourceFiber.alternate ? sourceFiber.tag = 17 : (returnFiber = createUpdate(2), returnFiber.tag = ForceUpdate, enqueueUpdate(sourceFiber, returnFiber, 2)) : 0 === sourceFiber.tag && null === sourceFiber.alternate && (sourceFiber.tag = 28), sourceFiber.lanes |= 2) : (currentSourceFiber.flags |= 65536, currentSourceFiber.lanes = rootRenderLanes), value === noopSuspenseyCommitThenable ? currentSourceFiber.flags |= 16384 : (returnFiber = currentSourceFiber.updateQueue, null === returnFiber ? currentSourceFiber.updateQueue = new Set([value]) : returnFiber.add(value), currentSourceFiber.mode & 1 && attachPingListener(root, value, rootRenderLanes)), !1;
+            case 22:
+              if (currentSourceFiber.mode & 1) return currentSourceFiber.flags |= 65536, value === noopSuspenseyCommitThenable ? currentSourceFiber.flags |= 16384 : (returnFiber = currentSourceFiber.updateQueue, null === returnFiber ? (returnFiber = {
+                transitions: null,
+                markerInstances: null,
+                retryQueue: new Set([value])
+              }, currentSourceFiber.updateQueue = returnFiber) : (sourceFiber = returnFiber.retryQueue, null === sourceFiber ? returnFiber.retryQueue = new Set([value]) : sourceFiber.add(value)), attachPingListener(root, value, rootRenderLanes)), !1;
+          }
+          throw Error("Unexpected Suspense handler tag (" + currentSourceFiber.tag + "). This is a bug in React.");
+        }
+        if (1 === root.tag) return attachPingListener(root, value, rootRenderLanes), renderDidSuspendDelayIfPossible(), !1;
+        value = 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.");
+      }
+      currentSourceFiber = createCapturedValueAtFiber(Error("There was an error during concurrent rendering but React was able to recover by instead synchronously rendering the entire root.", {
+        cause: value
+      }), sourceFiber);
+      null === workInProgressRootConcurrentErrors ? workInProgressRootConcurrentErrors = [currentSourceFiber] : workInProgressRootConcurrentErrors.push(currentSourceFiber);
+      workInProgressRootExitStatus !== RootSuspendedWithDelay && (workInProgressRootExitStatus = RootErrored);
+      if (null === returnFiber) return !0;
+      value = createCapturedValueAtFiber(value, sourceFiber);
+      do {
+        switch (returnFiber.tag) {
+          case 3:
+            return returnFiber.flags |= 65536, root = rootRenderLanes & -rootRenderLanes, returnFiber.lanes |= root, root = createRootErrorUpdate(returnFiber.stateNode, value, root), enqueueCapturedUpdate(returnFiber, root), !1;
+          case 1:
+            if (sourceFiber = returnFiber.type, currentSourceFiber = returnFiber.stateNode, 0 === (returnFiber.flags & 128) && ("function" === typeof sourceFiber.getDerivedStateFromError || null !== currentSourceFiber && "function" === typeof currentSourceFiber.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(currentSourceFiber)))) return returnFiber.flags |= 65536, rootRenderLanes &= -rootRenderLanes, returnFiber.lanes |= rootRenderLanes, rootRenderLanes = createClassErrorUpdate(rootRenderLanes), initializeClassErrorUpdate(rootRenderLanes, root, returnFiber, value), enqueueCapturedUpdate(returnFiber, rootRenderLanes), !1;
+        }
+        returnFiber = returnFiber.return;
+      } while (null !== returnFiber);
+      return !1;
+    }
+    function reconcileChildren(current, workInProgress, nextChildren, renderLanes) {
+      workInProgress.child = null === current ? mountChildFibers(workInProgress, null, nextChildren, renderLanes) : reconcileChildFibers(workInProgress, current.child, nextChildren, renderLanes);
+    }
+    function updateForwardRef(current, workInProgress, Component, nextProps, renderLanes) {
+      Component = Component.render;
+      var ref = workInProgress.ref;
+      if ("ref" in nextProps) {
+        var propsWithoutRef = {};
+        for (var key in nextProps) "ref" !== key && (propsWithoutRef[key] = nextProps[key]);
+      } else propsWithoutRef = nextProps;
+      prepareToReadContext(workInProgress);
+      markComponentRenderStarted(workInProgress);
+      nextProps = renderWithHooks(current, workInProgress, Component, propsWithoutRef, ref, renderLanes);
+      markComponentRenderStopped();
+      if (null !== current && !didReceiveUpdate) return bailoutHooks(current, workInProgress, renderLanes), bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+      workInProgress.flags |= 1;
+      reconcileChildren(current, workInProgress, nextProps, renderLanes);
+      return workInProgress.child;
+    }
+    function updateMemoComponent(current, workInProgress, Component, nextProps, renderLanes) {
+      if (null === current) {
+        var type = Component.type;
+        if ("function" === typeof type && !shouldConstruct(type) && void 0 === type.defaultProps && null === Component.compare) return Component = resolveFunctionForHotReloading(type), workInProgress.tag = 15, workInProgress.type = Component, validateFunctionComponentInDev(workInProgress, type), updateSimpleMemoComponent(current, workInProgress, Component, nextProps, renderLanes);
+        current = createFiberFromTypeAndProps(Component.type, null, nextProps, workInProgress, workInProgress.mode, renderLanes);
+        current.ref = workInProgress.ref;
+        current.return = workInProgress;
+        return workInProgress.child = current;
+      }
+      type = current.child;
+      if (!checkScheduledUpdateOrContext(current, renderLanes)) {
+        var prevProps = type.memoizedProps;
+        Component = Component.compare;
+        Component = null !== Component ? Component : shallowEqual;
+        if (Component(prevProps, nextProps) && current.ref === workInProgress.ref) return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+      }
+      workInProgress.flags |= 1;
+      current = createWorkInProgress(type, nextProps);
+      current.ref = workInProgress.ref;
+      current.return = workInProgress;
+      return workInProgress.child = current;
+    }
+    function updateSimpleMemoComponent(current, workInProgress, Component, nextProps, renderLanes) {
+      if (null !== current) {
+        var prevProps = current.memoizedProps;
+        if (shallowEqual(prevProps, nextProps) && current.ref === workInProgress.ref && workInProgress.type === current.type) if (didReceiveUpdate = !1, workInProgress.pendingProps = nextProps = prevProps, checkScheduledUpdateOrContext(current, renderLanes)) 0 !== (current.flags & 131072) && (didReceiveUpdate = !0);else return workInProgress.lanes = current.lanes, bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+      }
+      return updateFunctionComponent(current, workInProgress, Component, nextProps, renderLanes);
+    }
+    function updateOffscreenComponent(current, workInProgress, renderLanes) {
+      var nextProps = workInProgress.pendingProps,
+        nextChildren = nextProps.children,
+        prevState = null !== current ? current.memoizedState : null;
+      if ("hidden" === nextProps.mode) {
+        if (0 !== (workInProgress.flags & 128)) {
+          nextProps = null !== prevState ? prevState.baseLanes | renderLanes : renderLanes;
+          if (null !== current) {
+            nextChildren = workInProgress.child = current.child;
+            for (prevState = 0; null !== nextChildren;) prevState = prevState | nextChildren.lanes | nextChildren.childLanes, nextChildren = nextChildren.sibling;
+            workInProgress.childLanes = prevState & ~nextProps;
+          } else workInProgress.childLanes = 0, workInProgress.child = null;
+          return deferHiddenOffscreenComponent(current, workInProgress, nextProps, renderLanes);
+        }
+        if (0 === (workInProgress.mode & 1)) workInProgress.memoizedState = {
+          baseLanes: 0,
+          cachePool: null
+        }, null !== current && pushTransition(workInProgress, null), reuseHiddenContextOnStack(workInProgress), pushOffscreenSuspenseHandler(workInProgress);else if (0 !== (renderLanes & 536870912)) workInProgress.memoizedState = {
+          baseLanes: 0,
+          cachePool: null
+        }, null !== current && pushTransition(workInProgress, null !== prevState ? prevState.cachePool : null), null !== prevState ? pushHiddenContext(workInProgress, prevState) : reuseHiddenContextOnStack(workInProgress), pushOffscreenSuspenseHandler(workInProgress);else return workInProgress.lanes = workInProgress.childLanes = 536870912, deferHiddenOffscreenComponent(current, workInProgress, null !== prevState ? prevState.baseLanes | renderLanes : renderLanes, renderLanes);
+      } else null !== prevState ? (pushTransition(workInProgress, prevState.cachePool), pushHiddenContext(workInProgress, prevState), reuseSuspenseHandlerOnStack(workInProgress), workInProgress.memoizedState = null) : (null !== current && pushTransition(workInProgress, null), reuseHiddenContextOnStack(workInProgress), reuseSuspenseHandlerOnStack(workInProgress));
+      reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+      return workInProgress.child;
+    }
+    function deferHiddenOffscreenComponent(current, workInProgress, nextBaseLanes, renderLanes) {
+      var JSCompiler_inline_result = peekCacheFromPool();
+      JSCompiler_inline_result = null === JSCompiler_inline_result ? null : {
+        parent: CacheContext._currentValue2,
+        pool: JSCompiler_inline_result
+      };
+      workInProgress.memoizedState = {
+        baseLanes: nextBaseLanes,
+        cachePool: JSCompiler_inline_result
+      };
+      null !== current && pushTransition(workInProgress, null);
+      reuseHiddenContextOnStack(workInProgress);
+      pushOffscreenSuspenseHandler(workInProgress);
+      null !== current && propagateParentContextChanges(current, workInProgress, renderLanes, !0);
+      return null;
+    }
+    function markRef(current, workInProgress) {
+      var ref = workInProgress.ref;
+      if (null === ref) null !== current && null !== current.ref && (workInProgress.flags |= 4194816);else {
+        if ("function" !== typeof ref && "object" !== typeof ref) throw Error("Expected ref to be a function, an object returned by React.createRef(), or undefined/null.");
+        if (null === current || current.ref !== ref) workInProgress.flags |= 4194816;
+      }
+    }
+    function updateFunctionComponent(current, workInProgress, Component, nextProps, renderLanes) {
+      if (Component.prototype && "function" === typeof Component.prototype.render) {
+        var componentName = getComponentNameFromType(Component) || "Unknown";
+        didWarnAboutBadClass[componentName] || (console.error("The <%s /> component appears to have a render method, but doesn't extend React.Component. This is likely to cause errors. Change %s to extend React.Component instead.", componentName, componentName), didWarnAboutBadClass[componentName] = !0);
+      }
+      workInProgress.mode & 8 && ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, null);
+      null === current && (validateFunctionComponentInDev(workInProgress, workInProgress.type), Component.contextTypes && (componentName = getComponentNameFromType(Component) || "Unknown", didWarnAboutContextTypes[componentName] || (didWarnAboutContextTypes[componentName] = !0, console.error("%s uses the legacy contextTypes API which was removed in React 19. Use React.createContext() with React.useContext() instead. (https://react.dev/link/legacy-context)", componentName))));
+      prepareToReadContext(workInProgress);
+      markComponentRenderStarted(workInProgress);
+      Component = renderWithHooks(current, workInProgress, Component, nextProps, void 0, renderLanes);
+      markComponentRenderStopped();
+      if (null !== current && !didReceiveUpdate) return bailoutHooks(current, workInProgress, renderLanes), bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+      workInProgress.flags |= 1;
+      reconcileChildren(current, workInProgress, Component, renderLanes);
+      return workInProgress.child;
+    }
+    function replayFunctionComponent(current, workInProgress, nextProps, Component, secondArg, renderLanes) {
+      prepareToReadContext(workInProgress);
+      markComponentRenderStarted(workInProgress);
+      hookTypesUpdateIndexDev = -1;
+      ignorePreviousDependencies = null !== current && current.type !== workInProgress.type;
+      workInProgress.updateQueue = null;
+      nextProps = renderWithHooksAgain(workInProgress, Component, nextProps, secondArg);
+      finishRenderingHooks(current, workInProgress);
+      markComponentRenderStopped();
+      if (null !== current && !didReceiveUpdate) return bailoutHooks(current, workInProgress, renderLanes), bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+      workInProgress.flags |= 1;
+      reconcileChildren(current, workInProgress, nextProps, renderLanes);
+      return workInProgress.child;
+    }
+    function updateClassComponent(current, workInProgress, Component, nextProps, renderLanes) {
+      switch (shouldErrorImpl(workInProgress)) {
+        case !1:
+          var _instance = workInProgress.stateNode,
+            state = new workInProgress.type(workInProgress.memoizedProps, _instance.context).state;
+          _instance.updater.enqueueSetState(_instance, state, null);
+          break;
+        case !0:
+          workInProgress.flags |= 128;
+          workInProgress.flags |= 65536;
+          _instance = Error("Simulated error coming from DevTools");
+          var lane = renderLanes & -renderLanes;
+          workInProgress.lanes |= lane;
+          state = workInProgressRoot;
+          if (null === state) throw Error("Expected a work-in-progress root. This is a bug in React. Please file an issue.");
+          lane = createClassErrorUpdate(lane);
+          initializeClassErrorUpdate(lane, state, workInProgress, createCapturedValueAtFiber(_instance, workInProgress));
+          enqueueCapturedUpdate(workInProgress, lane);
+      }
+      prepareToReadContext(workInProgress);
+      if (null === workInProgress.stateNode) resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress), constructClassInstance(workInProgress, Component, nextProps), mountClassInstance(workInProgress, Component, nextProps, renderLanes), _instance = !0;else if (null === current) {
+        _instance = workInProgress.stateNode;
+        var unresolvedOldProps = workInProgress.memoizedProps;
+        lane = resolveClassComponentProps(Component, unresolvedOldProps);
+        _instance.props = lane;
+        var oldContext = _instance.context,
+          contextType = Component.contextType;
+        state = emptyContextObject;
+        "object" === typeof contextType && null !== contextType && (state = _readContext(contextType));
+        var getDerivedStateFromProps = Component.getDerivedStateFromProps;
+        contextType = "function" === typeof getDerivedStateFromProps || "function" === typeof _instance.getSnapshotBeforeUpdate;
+        unresolvedOldProps = workInProgress.pendingProps !== unresolvedOldProps;
+        contextType || "function" !== typeof _instance.UNSAFE_componentWillReceiveProps && "function" !== typeof _instance.componentWillReceiveProps || (unresolvedOldProps || oldContext !== state) && callComponentWillReceiveProps(workInProgress, _instance, nextProps, state);
+        hasForceUpdate = !1;
+        var oldState = workInProgress.memoizedState;
+        _instance.state = oldState;
+        processUpdateQueue(workInProgress, nextProps, _instance, renderLanes);
+        suspendIfUpdateReadFromEntangledAsyncAction();
+        oldContext = workInProgress.memoizedState;
+        unresolvedOldProps || oldState !== oldContext || hasForceUpdate ? ("function" === typeof getDerivedStateFromProps && (applyDerivedStateFromProps(workInProgress, Component, getDerivedStateFromProps, nextProps), oldContext = workInProgress.memoizedState), (lane = hasForceUpdate || checkShouldComponentUpdate(workInProgress, Component, lane, nextProps, oldState, oldContext, state)) ? (contextType || "function" !== typeof _instance.UNSAFE_componentWillMount && "function" !== typeof _instance.componentWillMount || ("function" === typeof _instance.componentWillMount && _instance.componentWillMount(), "function" === typeof _instance.UNSAFE_componentWillMount && _instance.UNSAFE_componentWillMount()), "function" === typeof _instance.componentDidMount && (workInProgress.flags |= 4194308), 0 !== (workInProgress.mode & 16) && (workInProgress.flags |= 134217728)) : ("function" === typeof _instance.componentDidMount && (workInProgress.flags |= 4194308), 0 !== (workInProgress.mode & 16) && (workInProgress.flags |= 134217728), workInProgress.memoizedProps = nextProps, workInProgress.memoizedState = oldContext), _instance.props = nextProps, _instance.state = oldContext, _instance.context = state, _instance = lane) : ("function" === typeof _instance.componentDidMount && (workInProgress.flags |= 4194308), 0 !== (workInProgress.mode & 16) && (workInProgress.flags |= 134217728), _instance = !1);
+      } else {
+        _instance = workInProgress.stateNode;
+        cloneUpdateQueue(current, workInProgress);
+        state = workInProgress.memoizedProps;
+        contextType = resolveClassComponentProps(Component, state);
+        _instance.props = contextType;
+        getDerivedStateFromProps = workInProgress.pendingProps;
+        oldState = _instance.context;
+        oldContext = Component.contextType;
+        lane = emptyContextObject;
+        "object" === typeof oldContext && null !== oldContext && (lane = _readContext(oldContext));
+        unresolvedOldProps = Component.getDerivedStateFromProps;
+        (oldContext = "function" === typeof unresolvedOldProps || "function" === typeof _instance.getSnapshotBeforeUpdate) || "function" !== typeof _instance.UNSAFE_componentWillReceiveProps && "function" !== typeof _instance.componentWillReceiveProps || (state !== getDerivedStateFromProps || oldState !== lane) && callComponentWillReceiveProps(workInProgress, _instance, nextProps, lane);
+        hasForceUpdate = !1;
+        oldState = workInProgress.memoizedState;
+        _instance.state = oldState;
+        processUpdateQueue(workInProgress, nextProps, _instance, renderLanes);
+        suspendIfUpdateReadFromEntangledAsyncAction();
+        var newState = workInProgress.memoizedState;
+        state !== getDerivedStateFromProps || oldState !== newState || hasForceUpdate || null !== current && null !== current.dependencies && checkIfContextChanged(current.dependencies) ? ("function" === typeof unresolvedOldProps && (applyDerivedStateFromProps(workInProgress, Component, unresolvedOldProps, nextProps), newState = workInProgress.memoizedState), (contextType = hasForceUpdate || checkShouldComponentUpdate(workInProgress, Component, contextType, nextProps, oldState, newState, lane) || null !== current && null !== current.dependencies && checkIfContextChanged(current.dependencies)) ? (oldContext || "function" !== typeof _instance.UNSAFE_componentWillUpdate && "function" !== typeof _instance.componentWillUpdate || ("function" === typeof _instance.componentWillUpdate && _instance.componentWillUpdate(nextProps, newState, lane), "function" === typeof _instance.UNSAFE_componentWillUpdate && _instance.UNSAFE_componentWillUpdate(nextProps, newState, lane)), "function" === typeof _instance.componentDidUpdate && (workInProgress.flags |= 4), "function" === typeof _instance.getSnapshotBeforeUpdate && (workInProgress.flags |= 1024)) : ("function" !== typeof _instance.componentDidUpdate || state === current.memoizedProps && oldState === current.memoizedState || (workInProgress.flags |= 4), "function" !== typeof _instance.getSnapshotBeforeUpdate || state === current.memoizedProps && oldState === current.memoizedState || (workInProgress.flags |= 1024), workInProgress.memoizedProps = nextProps, workInProgress.memoizedState = newState), _instance.props = nextProps, _instance.state = newState, _instance.context = lane, _instance = contextType) : ("function" !== typeof _instance.componentDidUpdate || state === current.memoizedProps && oldState === current.memoizedState || (workInProgress.flags |= 4), "function" !== typeof _instance.getSnapshotBeforeUpdate || state === current.memoizedProps && oldState === current.memoizedState || (workInProgress.flags |= 1024), _instance = !1);
+      }
+      current = finishClassComponent(current, workInProgress, Component, _instance, !1, renderLanes);
+      Component = workInProgress.stateNode;
+      _instance && Component.props !== nextProps && (didWarnAboutReassigningProps || console.error("It looks like %s is reassigning its own `this.props` while rendering. This is not supported and can lead to confusing bugs.", getComponentNameFromFiber(workInProgress) || "a component"), didWarnAboutReassigningProps = !0);
+      return current;
+    }
+    function finishClassComponent(current, workInProgress, Component, shouldUpdate, hasContext, renderLanes) {
+      markRef(current, workInProgress);
+      hasContext = 0 !== (workInProgress.flags & 128);
+      if (!shouldUpdate && !hasContext) return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+      shouldUpdate = workInProgress.stateNode;
+      setCurrentFiber(workInProgress);
+      if (hasContext && "function" !== typeof Component.getDerivedStateFromError) Component = null, profilerStartTime = -1;else {
+        markComponentRenderStarted(workInProgress);
+        Component = callRenderInDEV(shouldUpdate);
+        if (workInProgress.mode & 8) {
+          setIsStrictModeForDevtools(!0);
+          try {
+            callRenderInDEV(shouldUpdate);
+          } finally {
+            setIsStrictModeForDevtools(!1);
+          }
+        }
+        markComponentRenderStopped();
+      }
+      workInProgress.flags |= 1;
+      null !== current && hasContext ? (workInProgress.child = reconcileChildFibers(workInProgress, current.child, null, renderLanes), workInProgress.child = reconcileChildFibers(workInProgress, null, Component, renderLanes)) : reconcileChildren(current, workInProgress, Component, renderLanes);
+      workInProgress.memoizedState = shouldUpdate.state;
+      return workInProgress.child;
+    }
+    function validateFunctionComponentInDev(workInProgress, Component) {
+      Component && Component.childContextTypes && console.error("childContextTypes cannot be defined on a function component.\n  %s.childContextTypes = ...", Component.displayName || Component.name || "Component");
+      "function" === typeof Component.getDerivedStateFromProps && (workInProgress = getComponentNameFromType(Component) || "Unknown", didWarnAboutGetDerivedStateOnFunctionComponent[workInProgress] || (console.error("%s: Function components do not support getDerivedStateFromProps.", workInProgress), didWarnAboutGetDerivedStateOnFunctionComponent[workInProgress] = !0));
+      "object" === typeof Component.contextType && null !== Component.contextType && (Component = getComponentNameFromType(Component) || "Unknown", didWarnAboutContextTypeOnFunctionComponent[Component] || (console.error("%s: Function components do not support contextType.", Component), didWarnAboutContextTypeOnFunctionComponent[Component] = !0));
+    }
+    function mountSuspenseOffscreenState(renderLanes) {
+      return {
+        baseLanes: renderLanes,
+        cachePool: getSuspendedCache()
+      };
+    }
+    function getRemainingWorkInPrimaryTree(current, primaryTreeDidDefer, renderLanes) {
+      current = null !== current ? current.childLanes & ~renderLanes : 0;
+      primaryTreeDidDefer && (current |= workInProgressDeferredLane);
+      return current;
+    }
+    function updateSuspenseComponent(current, workInProgress, renderLanes) {
+      var nextProps = workInProgress.pendingProps;
+      shouldSuspendImpl(workInProgress) && (workInProgress.flags |= 128);
+      var showFallback = !1,
+        didSuspend = 0 !== (workInProgress.flags & 128),
+        JSCompiler_temp;
+      (JSCompiler_temp = didSuspend) || (JSCompiler_temp = null !== current && null === current.memoizedState ? !1 : 0 !== (suspenseStackCursor.current & ForceSuspenseFallback));
+      JSCompiler_temp && (showFallback = !0, workInProgress.flags &= -129);
+      JSCompiler_temp = 0 !== (workInProgress.flags & 32);
+      workInProgress.flags &= -33;
+      if (null === current) {
+        var nextPrimaryChildren = nextProps.children;
+        nextProps = nextProps.fallback;
+        if (showFallback) return reuseSuspenseHandlerOnStack(workInProgress), showFallback = workInProgress.mode, didSuspend = workInProgress.child, nextPrimaryChildren = {
+          mode: "hidden",
+          children: nextPrimaryChildren
+        }, 0 === (showFallback & 1) && null !== didSuspend ? (didSuspend.childLanes = 0, didSuspend.pendingProps = nextPrimaryChildren, workInProgress.mode & 2 && (didSuspend.actualDuration = -0, didSuspend.actualStartTime = -1.1, didSuspend.selfBaseDuration = -0, didSuspend.treeBaseDuration = -0)) : didSuspend = mountWorkInProgressOffscreenFiber(nextPrimaryChildren, showFallback), nextProps = createFiberFromFragment(nextProps, showFallback, renderLanes, null), didSuspend.return = workInProgress, nextProps.return = workInProgress, didSuspend.sibling = nextProps, workInProgress.child = didSuspend, nextPrimaryChildren = workInProgress.child, nextPrimaryChildren.memoizedState = mountSuspenseOffscreenState(renderLanes), nextPrimaryChildren.childLanes = getRemainingWorkInPrimaryTree(current, JSCompiler_temp, renderLanes), workInProgress.memoizedState = SUSPENDED_MARKER, nextProps;
+        pushPrimaryTreeSuspenseHandler(workInProgress);
+        return mountSuspensePrimaryChildren(workInProgress, nextPrimaryChildren);
+      }
+      nextPrimaryChildren = current.memoizedState;
+      if (null !== nextPrimaryChildren && null !== nextPrimaryChildren.dehydrated) {
+        if (didSuspend) workInProgress.flags & 256 ? (pushPrimaryTreeSuspenseHandler(workInProgress), workInProgress.flags &= -257, workInProgress = retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes)) : null !== workInProgress.memoizedState ? (reuseSuspenseHandlerOnStack(workInProgress), workInProgress.child = current.child, workInProgress.flags |= 128, workInProgress = null) : (reuseSuspenseHandlerOnStack(workInProgress), nextPrimaryChildren = nextProps.fallback, showFallback = workInProgress.mode, nextProps = mountWorkInProgressOffscreenFiber({
+          mode: "visible",
+          children: nextProps.children
+        }, showFallback), nextPrimaryChildren = createFiberFromFragment(nextPrimaryChildren, showFallback, renderLanes, null), nextPrimaryChildren.flags |= 2, nextProps.return = workInProgress, nextPrimaryChildren.return = workInProgress, nextProps.sibling = nextPrimaryChildren, workInProgress.child = nextProps, 0 !== (workInProgress.mode & 1) && reconcileChildFibers(workInProgress, current.child, null, renderLanes), nextProps = workInProgress.child, nextProps.memoizedState = mountSuspenseOffscreenState(renderLanes), nextProps.childLanes = getRemainingWorkInPrimaryTree(current, JSCompiler_temp, renderLanes), workInProgress.memoizedState = SUSPENDED_MARKER, workInProgress = nextPrimaryChildren);else if (pushPrimaryTreeSuspenseHandler(workInProgress), isSuspenseInstanceFallback()) showFallback = getSuspenseInstanceFallbackErrorDetails(), JSCompiler_temp = showFallback.digest, nextPrimaryChildren = showFallback.message, nextProps = showFallback.stack, showFallback = showFallback.componentStack, nextPrimaryChildren = nextPrimaryChildren ? Error(nextPrimaryChildren) : Error("The server could not finish this Suspense boundary, likely due to an error during server rendering. Switched to client rendering."), nextPrimaryChildren.stack = nextProps || "", nextPrimaryChildren.digest = JSCompiler_temp, JSCompiler_temp = void 0 === showFallback ? null : showFallback, nextProps = {
+          value: nextPrimaryChildren,
+          source: null,
+          stack: JSCompiler_temp
+        }, "string" === typeof JSCompiler_temp && CapturedStacks.set(nextPrimaryChildren, nextProps), null === hydrationErrors ? hydrationErrors = [nextProps] : hydrationErrors.push(nextProps), workInProgress = retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes);else if (didReceiveUpdate || propagateParentContextChanges(current, workInProgress, renderLanes, !1), JSCompiler_temp = 0 !== (renderLanes & current.childLanes), didReceiveUpdate || JSCompiler_temp) {
+          JSCompiler_temp = workInProgressRoot;
+          if (null !== JSCompiler_temp) {
+            nextProps = renderLanes & -renderLanes;
+            if (0 !== (nextProps & 42)) nextProps = 1;else switch (nextProps) {
+              case 2:
+                nextProps = 1;
+                break;
+              case 8:
+                nextProps = 4;
+                break;
+              case 32:
+                nextProps = 16;
+                break;
+              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:
+                nextProps = 128;
+                break;
+              case 268435456:
+                nextProps = 134217728;
+                break;
+              default:
+                nextProps = 0;
+            }
+            nextProps = 0 !== (nextProps & (JSCompiler_temp.suspendedLanes | renderLanes)) ? 0 : nextProps;
+            if (0 !== nextProps && nextProps !== nextPrimaryChildren.retryLane) throw nextPrimaryChildren.retryLane = nextProps, enqueueConcurrentRenderForLane(current, nextProps), scheduleUpdateOnFiber(JSCompiler_temp, current, nextProps), SelectiveHydrationException;
+          }
+          isSuspenseInstancePending() || renderDidSuspendDelayIfPossible();
+          workInProgress = retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes);
+        } else isSuspenseInstancePending() ? (workInProgress.flags |= 192, workInProgress.child = current.child, workInProgress = null) : (workInProgress = mountSuspensePrimaryChildren(workInProgress, nextProps.children), workInProgress.flags |= 4096);
+        return workInProgress;
+      }
+      if (showFallback) {
+        reuseSuspenseHandlerOnStack(workInProgress);
+        nextPrimaryChildren = nextProps.fallback;
+        showFallback = workInProgress.mode;
+        didSuspend = current.child;
+        var currentFallbackChildFragment = didSuspend.sibling,
+          primaryChildProps = {
+            mode: "hidden",
+            children: nextProps.children
+          };
+        0 === (showFallback & 1) && workInProgress.child !== didSuspend ? (nextProps = workInProgress.child, nextProps.childLanes = 0, nextProps.pendingProps = primaryChildProps, workInProgress.mode & 2 && (nextProps.actualDuration = -0, nextProps.actualStartTime = -1.1, nextProps.selfBaseDuration = didSuspend.selfBaseDuration, nextProps.treeBaseDuration = didSuspend.treeBaseDuration), workInProgress.deletions = null) : (nextProps = createWorkInProgress(didSuspend, primaryChildProps), nextProps.subtreeFlags = didSuspend.subtreeFlags & 65011712);
+        null !== currentFallbackChildFragment ? nextPrimaryChildren = createWorkInProgress(currentFallbackChildFragment, nextPrimaryChildren) : (nextPrimaryChildren = createFiberFromFragment(nextPrimaryChildren, showFallback, renderLanes, null), nextPrimaryChildren.flags |= 2);
+        nextPrimaryChildren.return = workInProgress;
+        nextProps.return = workInProgress;
+        nextProps.sibling = nextPrimaryChildren;
+        workInProgress.child = nextProps;
+        nextProps = nextPrimaryChildren;
+        nextPrimaryChildren = workInProgress.child;
+        showFallback = current.child.memoizedState;
+        null === showFallback ? showFallback = mountSuspenseOffscreenState(renderLanes) : (didSuspend = showFallback.cachePool, null !== didSuspend ? (currentFallbackChildFragment = CacheContext._currentValue2, didSuspend = didSuspend.parent !== currentFallbackChildFragment ? {
+          parent: currentFallbackChildFragment,
+          pool: currentFallbackChildFragment
+        } : didSuspend) : didSuspend = getSuspendedCache(), showFallback = {
+          baseLanes: showFallback.baseLanes | renderLanes,
+          cachePool: didSuspend
+        });
+        nextPrimaryChildren.memoizedState = showFallback;
+        nextPrimaryChildren.childLanes = getRemainingWorkInPrimaryTree(current, JSCompiler_temp, renderLanes);
+        workInProgress.memoizedState = SUSPENDED_MARKER;
+        return nextProps;
+      }
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      JSCompiler_temp = current.child;
+      current = JSCompiler_temp.sibling;
+      JSCompiler_temp = createWorkInProgress(JSCompiler_temp, {
+        mode: "visible",
+        children: nextProps.children
+      });
+      0 === (workInProgress.mode & 1) && (JSCompiler_temp.lanes = renderLanes);
+      JSCompiler_temp.return = workInProgress;
+      JSCompiler_temp.sibling = null;
+      null !== current && (renderLanes = workInProgress.deletions, null === renderLanes ? (workInProgress.deletions = [current], workInProgress.flags |= 16) : renderLanes.push(current));
+      workInProgress.child = JSCompiler_temp;
+      workInProgress.memoizedState = null;
+      return JSCompiler_temp;
+    }
+    function mountSuspensePrimaryChildren(workInProgress, primaryChildren) {
+      primaryChildren = mountWorkInProgressOffscreenFiber({
+        mode: "visible",
+        children: primaryChildren
+      }, workInProgress.mode);
+      primaryChildren.return = workInProgress;
+      return workInProgress.child = primaryChildren;
+    }
+    function mountWorkInProgressOffscreenFiber(offscreenProps, mode) {
+      offscreenProps = createFiber(22, offscreenProps, null, mode);
+      offscreenProps.lanes = 0;
+      offscreenProps.stateNode = {
+        _visibility: 1,
+        _pendingMarkers: null,
+        _retryCache: null,
+        _transitions: null
+      };
+      return offscreenProps;
+    }
+    function retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes) {
+      reconcileChildFibers(workInProgress, current.child, null, renderLanes);
+      current = mountSuspensePrimaryChildren(workInProgress, workInProgress.pendingProps.children);
+      current.flags |= 2;
+      workInProgress.memoizedState = null;
+      return current;
+    }
+    function scheduleSuspenseWorkOnFiber(fiber, renderLanes, propagationRoot) {
+      fiber.lanes |= renderLanes;
+      var alternate = fiber.alternate;
+      null !== alternate && (alternate.lanes |= renderLanes);
+      scheduleContextWorkOnParentPath(fiber.return, renderLanes, propagationRoot);
+    }
+    function validateSuspenseListNestedChild(childSlot, index) {
+      var isAnArray = isArrayImpl(childSlot);
+      childSlot = !isAnArray && "function" === typeof getIteratorFn(childSlot);
+      return isAnArray || childSlot ? (isAnArray = isAnArray ? "array" : "iterable", console.error("A nested %s was passed to row #%s in <SuspenseList />. Wrap it in an additional SuspenseList to configure its revealOrder: <SuspenseList revealOrder=...> ... <SuspenseList revealOrder=...>{%s}</SuspenseList> ... </SuspenseList>", isAnArray, index, isAnArray), !1) : !0;
+    }
+    function initSuspenseListRenderState(workInProgress, isBackwards, tail, lastContentRow, tailMode) {
+      var renderState = workInProgress.memoizedState;
+      null === renderState ? workInProgress.memoizedState = {
+        isBackwards: isBackwards,
+        rendering: null,
+        renderingStartTime: 0,
+        last: lastContentRow,
+        tail: tail,
+        tailMode: tailMode
+      } : (renderState.isBackwards = isBackwards, renderState.rendering = null, renderState.renderingStartTime = 0, renderState.last = lastContentRow, renderState.tail = tail, renderState.tailMode = tailMode);
+    }
+    function updateSuspenseListComponent(current, workInProgress, renderLanes) {
+      var nextProps = workInProgress.pendingProps,
+        revealOrder = nextProps.revealOrder,
+        tailMode = nextProps.tail;
+      nextProps = nextProps.children;
+      if (void 0 !== revealOrder && "forwards" !== revealOrder && "backwards" !== revealOrder && "together" !== revealOrder && !didWarnAboutRevealOrder[revealOrder]) if (didWarnAboutRevealOrder[revealOrder] = !0, "string" === typeof revealOrder) switch (revealOrder.toLowerCase()) {
+        case "together":
+        case "forwards":
+        case "backwards":
+          console.error('"%s" is not a valid value for revealOrder on <SuspenseList />. Use lowercase "%s" instead.', revealOrder, revealOrder.toLowerCase());
+          break;
+        case "forward":
+        case "backward":
+          console.error('"%s" is not a valid value for revealOrder on <SuspenseList />. React uses the -s suffix in the spelling. Use "%ss" instead.', revealOrder, revealOrder.toLowerCase());
+          break;
+        default:
+          console.error('"%s" is not a supported revealOrder on <SuspenseList />. Did you mean "together", "forwards" or "backwards"?', revealOrder);
+      } else console.error('%s is not a supported value for revealOrder on <SuspenseList />. Did you mean "together", "forwards" or "backwards"?', revealOrder);
+      void 0 === tailMode || didWarnAboutTailOptions[tailMode] || ("collapsed" !== tailMode && "hidden" !== tailMode ? (didWarnAboutTailOptions[tailMode] = !0, console.error('"%s" is not a supported value for tail on <SuspenseList />. Did you mean "collapsed" or "hidden"?', tailMode)) : "forwards" !== revealOrder && "backwards" !== revealOrder && (didWarnAboutTailOptions[tailMode] = !0, console.error('<SuspenseList tail="%s" /> is only valid if revealOrder is "forwards" or "backwards". Did you mean to specify revealOrder="forwards"?', tailMode)));
+      a: if (("forwards" === revealOrder || "backwards" === revealOrder) && void 0 !== nextProps && null !== nextProps && !1 !== nextProps) if (isArrayImpl(nextProps)) for (var i = 0; i < nextProps.length; i++) {
+        if (!validateSuspenseListNestedChild(nextProps[i], i)) break a;
+      } else if (i = getIteratorFn(nextProps), "function" === typeof i) {
+        if (i = i.call(nextProps)) for (var step = i.next(), _i = 0; !step.done; step = i.next()) {
+          if (!validateSuspenseListNestedChild(step.value, _i)) break a;
+          _i++;
+        }
+      } else console.error('A single row was passed to a <SuspenseList revealOrder="%s" />. This is not useful since it needs multiple rows. Did you mean to pass multiple children or an array?', revealOrder);
+      reconcileChildren(current, workInProgress, nextProps, renderLanes);
+      nextProps = suspenseStackCursor.current;
+      if (0 !== (nextProps & ForceSuspenseFallback)) nextProps = nextProps & SubtreeSuspenseContextMask | ForceSuspenseFallback, workInProgress.flags |= 128;else {
+        if (null !== current && 0 !== (current.flags & 128)) a: for (current = workInProgress.child; null !== current;) {
+          if (13 === current.tag) null !== current.memoizedState && scheduleSuspenseWorkOnFiber(current, renderLanes, workInProgress);else if (19 === current.tag) scheduleSuspenseWorkOnFiber(current, renderLanes, workInProgress);else if (null !== current.child) {
+            current.child.return = current;
+            current = current.child;
+            continue;
+          }
+          if (current === workInProgress) break a;
+          for (; null === current.sibling;) {
+            if (null === current.return || current.return === workInProgress) break a;
+            current = current.return;
+          }
+          current.sibling.return = current.return;
+          current = current.sibling;
+        }
+        nextProps &= SubtreeSuspenseContextMask;
+      }
+      push(suspenseStackCursor, nextProps, workInProgress);
+      if (0 === (workInProgress.mode & 1)) workInProgress.memoizedState = null;else switch (revealOrder) {
+        case "forwards":
+          renderLanes = workInProgress.child;
+          for (revealOrder = null; null !== renderLanes;) current = renderLanes.alternate, null !== current && null === findFirstSuspended(current) && (revealOrder = renderLanes), renderLanes = renderLanes.sibling;
+          renderLanes = revealOrder;
+          null === renderLanes ? (revealOrder = workInProgress.child, workInProgress.child = null) : (revealOrder = renderLanes.sibling, renderLanes.sibling = null);
+          initSuspenseListRenderState(workInProgress, !1, revealOrder, renderLanes, tailMode);
+          break;
+        case "backwards":
+          renderLanes = null;
+          revealOrder = workInProgress.child;
+          for (workInProgress.child = null; null !== revealOrder;) {
+            current = revealOrder.alternate;
+            if (null !== current && null === findFirstSuspended(current)) {
+              workInProgress.child = revealOrder;
+              break;
+            }
+            current = revealOrder.sibling;
+            revealOrder.sibling = renderLanes;
+            renderLanes = revealOrder;
+            revealOrder = current;
+          }
+          initSuspenseListRenderState(workInProgress, !0, renderLanes, null, tailMode);
+          break;
+        case "together":
+          initSuspenseListRenderState(workInProgress, !1, null, null, void 0);
+          break;
+        default:
+          workInProgress.memoizedState = null;
+      }
+      return workInProgress.child;
+    }
+    function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
+      0 === (workInProgress.mode & 1) && null !== current && (current.alternate = null, workInProgress.alternate = null, workInProgress.flags |= 2);
+    }
+    function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
+      null !== current && (workInProgress.dependencies = current.dependencies);
+      profilerStartTime = -1;
+      workInProgressRootSkippedLanes |= workInProgress.lanes;
+      if (0 === (renderLanes & workInProgress.childLanes)) if (null !== current) {
+        if (propagateParentContextChanges(current, workInProgress, renderLanes, !1), 0 === (renderLanes & workInProgress.childLanes)) return null;
+      } else return null;
+      if (null !== current && workInProgress.child !== current.child) throw Error("Resuming work not yet implemented.");
+      if (null !== workInProgress.child) {
+        current = workInProgress.child;
+        renderLanes = createWorkInProgress(current, current.pendingProps);
+        workInProgress.child = renderLanes;
+        for (renderLanes.return = workInProgress; null !== current.sibling;) current = current.sibling, renderLanes = renderLanes.sibling = createWorkInProgress(current, current.pendingProps), renderLanes.return = workInProgress;
+        renderLanes.sibling = null;
+      }
+      return workInProgress.child;
+    }
+    function checkScheduledUpdateOrContext(current, renderLanes) {
+      if (0 !== (current.lanes & renderLanes)) return !0;
+      current = current.dependencies;
+      return null !== current && checkIfContextChanged(current) ? !0 : !1;
+    }
+    function attemptEarlyBailoutIfNoScheduledUpdate(current, workInProgress, renderLanes) {
+      switch (workInProgress.tag) {
+        case 3:
+          pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+          pushProvider(workInProgress, CacheContext, current.memoizedState.cache);
+          break;
+        case 27:
+        case 5:
+          pushHostContext(workInProgress);
+          break;
+        case 4:
+          pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+          break;
+        case 10:
+          pushProvider(workInProgress, workInProgress.type, workInProgress.memoizedProps.value);
+          break;
+        case 12:
+          0 !== (renderLanes & workInProgress.childLanes) && (workInProgress.flags |= 4);
+          workInProgress.flags |= 2048;
+          var stateNode = workInProgress.stateNode;
+          stateNode.effectDuration = -0;
+          stateNode.passiveEffectDuration = -0;
+          break;
+        case 13:
+          stateNode = workInProgress.memoizedState;
+          if (null !== stateNode) {
+            if (null !== stateNode.dehydrated) return pushPrimaryTreeSuspenseHandler(workInProgress), workInProgress.flags |= 128, null;
+            if (0 !== (renderLanes & workInProgress.child.childLanes)) return updateSuspenseComponent(current, workInProgress, renderLanes);
+            pushPrimaryTreeSuspenseHandler(workInProgress);
+            current = bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+            return null !== current ? current.sibling : null;
+          }
+          pushPrimaryTreeSuspenseHandler(workInProgress);
+          break;
+        case 19:
+          var didSuspendBefore = 0 !== (current.flags & 128);
+          stateNode = 0 !== (renderLanes & workInProgress.childLanes);
+          stateNode || (propagateParentContextChanges(current, workInProgress, renderLanes, !1), stateNode = 0 !== (renderLanes & workInProgress.childLanes));
+          if (didSuspendBefore) {
+            if (stateNode) return updateSuspenseListComponent(current, workInProgress, renderLanes);
+            workInProgress.flags |= 128;
+          }
+          didSuspendBefore = workInProgress.memoizedState;
+          null !== didSuspendBefore && (didSuspendBefore.rendering = null, didSuspendBefore.tail = null, didSuspendBefore.lastEffect = null);
+          push(suspenseStackCursor, suspenseStackCursor.current, workInProgress);
+          if (stateNode) break;else return null;
+        case 22:
+        case 23:
+          return workInProgress.lanes = 0, updateOffscreenComponent(current, workInProgress, renderLanes);
+        case 24:
+          pushProvider(workInProgress, CacheContext, current.memoizedState.cache);
+      }
+      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    }
+    function beginWork(current, workInProgress, renderLanes) {
+      if (workInProgress._debugNeedsRemount && null !== current) {
+        renderLanes = createFiberFromTypeAndProps(workInProgress.type, workInProgress.key, workInProgress.pendingProps, workInProgress._debugOwner || null, workInProgress.mode, workInProgress.lanes);
+        renderLanes._debugStack = workInProgress._debugStack;
+        renderLanes._debugTask = workInProgress._debugTask;
+        var returnFiber = workInProgress.return;
+        if (null === returnFiber) throw Error("Cannot swap the root fiber.");
+        current.alternate = null;
+        workInProgress.alternate = null;
+        renderLanes.index = workInProgress.index;
+        renderLanes.sibling = workInProgress.sibling;
+        renderLanes.return = workInProgress.return;
+        renderLanes.ref = workInProgress.ref;
+        renderLanes._debugInfo = workInProgress._debugInfo;
+        if (workInProgress === returnFiber.child) returnFiber.child = renderLanes;else {
+          var prevSibling = returnFiber.child;
+          if (null === prevSibling) throw Error("Expected parent to have a child.");
+          for (; prevSibling.sibling !== workInProgress;) if (prevSibling = prevSibling.sibling, null === prevSibling) throw Error("Expected to find the previous sibling.");
+          prevSibling.sibling = renderLanes;
+        }
+        workInProgress = returnFiber.deletions;
+        null === workInProgress ? (returnFiber.deletions = [current], returnFiber.flags |= 16) : workInProgress.push(current);
+        renderLanes.flags |= 2;
+        return renderLanes;
+      }
+      if (null !== current) {
+        if (current.memoizedProps !== workInProgress.pendingProps || workInProgress.type !== current.type) didReceiveUpdate = !0;else {
+          if (!checkScheduledUpdateOrContext(current, renderLanes) && 0 === (workInProgress.flags & 128)) return didReceiveUpdate = !1, attemptEarlyBailoutIfNoScheduledUpdate(current, workInProgress, renderLanes);
+          didReceiveUpdate = 0 !== (current.flags & 131072) ? !0 : !1;
+        }
+      } else didReceiveUpdate = !1;
+      workInProgress.lanes = 0;
+      switch (workInProgress.tag) {
+        case 16:
+          a: if (prevSibling = workInProgress.elementType, resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress), returnFiber = workInProgress.pendingProps, current = callLazyInitInDEV(prevSibling), workInProgress.type = current, "function" === typeof current) shouldConstruct(current) ? (returnFiber = resolveClassComponentProps(current, returnFiber), workInProgress.tag = 1, workInProgress.type = current = resolveFunctionForHotReloading(current), workInProgress = updateClassComponent(null, workInProgress, current, returnFiber, renderLanes)) : (workInProgress.tag = 0, validateFunctionComponentInDev(workInProgress, current), workInProgress.type = current = resolveFunctionForHotReloading(current), workInProgress = updateFunctionComponent(null, workInProgress, current, returnFiber, renderLanes));else {
+            if (void 0 !== current && null !== current) if (prevSibling = current.$$typeof, prevSibling === REACT_FORWARD_REF_TYPE) {
+              workInProgress.tag = 11;
+              workInProgress.type = current = resolveForwardRefForHotReloading(current);
+              workInProgress = updateForwardRef(null, workInProgress, current, returnFiber, renderLanes);
+              break a;
+            } else if (prevSibling === REACT_MEMO_TYPE) {
+              workInProgress.tag = 14;
+              workInProgress = updateMemoComponent(null, workInProgress, current, returnFiber, renderLanes);
+              break a;
+            }
+            workInProgress = "";
+            null !== current && "object" === typeof current && current.$$typeof === REACT_LAZY_TYPE && (workInProgress = " Did you wrap a component in React.lazy() more than once?");
+            current = getComponentNameFromType(current) || current;
+            throw Error("Element type is invalid. Received a promise that resolves to: " + current + ". Lazy element type must resolve to a class or function." + workInProgress);
+          }
+          return workInProgress;
+        case 0:
+          return updateFunctionComponent(current, workInProgress, workInProgress.type, workInProgress.pendingProps, renderLanes);
+        case 1:
+          return returnFiber = workInProgress.type, prevSibling = resolveClassComponentProps(returnFiber, workInProgress.pendingProps), updateClassComponent(current, workInProgress, returnFiber, prevSibling, renderLanes);
+        case 3:
+          pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+          if (null === current) throw Error("Should have a current fiber. This is a bug in React.");
+          var nextProps = workInProgress.pendingProps;
+          prevSibling = workInProgress.memoizedState;
+          returnFiber = prevSibling.element;
+          cloneUpdateQueue(current, workInProgress);
+          processUpdateQueue(workInProgress, nextProps, null, renderLanes);
+          nextProps = workInProgress.memoizedState;
+          var nextCache = nextProps.cache;
+          pushProvider(workInProgress, CacheContext, nextCache);
+          nextCache !== prevSibling.cache && propagateContextChanges(workInProgress, [CacheContext], renderLanes, !0);
+          suspendIfUpdateReadFromEntangledAsyncAction();
+          prevSibling = nextProps.element;
+          prevSibling === returnFiber ? workInProgress = bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) : (reconcileChildren(current, workInProgress, prevSibling, renderLanes), workInProgress = workInProgress.child);
+          return workInProgress;
+        case 26:
+        case 27:
+        case 5:
+          return pushHostContext(workInProgress), returnFiber = workInProgress.pendingProps.children, null !== workInProgress.memoizedState && (prevSibling = renderWithHooks(current, workInProgress, TransitionAwareHostComponent, null, null, renderLanes), HostTransitionContext._currentValue2 = prevSibling), markRef(current, workInProgress), reconcileChildren(current, workInProgress, returnFiber, renderLanes), workInProgress.child;
+        case 6:
+          return null;
+        case 13:
+          return updateSuspenseComponent(current, workInProgress, renderLanes);
+        case 4:
+          return pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo), returnFiber = workInProgress.pendingProps, null === current ? workInProgress.child = reconcileChildFibers(workInProgress, null, returnFiber, renderLanes) : reconcileChildren(current, workInProgress, returnFiber, renderLanes), workInProgress.child;
+        case 11:
+          return updateForwardRef(current, workInProgress, workInProgress.type, workInProgress.pendingProps, renderLanes);
+        case 7:
+          return reconcileChildren(current, workInProgress, workInProgress.pendingProps, renderLanes), workInProgress.child;
+        case 8:
+          return reconcileChildren(current, workInProgress, workInProgress.pendingProps.children, renderLanes), workInProgress.child;
+        case 12:
+          return workInProgress.flags |= 4, workInProgress.flags |= 2048, returnFiber = workInProgress.stateNode, returnFiber.effectDuration = -0, returnFiber.passiveEffectDuration = -0, reconcileChildren(current, workInProgress, workInProgress.pendingProps.children, renderLanes), workInProgress.child;
+        case 10:
+          return returnFiber = workInProgress.type, prevSibling = workInProgress.pendingProps, nextProps = prevSibling.value, "value" in prevSibling || hasWarnedAboutUsingNoValuePropOnContextProvider || (hasWarnedAboutUsingNoValuePropOnContextProvider = !0, console.error("The `value` prop is required for the `<Context.Provider>`. Did you misspell it or forget to pass it?")), pushProvider(workInProgress, returnFiber, nextProps), reconcileChildren(current, workInProgress, prevSibling.children, renderLanes), workInProgress.child;
+        case 9:
+          return prevSibling = workInProgress.type._context, returnFiber = workInProgress.pendingProps.children, "function" !== typeof returnFiber && console.error("A context consumer was rendered with multiple children, or a child that isn't a function. A context consumer expects a single child that is a function. If you did pass a function, make sure there is no trailing or leading whitespace around it."), prepareToReadContext(workInProgress), prevSibling = _readContext(prevSibling), markComponentRenderStarted(workInProgress), returnFiber = callComponentInDEV(returnFiber, prevSibling, void 0), markComponentRenderStopped(), workInProgress.flags |= 1, reconcileChildren(current, workInProgress, returnFiber, renderLanes), workInProgress.child;
+        case 14:
+          return updateMemoComponent(current, workInProgress, workInProgress.type, workInProgress.pendingProps, renderLanes);
+        case 15:
+          return updateSimpleMemoComponent(current, workInProgress, workInProgress.type, workInProgress.pendingProps, renderLanes);
+        case 17:
+          return returnFiber = workInProgress.type, prevSibling = resolveClassComponentProps(returnFiber, workInProgress.pendingProps), resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress), workInProgress.tag = 1, prepareToReadContext(workInProgress), constructClassInstance(workInProgress, returnFiber, prevSibling), mountClassInstance(workInProgress, returnFiber, prevSibling, renderLanes), finishClassComponent(null, workInProgress, returnFiber, !0, !1, renderLanes);
+        case 28:
+          return returnFiber = workInProgress.type, prevSibling = resolveClassComponentProps(returnFiber, workInProgress.pendingProps), resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress), workInProgress.tag = 0, updateFunctionComponent(null, workInProgress, returnFiber, prevSibling, renderLanes);
+        case 19:
+          return updateSuspenseListComponent(current, workInProgress, renderLanes);
+        case 31:
+          return returnFiber = workInProgress.pendingProps, renderLanes = workInProgress.mode, returnFiber = {
+            mode: returnFiber.mode,
+            children: returnFiber.children
+          }, null === current ? (current = mountWorkInProgressOffscreenFiber(returnFiber, renderLanes), current.ref = workInProgress.ref, workInProgress.child = current, current.return = workInProgress, workInProgress = current) : (current = createWorkInProgress(current.child, returnFiber), current.ref = workInProgress.ref, workInProgress.child = current, current.return = workInProgress, workInProgress = current), workInProgress;
+        case 22:
+          return updateOffscreenComponent(current, workInProgress, renderLanes);
+        case 24:
+          return prepareToReadContext(workInProgress), returnFiber = _readContext(CacheContext), null === current ? (prevSibling = peekCacheFromPool(), null === prevSibling && (prevSibling = workInProgressRoot, nextProps = createCache(), prevSibling.pooledCache = nextProps, retainCache(nextProps), null !== nextProps && (prevSibling.pooledCacheLanes |= renderLanes), prevSibling = nextProps), workInProgress.memoizedState = {
+            parent: returnFiber,
+            cache: prevSibling
+          }, initializeUpdateQueue(workInProgress), pushProvider(workInProgress, CacheContext, prevSibling)) : (0 !== (current.lanes & renderLanes) && (cloneUpdateQueue(current, workInProgress), processUpdateQueue(workInProgress, null, null, renderLanes), suspendIfUpdateReadFromEntangledAsyncAction()), prevSibling = current.memoizedState, nextProps = workInProgress.memoizedState, prevSibling.parent !== returnFiber ? (prevSibling = {
+            parent: returnFiber,
+            cache: returnFiber
+          }, workInProgress.memoizedState = prevSibling, 0 === workInProgress.lanes && (workInProgress.memoizedState = workInProgress.updateQueue.baseState = prevSibling), pushProvider(workInProgress, CacheContext, returnFiber)) : (returnFiber = nextProps.cache, pushProvider(workInProgress, CacheContext, returnFiber), returnFiber !== prevSibling.cache && propagateContextChanges(workInProgress, [CacheContext], renderLanes, !0))), reconcileChildren(current, workInProgress, workInProgress.pendingProps.children, renderLanes), workInProgress.child;
+        case 29:
+          throw workInProgress.pendingProps;
+      }
+      throw Error("Unknown unit of work tag (" + workInProgress.tag + "). This error is likely caused by a bug in React. Please file an issue.");
+    }
+    function doesRequireClone(current, completedWork) {
+      if (null !== current && current.child === completedWork.child) return !1;
+      if (0 !== (completedWork.flags & 16)) return !0;
+      for (current = completedWork.child; null !== current;) {
+        if (0 !== (current.flags & 13878) || 0 !== (current.subtreeFlags & 13878)) return !0;
+        current = current.sibling;
+      }
+      return !1;
+    }
+    function appendAllChildren(parent, workInProgress, needsVisibilityToggle, isHidden) {
+      for (var _node = workInProgress.child; null !== _node;) {
+        if (5 === _node.tag) {
+          var instance = _node.stateNode;
+          needsVisibilityToggle && isHidden && (instance = cloneHiddenInstance(instance));
+          appendChildNode(parent.node, instance.node);
+        } else if (6 === _node.tag) {
+          instance = _node.stateNode;
+          if (needsVisibilityToggle && isHidden) throw Error("Not yet implemented.");
+          appendChildNode(parent.node, instance.node);
+        } else if (4 !== _node.tag) if (22 === _node.tag && null !== _node.memoizedState) instance = _node.child, null !== instance && (instance.return = _node), appendAllChildren(parent, _node, !0, !0);else if (null !== _node.child) {
+          _node.child.return = _node;
+          _node = _node.child;
+          continue;
+        }
+        if (_node === workInProgress) break;
+        for (; null === _node.sibling;) {
+          if (null === _node.return || _node.return === workInProgress) return;
+          _node = _node.return;
+        }
+        _node.sibling.return = _node.return;
+        _node = _node.sibling;
+      }
+    }
+    function appendAllChildrenToContainer(containerChildSet, workInProgress, needsVisibilityToggle, isHidden) {
+      for (var hasOffscreenComponentChild = !1, node = workInProgress.child; null !== node;) {
+        if (5 === node.tag) {
+          var instance = node.stateNode;
+          needsVisibilityToggle && isHidden && (instance = cloneHiddenInstance(instance));
+          appendChildNodeToSet(containerChildSet, instance.node);
+        } else if (6 === node.tag) {
+          instance = node.stateNode;
+          if (needsVisibilityToggle && isHidden) throw Error("Not yet implemented.");
+          appendChildNodeToSet(containerChildSet, instance.node);
+        } else if (4 !== node.tag) if (22 === node.tag && null !== node.memoizedState) hasOffscreenComponentChild = node.child, null !== hasOffscreenComponentChild && (hasOffscreenComponentChild.return = node), appendAllChildrenToContainer(containerChildSet, node, !0, !0), hasOffscreenComponentChild = !0;else if (null !== node.child) {
+          node.child.return = node;
+          node = node.child;
+          continue;
+        }
+        if (node === workInProgress) break;
+        for (; null === node.sibling;) {
+          if (null === node.return || node.return === workInProgress) return hasOffscreenComponentChild;
+          node = node.return;
+        }
+        node.sibling.return = node.return;
+        node = node.sibling;
+      }
+      return hasOffscreenComponentChild;
+    }
+    function updateHostContainer(current, workInProgress) {
+      if (doesRequireClone(current, workInProgress)) {
+        current = workInProgress.stateNode;
+        var container = current.containerInfo,
+          newChildSet = createChildNodeSet();
+        appendAllChildrenToContainer(newChildSet, workInProgress, !1, !1);
+        current.pendingChildren = newChildSet;
+        workInProgress.flags |= 4;
+        completeRoot(container.containerTag, newChildSet);
+      }
+    }
+    function scheduleRetryEffect(workInProgress, retryQueue) {
+      null !== retryQueue && (workInProgress.flags |= 4);
+      workInProgress.flags & 16384 && (retryQueue = 22 !== workInProgress.tag ? claimNextRetryLane() : 536870912, workInProgress.lanes |= retryQueue, workInProgressSuspendedRetryLanes |= retryQueue);
+    }
+    function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
+      switch (renderState.tailMode) {
+        case "hidden":
+          hasRenderedATailFallback = renderState.tail;
+          for (var lastTailNode = null; null !== hasRenderedATailFallback;) null !== hasRenderedATailFallback.alternate && (lastTailNode = hasRenderedATailFallback), hasRenderedATailFallback = hasRenderedATailFallback.sibling;
+          null === lastTailNode ? renderState.tail = null : lastTailNode.sibling = null;
+          break;
+        case "collapsed":
+          lastTailNode = renderState.tail;
+          for (var _lastTailNode = null; null !== lastTailNode;) null !== lastTailNode.alternate && (_lastTailNode = lastTailNode), lastTailNode = lastTailNode.sibling;
+          null === _lastTailNode ? hasRenderedATailFallback || null === renderState.tail ? renderState.tail = null : renderState.tail.sibling = null : _lastTailNode.sibling = null;
+      }
+    }
+    function bubbleProperties(completedWork) {
+      var didBailout = null !== completedWork.alternate && completedWork.alternate.child === completedWork.child,
+        newChildLanes = 0,
+        subtreeFlags = 0;
+      if (didBailout) {
+        if (0 !== (completedWork.mode & 2)) {
+          for (var _treeBaseDuration = completedWork.selfBaseDuration, _child2 = completedWork.child; null !== _child2;) newChildLanes |= _child2.lanes | _child2.childLanes, subtreeFlags |= _child2.subtreeFlags & 65011712, subtreeFlags |= _child2.flags & 65011712, _treeBaseDuration += _child2.treeBaseDuration, _child2 = _child2.sibling;
+          completedWork.treeBaseDuration = _treeBaseDuration;
+        } else for (_treeBaseDuration = completedWork.child; null !== _treeBaseDuration;) newChildLanes |= _treeBaseDuration.lanes | _treeBaseDuration.childLanes, subtreeFlags |= _treeBaseDuration.subtreeFlags & 65011712, subtreeFlags |= _treeBaseDuration.flags & 65011712, _treeBaseDuration.return = completedWork, _treeBaseDuration = _treeBaseDuration.sibling;
+      } else if (0 !== (completedWork.mode & 2)) {
+        _treeBaseDuration = completedWork.actualDuration;
+        _child2 = completedWork.selfBaseDuration;
+        for (var child = completedWork.child; null !== child;) newChildLanes |= child.lanes | child.childLanes, subtreeFlags |= child.subtreeFlags, subtreeFlags |= child.flags, _treeBaseDuration += child.actualDuration, _child2 += child.treeBaseDuration, child = child.sibling;
+        completedWork.actualDuration = _treeBaseDuration;
+        completedWork.treeBaseDuration = _child2;
+      } else for (_treeBaseDuration = completedWork.child; null !== _treeBaseDuration;) newChildLanes |= _treeBaseDuration.lanes | _treeBaseDuration.childLanes, subtreeFlags |= _treeBaseDuration.subtreeFlags, subtreeFlags |= _treeBaseDuration.flags, _treeBaseDuration.return = completedWork, _treeBaseDuration = _treeBaseDuration.sibling;
+      completedWork.subtreeFlags |= subtreeFlags;
+      completedWork.childLanes = newChildLanes;
+      return didBailout;
+    }
+    function completeWork(current, workInProgress, renderLanes) {
+      var newProps = workInProgress.pendingProps;
+      switch (workInProgress.tag) {
+        case 28:
+        case 31:
+        case 16:
+        case 15:
+        case 0:
+        case 11:
+        case 7:
+        case 8:
+        case 12:
+        case 9:
+        case 14:
+          return bubbleProperties(workInProgress), null;
+        case 1:
+          return bubbleProperties(workInProgress), null;
+        case 3:
+          return newProps = workInProgress.stateNode, renderLanes = null, null !== current && (renderLanes = current.memoizedState.cache), workInProgress.memoizedState.cache !== renderLanes && (workInProgress.flags |= 2048), popProvider(CacheContext, workInProgress), popHostContainer(workInProgress), newProps.pendingContext && (newProps.context = newProps.pendingContext, newProps.pendingContext = null), null !== current && null !== current.child || null === current || current.memoizedState.isDehydrated && 0 === (workInProgress.flags & 256) || (workInProgress.flags |= 1024, upgradeHydrationErrorsToRecoverable()), updateHostContainer(current, workInProgress), bubbleProperties(workInProgress), null;
+        case 26:
+        case 27:
+        case 5:
+          popHostContext(workInProgress);
+          var _type2 = workInProgress.type;
+          if (null !== current && null != workInProgress.stateNode) {
+            renderLanes = current.stateNode;
+            var _oldProps = current.memoizedProps;
+            if ((current = doesRequireClone(current, workInProgress)) || _oldProps !== newProps) {
+              requiredContext(contextStackCursor.current);
+              b: {
+                _type2 = !current;
+                _oldProps = diffProperties(null, _oldProps, newProps, renderLanes.canonical.viewConfig.validAttributes);
+                renderLanes.canonical.currentProps = newProps;
+                newProps = renderLanes.node;
+                if (_type2) {
+                  if (null !== _oldProps) newProps = cloneNodeWithNewProps(newProps, _oldProps);else {
+                    newProps = renderLanes;
+                    break b;
+                  }
+                } else newProps = null !== _oldProps ? cloneNodeWithNewChildrenAndProps(newProps, _oldProps) : cloneNodeWithNewChildren(newProps);
+                newProps = {
+                  node: newProps,
+                  canonical: renderLanes.canonical
+                };
+              }
+              newProps === renderLanes ? workInProgress.stateNode = renderLanes : (workInProgress.stateNode = newProps, current ? appendAllChildren(newProps, workInProgress, !1, !1) : workInProgress.flags |= 4);
+            } else workInProgress.stateNode = renderLanes;
+          } else {
+            if (!newProps) {
+              if (null === workInProgress.stateNode) throw Error("We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue.");
+              bubbleProperties(workInProgress);
+              return null;
+            }
+            requiredContext(contextStackCursor.current);
+            renderLanes = requiredContext(rootInstanceStackCursor.current);
+            current = nextReactTag;
+            nextReactTag += 2;
+            _type2 = getViewConfigForType(_type2);
+            for (_oldProps in _type2.validAttributes) newProps.hasOwnProperty(_oldProps) && ReactNativePrivateInterface.deepFreezeAndThrowOnMutationInDev(newProps[_oldProps]);
+            _oldProps = fastAddProperties(null, newProps, _type2.validAttributes);
+            _oldProps = createNode(current, _type2.uiViewClassName, renderLanes.containerTag, _oldProps, workInProgress);
+            renderLanes = ReactNativePrivateInterface.createPublicInstance(current, _type2, workInProgress, renderLanes.publicInstance);
+            current = {
+              node: _oldProps,
+              canonical: {
+                nativeTag: current,
+                viewConfig: _type2,
+                currentProps: newProps,
+                internalInstanceHandle: workInProgress,
+                publicInstance: renderLanes
+              }
+            };
+            appendAllChildren(current, workInProgress, !1, !1);
+            workInProgress.stateNode = current;
+          }
+          bubbleProperties(workInProgress);
+          workInProgress.flags &= -16777217;
+          return null;
+        case 6:
+          if (current && null != workInProgress.stateNode) current.memoizedProps !== newProps ? (current = requiredContext(rootInstanceStackCursor.current), renderLanes = requiredContext(contextStackCursor.current), workInProgress.stateNode = createTextInstance(newProps, current, renderLanes, workInProgress), workInProgress.flags |= 4) : workInProgress.stateNode = current.stateNode;else {
+            if ("string" !== typeof newProps && null === workInProgress.stateNode) throw Error("We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue.");
+            current = requiredContext(rootInstanceStackCursor.current);
+            renderLanes = requiredContext(contextStackCursor.current);
+            workInProgress.stateNode = createTextInstance(newProps, current, renderLanes, workInProgress);
+          }
+          bubbleProperties(workInProgress);
+          return null;
+        case 13:
+          newProps = workInProgress.memoizedState;
+          if (null === current || null !== current.memoizedState && null !== current.memoizedState.dehydrated) {
+            if (null !== newProps && null !== newProps.dehydrated) {
+              if (null === current) {
+                throw Error("A dehydrated suspense component was completed without a hydrated node. This is probably a bug in React.");
+                throw Error("Expected prepareToHydrateHostSuspenseInstance() to never be called. This error is likely caused by a bug in React. Please file an issue.");
+              }
+              emitPendingHydrationWarnings();
+              0 === (workInProgress.flags & 128) && (workInProgress.memoizedState = null);
+              workInProgress.flags |= 4;
+              bubbleProperties(workInProgress);
+              0 !== (workInProgress.mode & 2) && null !== newProps && (_type2 = workInProgress.child, null !== _type2 && (workInProgress.treeBaseDuration -= _type2.treeBaseDuration));
+              _type2 = !1;
+            } else _type2 = upgradeHydrationErrorsToRecoverable(), null !== current && null !== current.memoizedState && (current.memoizedState.hydrationErrors = _type2), _type2 = !0;
+            if (!_type2) {
+              if (workInProgress.flags & 256) return popSuspenseHandler(workInProgress), workInProgress;
+              popSuspenseHandler(workInProgress);
+              return null;
+            }
+          }
+          popSuspenseHandler(workInProgress);
+          if (0 !== (workInProgress.flags & 128)) return workInProgress.lanes = renderLanes, 0 !== (workInProgress.mode & 2) && transferActualDuration(workInProgress), workInProgress;
+          newProps = null !== newProps;
+          current = null !== current && null !== current.memoizedState;
+          newProps && (renderLanes = workInProgress.child, _type2 = null, null !== renderLanes.alternate && null !== renderLanes.alternate.memoizedState && null !== renderLanes.alternate.memoizedState.cachePool && (_type2 = renderLanes.alternate.memoizedState.cachePool.pool), _oldProps = null, null !== renderLanes.memoizedState && null !== renderLanes.memoizedState.cachePool && (_oldProps = renderLanes.memoizedState.cachePool.pool), _oldProps !== _type2 && (renderLanes.flags |= 2048));
+          newProps !== current && newProps && (workInProgress.child.flags |= 8192);
+          scheduleRetryEffect(workInProgress, workInProgress.updateQueue);
+          bubbleProperties(workInProgress);
+          0 !== (workInProgress.mode & 2) && newProps && (current = workInProgress.child, null !== current && (workInProgress.treeBaseDuration -= current.treeBaseDuration));
+          return null;
+        case 4:
+          return popHostContainer(workInProgress), updateHostContainer(current, workInProgress), bubbleProperties(workInProgress), null;
+        case 10:
+          return popProvider(workInProgress.type, workInProgress), bubbleProperties(workInProgress), null;
+        case 17:
+          return bubbleProperties(workInProgress), null;
+        case 19:
+          pop(suspenseStackCursor, workInProgress);
+          _type2 = workInProgress.memoizedState;
+          if (null === _type2) return bubbleProperties(workInProgress), null;
+          newProps = 0 !== (workInProgress.flags & 128);
+          _oldProps = _type2.rendering;
+          if (null === _oldProps) {
+            if (newProps) cutOffTailIfNeeded(_type2, !1);else {
+              if (workInProgressRootExitStatus !== RootInProgress || null !== current && 0 !== (current.flags & 128)) for (current = workInProgress.child; null !== current;) {
+                _oldProps = findFirstSuspended(current);
+                if (null !== _oldProps) {
+                  workInProgress.flags |= 128;
+                  cutOffTailIfNeeded(_type2, !1);
+                  current = _oldProps.updateQueue;
+                  workInProgress.updateQueue = current;
+                  scheduleRetryEffect(workInProgress, current);
+                  workInProgress.subtreeFlags = 0;
+                  current = renderLanes;
+                  for (newProps = workInProgress.child; null !== newProps;) resetWorkInProgress(newProps, current), newProps = newProps.sibling;
+                  push(suspenseStackCursor, suspenseStackCursor.current & SubtreeSuspenseContextMask | ForceSuspenseFallback, workInProgress);
+                  return workInProgress.child;
+                }
+                current = current.sibling;
+              }
+              null !== _type2.tail && now$1() > workInProgressRootRenderTargetTime && (workInProgress.flags |= 128, newProps = !0, cutOffTailIfNeeded(_type2, !1), workInProgress.lanes = 4194304);
+            }
+          } else {
+            if (!newProps) if (current = findFirstSuspended(_oldProps), null !== current) {
+              if (workInProgress.flags |= 128, newProps = !0, current = current.updateQueue, workInProgress.updateQueue = current, scheduleRetryEffect(workInProgress, current), cutOffTailIfNeeded(_type2, !0), null === _type2.tail && "hidden" === _type2.tailMode && !_oldProps.alternate) return bubbleProperties(workInProgress), null;
+            } else 2 * now$1() - _type2.renderingStartTime > workInProgressRootRenderTargetTime && 536870912 !== renderLanes && (workInProgress.flags |= 128, newProps = !0, cutOffTailIfNeeded(_type2, !1), workInProgress.lanes = 4194304);
+            _type2.isBackwards ? (_oldProps.sibling = workInProgress.child, workInProgress.child = _oldProps) : (current = _type2.last, null !== current ? current.sibling = _oldProps : workInProgress.child = _oldProps, _type2.last = _oldProps);
+          }
+          if (null !== _type2.tail) return current = _type2.tail, _type2.rendering = current, _type2.tail = current.sibling, _type2.renderingStartTime = now$1(), current.sibling = null, renderLanes = suspenseStackCursor.current, renderLanes = newProps ? renderLanes & SubtreeSuspenseContextMask | ForceSuspenseFallback : renderLanes & SubtreeSuspenseContextMask, push(suspenseStackCursor, renderLanes, workInProgress), current;
+          bubbleProperties(workInProgress);
+          return null;
+        case 22:
+        case 23:
+          return popSuspenseHandler(workInProgress), popHiddenContext(workInProgress), newProps = null !== workInProgress.memoizedState, null !== current ? null !== current.memoizedState !== newProps && (workInProgress.flags |= 8192) : newProps && (workInProgress.flags |= 8192), newProps && 0 !== (workInProgress.mode & 1) ? 0 !== (renderLanes & 536870912) && 0 === (workInProgress.flags & 128) && (bubbleProperties(workInProgress), workInProgress.subtreeFlags & 6 && (workInProgress.flags |= 8192)) : bubbleProperties(workInProgress), newProps = workInProgress.updateQueue, null !== newProps && scheduleRetryEffect(workInProgress, newProps.retryQueue), newProps = null, null !== current && null !== current.memoizedState && null !== current.memoizedState.cachePool && (newProps = current.memoizedState.cachePool.pool), renderLanes = null, null !== workInProgress.memoizedState && null !== workInProgress.memoizedState.cachePool && (renderLanes = workInProgress.memoizedState.cachePool.pool), renderLanes !== newProps && (workInProgress.flags |= 2048), null !== current && pop(resumedCache, workInProgress), null;
+        case 24:
+          return newProps = null, null !== current && (newProps = current.memoizedState.cache), workInProgress.memoizedState.cache !== newProps && (workInProgress.flags |= 2048), popProvider(CacheContext, workInProgress), bubbleProperties(workInProgress), null;
+        case 25:
+          return null;
+        case 30:
+          return null;
+        case 29:
+          return null;
+      }
+      throw Error("Unknown unit of work tag (" + workInProgress.tag + "). This error is likely caused by a bug in React. Please file an issue.");
+    }
+    function unwindWork(current, workInProgress) {
+      switch (workInProgress.tag) {
+        case 1:
+          return current = workInProgress.flags, current & 65536 ? (workInProgress.flags = current & -65537 | 128, 0 !== (workInProgress.mode & 2) && transferActualDuration(workInProgress), workInProgress) : null;
+        case 3:
+          return popProvider(CacheContext, workInProgress), popHostContainer(workInProgress), current = workInProgress.flags, 0 !== (current & 65536) && 0 === (current & 128) ? (workInProgress.flags = current & -65537 | 128, workInProgress) : null;
+        case 26:
+        case 27:
+        case 5:
+          return popHostContext(workInProgress), null;
+        case 13:
+          popSuspenseHandler(workInProgress);
+          current = workInProgress.memoizedState;
+          if (null !== current && null !== current.dehydrated && null === workInProgress.alternate) throw Error("Threw in newly mounted dehydrated component. This is likely a bug in React. Please file an issue.");
+          current = workInProgress.flags;
+          return current & 65536 ? (workInProgress.flags = current & -65537 | 128, 0 !== (workInProgress.mode & 2) && transferActualDuration(workInProgress), workInProgress) : null;
+        case 19:
+          return pop(suspenseStackCursor, workInProgress), null;
+        case 4:
+          return popHostContainer(workInProgress), null;
+        case 10:
+          return popProvider(workInProgress.type, workInProgress), null;
+        case 22:
+        case 23:
+          return popSuspenseHandler(workInProgress), popHiddenContext(workInProgress), null !== current && pop(resumedCache, workInProgress), current = workInProgress.flags, current & 65536 ? (workInProgress.flags = current & -65537 | 128, 0 !== (workInProgress.mode & 2) && transferActualDuration(workInProgress), workInProgress) : null;
+        case 24:
+          return popProvider(CacheContext, workInProgress), null;
+        case 25:
+          return null;
+        default:
+          return null;
+      }
+    }
+    function unwindInterruptedWork(current, interruptedWork) {
+      switch (interruptedWork.tag) {
+        case 3:
+          popProvider(CacheContext, interruptedWork);
+          popHostContainer(interruptedWork);
+          break;
+        case 26:
+        case 27:
+        case 5:
+          popHostContext(interruptedWork);
+          break;
+        case 4:
+          popHostContainer(interruptedWork);
+          break;
+        case 13:
+          popSuspenseHandler(interruptedWork);
+          break;
+        case 19:
+          pop(suspenseStackCursor, interruptedWork);
+          break;
+        case 10:
+          popProvider(interruptedWork.type, interruptedWork);
+          break;
+        case 22:
+        case 23:
+          popSuspenseHandler(interruptedWork);
+          popHiddenContext(interruptedWork);
+          null !== current && pop(resumedCache, interruptedWork);
+          break;
+        case 24:
+          popProvider(CacheContext, interruptedWork);
+      }
+    }
+    function shouldProfile(current) {
+      return 0 !== (current.mode & 2);
+    }
+    function commitHookLayoutEffects(finishedWork, hookFlags) {
+      shouldProfile(finishedWork) ? (startEffectTimer(), commitHookEffectListMount(hookFlags, finishedWork), recordEffectDuration()) : commitHookEffectListMount(hookFlags, finishedWork);
+    }
+    function commitHookLayoutUnmountEffects(finishedWork, nearestMountedAncestor, hookFlags) {
+      shouldProfile(finishedWork) ? (startEffectTimer(), commitHookEffectListUnmount(hookFlags, finishedWork, nearestMountedAncestor), recordEffectDuration()) : commitHookEffectListUnmount(hookFlags, finishedWork, nearestMountedAncestor);
+    }
+    function commitHookEffectListMount(flags, finishedWork) {
+      try {
+        var updateQueue = finishedWork.updateQueue,
+          lastEffect = null !== updateQueue ? updateQueue.lastEffect : null;
+        if (null !== lastEffect) {
+          var firstEffect = lastEffect.next;
+          updateQueue = firstEffect;
+          do {
+            if ((updateQueue.tag & flags) === flags && ((flags & Passive) !== NoFlags ? null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markComponentPassiveEffectMountStarted && injectedProfilingHooks.markComponentPassiveEffectMountStarted(finishedWork) : (flags & Layout) !== NoFlags && null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markComponentLayoutEffectMountStarted && injectedProfilingHooks.markComponentLayoutEffectMountStarted(finishedWork), lastEffect = void 0, (flags & Insertion) !== NoFlags && (isRunningInsertionEffect = !0), lastEffect = runWithFiberInDEV(finishedWork, callCreateInDEV, updateQueue), (flags & Insertion) !== NoFlags && (isRunningInsertionEffect = !1), (flags & Passive) !== NoFlags ? null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markComponentPassiveEffectMountStopped && injectedProfilingHooks.markComponentPassiveEffectMountStopped() : (flags & Layout) !== NoFlags && null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markComponentLayoutEffectMountStopped && injectedProfilingHooks.markComponentLayoutEffectMountStopped(), void 0 !== lastEffect && "function" !== typeof lastEffect)) {
+              var hookName = void 0;
+              hookName = 0 !== (updateQueue.tag & Layout) ? "useLayoutEffect" : 0 !== (updateQueue.tag & Insertion) ? "useInsertionEffect" : "useEffect";
+              var addendum = void 0;
+              addendum = null === lastEffect ? " You returned null. If your effect does not require clean up, return undefined (or nothing)." : "function" === typeof lastEffect.then ? "\n\nIt looks like you wrote " + hookName + "(async () => ...) or returned a Promise. Instead, write the async function inside your effect and call it immediately:\n\n" + hookName + "(() => {\n  async function fetchData() {\n    // You can await here\n    const response = await MyAPI.getData(someId);\n    // ...\n  }\n  fetchData();\n}, [someId]); // Or [] if effect doesn't need props or state\n\nLearn more about data fetching with Hooks: https://react.dev/link/hooks-data-fetching" : " You returned: " + lastEffect;
+              runWithFiberInDEV(finishedWork, function (n, a) {
+                console.error("%s must not return anything besides a function, which is used for clean-up.%s", n, a);
+              }, hookName, addendum);
+            }
+            updateQueue = updateQueue.next;
+          } while (updateQueue !== firstEffect);
+        }
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+    }
+    function commitHookEffectListUnmount(flags, finishedWork, nearestMountedAncestor) {
+      try {
+        var updateQueue = finishedWork.updateQueue,
+          lastEffect = null !== updateQueue ? updateQueue.lastEffect : null;
+        if (null !== lastEffect) {
+          var firstEffect = lastEffect.next;
+          updateQueue = firstEffect;
+          do {
+            if ((updateQueue.tag & flags) === flags) {
+              var inst = updateQueue.inst,
+                destroy = inst.destroy;
+              void 0 !== destroy && (inst.destroy = void 0, (flags & Passive) !== NoFlags ? null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markComponentPassiveEffectUnmountStarted && injectedProfilingHooks.markComponentPassiveEffectUnmountStarted(finishedWork) : (flags & Layout) !== NoFlags && null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStarted && injectedProfilingHooks.markComponentLayoutEffectUnmountStarted(finishedWork), (flags & Insertion) !== NoFlags && (isRunningInsertionEffect = !0), lastEffect = finishedWork, runWithFiberInDEV(lastEffect, callDestroyInDEV, lastEffect, nearestMountedAncestor, destroy), (flags & Insertion) !== NoFlags && (isRunningInsertionEffect = !1), (flags & Passive) !== NoFlags ? null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markComponentPassiveEffectUnmountStopped && injectedProfilingHooks.markComponentPassiveEffectUnmountStopped() : (flags & Layout) !== NoFlags && null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStopped && injectedProfilingHooks.markComponentLayoutEffectUnmountStopped());
+            }
+            updateQueue = updateQueue.next;
+          } while (updateQueue !== firstEffect);
+        }
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+    }
+    function commitHookPassiveMountEffects(finishedWork, hookFlags) {
+      shouldProfile(finishedWork) ? (startEffectTimer(), commitHookEffectListMount(hookFlags, finishedWork), recordEffectDuration()) : commitHookEffectListMount(hookFlags, finishedWork);
+    }
+    function commitHookPassiveUnmountEffects(finishedWork, nearestMountedAncestor, hookFlags) {
+      shouldProfile(finishedWork) ? (startEffectTimer(), commitHookEffectListUnmount(hookFlags, finishedWork, nearestMountedAncestor), recordEffectDuration()) : commitHookEffectListUnmount(hookFlags, finishedWork, nearestMountedAncestor);
+    }
+    function commitClassDidMount(finishedWork) {
+      var instance = finishedWork.stateNode;
+      "function" === typeof instance.componentDidMount && runWithFiberInDEV(finishedWork, callComponentDidMountInDEV, finishedWork, instance);
+    }
+    function commitClassCallbacks(finishedWork) {
+      var updateQueue = finishedWork.updateQueue;
+      if (null !== updateQueue) {
+        var instance = finishedWork.stateNode;
+        finishedWork.type.defaultProps || "ref" in finishedWork.memoizedProps || didWarnAboutReassigningProps || (instance.props !== finishedWork.memoizedProps && console.error("Expected %s props to match memoized props before processing the update queue. This might either be because of a bug in React, or because a component reassigns its own `this.props`. Please file an issue.", getComponentNameFromFiber(finishedWork) || "instance"), instance.state !== finishedWork.memoizedState && console.error("Expected %s state to match memoized state before processing the update queue. This might either be because of a bug in React, or because a component reassigns its own `this.state`. Please file an issue.", getComponentNameFromFiber(finishedWork) || "instance"));
+        try {
+          runWithFiberInDEV(finishedWork, commitCallbacks, updateQueue, instance);
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        }
+      }
+    }
+    function callGetSnapshotBeforeUpdates(instance, prevProps, prevState) {
+      return instance.getSnapshotBeforeUpdate(prevProps, prevState);
+    }
+    function commitClassSnapshot(finishedWork, current) {
+      var prevProps = current.memoizedProps,
+        prevState = current.memoizedState;
+      current = finishedWork.stateNode;
+      finishedWork.type.defaultProps || "ref" in finishedWork.memoizedProps || didWarnAboutReassigningProps || (current.props !== finishedWork.memoizedProps && console.error("Expected %s props to match memoized props before getSnapshotBeforeUpdate. This might either be because of a bug in React, or because a component reassigns its own `this.props`. Please file an issue.", getComponentNameFromFiber(finishedWork) || "instance"), current.state !== finishedWork.memoizedState && console.error("Expected %s state to match memoized state before getSnapshotBeforeUpdate. This might either be because of a bug in React, or because a component reassigns its own `this.state`. Please file an issue.", getComponentNameFromFiber(finishedWork) || "instance"));
+      try {
+        var resolvedPrevProps = resolveClassComponentProps(finishedWork.type, prevProps, finishedWork.elementType === finishedWork.type);
+        var snapshot = runWithFiberInDEV(finishedWork, callGetSnapshotBeforeUpdates, current, resolvedPrevProps, prevState);
+        prevProps = didWarnAboutUndefinedSnapshotBeforeUpdate;
+        void 0 !== snapshot || prevProps.has(finishedWork.type) || (prevProps.add(finishedWork.type), runWithFiberInDEV(finishedWork, function () {
+          console.error("%s.getSnapshotBeforeUpdate(): A snapshot value (or null) must be returned. You have returned undefined.", getComponentNameFromFiber(finishedWork));
+        }));
+        current.__reactInternalSnapshotBeforeUpdate = snapshot;
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+    }
+    function safelyCallComponentWillUnmount(current, nearestMountedAncestor, instance) {
+      instance.props = resolveClassComponentProps(current.type, current.memoizedProps);
+      instance.state = current.memoizedState;
+      shouldProfile(current) ? (startEffectTimer(), runWithFiberInDEV(current, callComponentWillUnmountInDEV, current, nearestMountedAncestor, instance), recordEffectDuration()) : runWithFiberInDEV(current, callComponentWillUnmountInDEV, current, nearestMountedAncestor, instance);
+    }
+    function commitAttachRef(finishedWork) {
+      var ref = finishedWork.ref;
+      if (null !== ref) {
+        switch (finishedWork.tag) {
+          case 26:
+          case 27:
+          case 5:
+            var instanceToUse = getPublicInstance(finishedWork.stateNode);
+            break;
+          case 30:
+            instanceToUse = finishedWork.stateNode;
+            break;
+          default:
+            instanceToUse = finishedWork.stateNode;
+        }
+        if ("function" === typeof ref) {
+          if (shouldProfile(finishedWork)) try {
+            startEffectTimer(), finishedWork.refCleanup = ref(instanceToUse);
+          } finally {
+            recordEffectDuration();
+          } else finishedWork.refCleanup = ref(instanceToUse);
+        } else "string" === typeof ref ? console.error("String refs are no longer supported.") : ref.hasOwnProperty("current") || console.error("Unexpected ref object provided for %s. Use either a ref-setter function or React.createRef().", getComponentNameFromFiber(finishedWork)), ref.current = instanceToUse;
+      }
+    }
+    function safelyAttachRef(current, nearestMountedAncestor) {
+      try {
+        runWithFiberInDEV(current, commitAttachRef, current);
+      } catch (error) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error);
+      }
+    }
+    function safelyDetachRef(current, nearestMountedAncestor) {
+      var ref = current.ref,
+        refCleanup = current.refCleanup;
+      if (null !== ref) if ("function" === typeof refCleanup) try {
+        if (shouldProfile(current)) try {
+          startEffectTimer(), runWithFiberInDEV(current, refCleanup);
+        } finally {
+          recordEffectDuration(current);
+        } else runWithFiberInDEV(current, refCleanup);
+      } catch (error) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error);
+      } finally {
+        current.refCleanup = null, current = current.alternate, null != current && (current.refCleanup = null);
+      } else if ("function" === typeof ref) try {
+        if (shouldProfile(current)) try {
+          startEffectTimer(), runWithFiberInDEV(current, ref, null);
+        } finally {
+          recordEffectDuration(current);
+        } else runWithFiberInDEV(current, ref, null);
+      } catch (error$4) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error$4);
+      } else ref.current = null;
+    }
+    function commitProfiler(finishedWork, current, commitStartTime, effectDuration) {
+      var _finishedWork$memoize = finishedWork.memoizedProps,
+        id = _finishedWork$memoize.id,
+        onCommit = _finishedWork$memoize.onCommit;
+      _finishedWork$memoize = _finishedWork$memoize.onRender;
+      current = null === current ? "mount" : "update";
+      currentUpdateIsNested && (current = "nested-update");
+      "function" === typeof _finishedWork$memoize && _finishedWork$memoize(id, current, finishedWork.actualDuration, finishedWork.treeBaseDuration, finishedWork.actualStartTime, commitStartTime);
+      "function" === typeof onCommit && onCommit(finishedWork.memoizedProps.id, current, effectDuration, commitStartTime);
+    }
+    function commitProfilerPostCommitImpl(finishedWork, current, commitStartTime, passiveEffectDuration) {
+      var _finishedWork$memoize2 = finishedWork.memoizedProps;
+      finishedWork = _finishedWork$memoize2.id;
+      _finishedWork$memoize2 = _finishedWork$memoize2.onPostCommit;
+      current = null === current ? "mount" : "update";
+      currentUpdateIsNested && (current = "nested-update");
+      "function" === typeof _finishedWork$memoize2 && _finishedWork$memoize2(finishedWork, current, passiveEffectDuration, commitStartTime);
+    }
+    function commitHostMount(finishedWork) {
+      var type = finishedWork.type,
+        props = finishedWork.memoizedProps,
+        instance = finishedWork.stateNode;
+      try {
+        runWithFiberInDEV(finishedWork, commitMount, instance, type, props, finishedWork);
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+    }
+    function commitPlacement() {}
+    function commitHostPortalContainerChildren(portal, finishedWork, pendingChildren) {
+      portal = portal.containerInfo;
+      try {
+        runWithFiberInDEV(finishedWork, replaceContainerChildren, portal, pendingChildren);
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+    }
+    function commitBeforeMutationEffects(root, firstChild) {
+      for (nextEffect = firstChild; null !== nextEffect;) if (root = nextEffect, firstChild = root.child, 0 !== (root.subtreeFlags & 1024) && null !== firstChild) firstChild.return = root, nextEffect = firstChild;else for (; null !== nextEffect;) {
+        root = nextEffect;
+        firstChild = root.alternate;
+        var flags = root.flags;
+        switch (root.tag) {
+          case 0:
+            break;
+          case 11:
+          case 15:
+            break;
+          case 1:
+            0 !== (flags & 1024) && null !== firstChild && commitClassSnapshot(root, firstChild);
+            break;
+          case 3:
+            break;
+          case 5:
+          case 26:
+          case 27:
+          case 6:
+          case 4:
+          case 17:
+            break;
+          default:
+            if (0 !== (flags & 1024)) throw Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue.");
+        }
+        firstChild = root.sibling;
+        if (null !== firstChild) {
+          firstChild.return = root.return;
+          nextEffect = firstChild;
+          break;
+        }
+        nextEffect = root.return;
+      }
+    }
+    function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork) {
+      var flags = finishedWork.flags;
+      switch (finishedWork.tag) {
+        case 0:
+        case 11:
+        case 15:
+          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+          flags & 4 && commitHookLayoutEffects(finishedWork, Layout | HasEffect);
+          break;
+        case 1:
+          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+          if (flags & 4) if (finishedRoot = finishedWork.stateNode, null === current) finishedWork.type.defaultProps || "ref" in finishedWork.memoizedProps || didWarnAboutReassigningProps || (finishedRoot.props !== finishedWork.memoizedProps && console.error("Expected %s props to match memoized props before componentDidMount. This might either be because of a bug in React, or because a component reassigns its own `this.props`. Please file an issue.", getComponentNameFromFiber(finishedWork) || "instance"), finishedRoot.state !== finishedWork.memoizedState && console.error("Expected %s state to match memoized state before componentDidMount. This might either be because of a bug in React, or because a component reassigns its own `this.state`. Please file an issue.", getComponentNameFromFiber(finishedWork) || "instance")), shouldProfile(finishedWork) ? (startEffectTimer(), runWithFiberInDEV(finishedWork, callComponentDidMountInDEV, finishedWork, finishedRoot), recordEffectDuration()) : runWithFiberInDEV(finishedWork, callComponentDidMountInDEV, finishedWork, finishedRoot);else {
+            var prevProps = resolveClassComponentProps(finishedWork.type, current.memoizedProps);
+            current = current.memoizedState;
+            finishedWork.type.defaultProps || "ref" in finishedWork.memoizedProps || didWarnAboutReassigningProps || (finishedRoot.props !== finishedWork.memoizedProps && console.error("Expected %s props to match memoized props before componentDidUpdate. This might either be because of a bug in React, or because a component reassigns its own `this.props`. Please file an issue.", getComponentNameFromFiber(finishedWork) || "instance"), finishedRoot.state !== finishedWork.memoizedState && console.error("Expected %s state to match memoized state before componentDidUpdate. This might either be because of a bug in React, or because a component reassigns its own `this.state`. Please file an issue.", getComponentNameFromFiber(finishedWork) || "instance"));
+            shouldProfile(finishedWork) ? (startEffectTimer(), runWithFiberInDEV(finishedWork, callComponentDidUpdateInDEV, finishedWork, finishedRoot, prevProps, current, finishedRoot.__reactInternalSnapshotBeforeUpdate), recordEffectDuration()) : runWithFiberInDEV(finishedWork, callComponentDidUpdateInDEV, finishedWork, finishedRoot, prevProps, current, finishedRoot.__reactInternalSnapshotBeforeUpdate);
+          }
+          flags & 64 && commitClassCallbacks(finishedWork);
+          flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
+          break;
+        case 3:
+          current = pushNestedEffectDurations();
+          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+          if (flags & 64 && (flags = finishedWork.updateQueue, null !== flags)) {
+            prevProps = null;
+            if (null !== finishedWork.child) switch (finishedWork.child.tag) {
+              case 27:
+              case 5:
+                prevProps = getPublicInstance(finishedWork.child.stateNode);
+                break;
+              case 1:
+                prevProps = finishedWork.child.stateNode;
+            }
+            try {
+              runWithFiberInDEV(finishedWork, commitCallbacks, flags, prevProps);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+          finishedRoot.effectDuration += popNestedEffectDurations(current);
+          break;
+        case 27:
+        case 26:
+        case 5:
+          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+          null === current && flags & 4 && commitHostMount(finishedWork);
+          flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
+          break;
+        case 12:
+          if (flags & 4) {
+            flags = pushNestedEffectDurations();
+            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+            finishedRoot = finishedWork.stateNode;
+            finishedRoot.effectDuration += bubbleNestedEffectDurations(flags);
+            try {
+              runWithFiberInDEV(finishedWork, commitProfiler, finishedWork, current, commitStartTime, finishedRoot.effectDuration);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          } else recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+          break;
+        case 13:
+          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+          flags & 64 && (finishedRoot = finishedWork.memoizedState, null !== finishedRoot && null !== finishedRoot.dehydrated && (retryDehydratedSuspenseBoundary.bind(null, finishedWork), registerSuspenseInstanceRetry()));
+          break;
+        case 22:
+          if (0 !== (finishedWork.mode & 1)) {
+            if (flags = null !== finishedWork.memoizedState || offscreenSubtreeIsHidden, !flags) {
+              current = null !== current && null !== current.memoizedState || offscreenSubtreeWasHidden;
+              prevProps = offscreenSubtreeIsHidden;
+              var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+              offscreenSubtreeIsHidden = flags;
+              (offscreenSubtreeWasHidden = current) && !prevOffscreenSubtreeWasHidden ? recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, 0 !== (finishedWork.subtreeFlags & 8772)) : recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+              offscreenSubtreeIsHidden = prevProps;
+              offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+            }
+          } else recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+          break;
+        case 30:
+          break;
+        default:
+          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      }
+    }
+    function detachFiberAfterEffects(fiber) {
+      var alternate = fiber.alternate;
+      null !== alternate && (fiber.alternate = null, detachFiberAfterEffects(alternate));
+      fiber.child = null;
+      fiber.deletions = null;
+      fiber.sibling = null;
+      fiber.stateNode = null;
+      fiber._debugOwner = null;
+      fiber.return = null;
+      fiber.dependencies = null;
+      fiber.memoizedProps = null;
+      fiber.memoizedState = null;
+      fiber.pendingProps = null;
+      fiber.stateNode = null;
+      fiber.updateQueue = null;
+    }
+    function recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, parent) {
+      for (parent = parent.child; null !== parent;) commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, parent), parent = parent.sibling;
+    }
+    function commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, deletedFiber) {
+      if (injectedHook && "function" === typeof injectedHook.onCommitFiberUnmount) try {
+        injectedHook.onCommitFiberUnmount(rendererID, deletedFiber);
+      } catch (err) {
+        hasLoggedError || (hasLoggedError = !0, console.error("React instrumentation encountered an error: %s", err));
+      }
+      switch (deletedFiber.tag) {
+        case 26:
+        case 27:
+        case 5:
+          offscreenSubtreeWasHidden || safelyDetachRef(deletedFiber, nearestMountedAncestor);
+        case 6:
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          break;
+        case 18:
+          break;
+        case 4:
+          commitHostPortalContainerChildren(deletedFiber.stateNode, deletedFiber, createChildNodeSet());
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          break;
+        case 0:
+        case 11:
+        case 14:
+        case 15:
+          offscreenSubtreeWasHidden || commitHookEffectListUnmount(Insertion, deletedFiber, nearestMountedAncestor);
+          offscreenSubtreeWasHidden || commitHookLayoutUnmountEffects(deletedFiber, nearestMountedAncestor, Layout);
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          break;
+        case 1:
+          if (!offscreenSubtreeWasHidden) {
+            safelyDetachRef(deletedFiber, nearestMountedAncestor);
+            var instance = deletedFiber.stateNode;
+            "function" === typeof instance.componentWillUnmount && safelyCallComponentWillUnmount(deletedFiber, nearestMountedAncestor, instance);
+          }
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          break;
+        case 21:
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          break;
+        case 22:
+          deletedFiber.mode & 1 ? (offscreenSubtreeWasHidden = (instance = offscreenSubtreeWasHidden) || null !== deletedFiber.memoizedState, recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber), offscreenSubtreeWasHidden = instance) : recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          break;
+        default:
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+      }
+    }
+    function getRetryCache(finishedWork) {
+      switch (finishedWork.tag) {
+        case 13:
+        case 19:
+          var retryCache = finishedWork.stateNode;
+          null === retryCache && (retryCache = finishedWork.stateNode = new PossiblyWeakSet());
+          return retryCache;
+        case 22:
+          return finishedWork = finishedWork.stateNode, retryCache = finishedWork._retryCache, null === retryCache && (retryCache = finishedWork._retryCache = new PossiblyWeakSet()), retryCache;
+        default:
+          throw Error("Unexpected Suspense handler tag (" + finishedWork.tag + "). This is a bug in React.");
+      }
+    }
+    function attachSuspenseRetryListeners(finishedWork, wakeables) {
+      var retryCache = getRetryCache(finishedWork);
+      wakeables.forEach(function (wakeable) {
+        var retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
+        if (!retryCache.has(wakeable)) {
+          retryCache.add(wakeable);
+          if (isDevToolsPresent) if (null !== inProgressLanes && null !== inProgressRoot) restorePendingUpdaters(inProgressRoot, inProgressLanes);else throw Error("Expected finished root and lanes to be set. This is a bug in React.");
+          wakeable.then(retry, retry);
+        }
+      });
+    }
+    function recursivelyTraverseMutationEffects(root, parentFiber) {
+      var deletions = parentFiber.deletions;
+      if (null !== deletions) for (var i = 0; i < deletions.length; i++) {
+        var deletedFiber = deletions[i];
+        commitDeletionEffectsOnFiber(root, parentFiber, deletedFiber);
+        var alternate = deletedFiber.alternate;
+        null !== alternate && (alternate.return = null);
+        deletedFiber.return = null;
+      }
+      if (parentFiber.subtreeFlags & 13878) for (parentFiber = parentFiber.child; null !== parentFiber;) commitMutationEffectsOnFiber(parentFiber, root), parentFiber = parentFiber.sibling;
+    }
+    function commitMutationEffectsOnFiber(finishedWork, root) {
+      var current = finishedWork.alternate,
+        flags = finishedWork.flags;
+      switch (finishedWork.tag) {
+        case 0:
+        case 11:
+        case 14:
+        case 15:
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          flags & 4 && (commitHookEffectListUnmount(Insertion | HasEffect, finishedWork, finishedWork.return), commitHookEffectListMount(Insertion | HasEffect, finishedWork), commitHookLayoutUnmountEffects(finishedWork, finishedWork.return, Layout | HasEffect));
+          break;
+        case 1:
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          flags & 512 && (offscreenSubtreeWasHidden || null === current || safelyDetachRef(current, current.return));
+          flags & 64 && offscreenSubtreeIsHidden && (finishedWork = finishedWork.updateQueue, null !== finishedWork && (root = finishedWork.callbacks, null !== root && (flags = finishedWork.shared.hiddenCallbacks, finishedWork.shared.hiddenCallbacks = null === flags ? root : flags.concat(root))));
+          break;
+        case 26:
+        case 27:
+        case 5:
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          flags & 512 && (offscreenSubtreeWasHidden || null === current || safelyDetachRef(current, current.return));
+          break;
+        case 6:
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          break;
+        case 3:
+          current = pushNestedEffectDurations();
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          if (flags & 4) {
+            flags = root.containerInfo;
+            var pendingChildren = root.pendingChildren;
+            try {
+              runWithFiberInDEV(finishedWork, replaceContainerChildren, flags, pendingChildren);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+          root.effectDuration += popNestedEffectDurations(current);
+          break;
+        case 4:
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          flags & 4 && commitHostPortalContainerChildren(finishedWork.stateNode, finishedWork, finishedWork.stateNode.pendingChildren);
+          break;
+        case 12:
+          flags = pushNestedEffectDurations();
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          finishedWork.stateNode.effectDuration += bubbleNestedEffectDurations(flags);
+          break;
+        case 13:
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          finishedWork.child.flags & 8192 && (root = null !== current && null !== current.memoizedState, null === finishedWork.memoizedState || root || (globalMostRecentFallbackTime = now$1()));
+          flags & 4 && (root = finishedWork.updateQueue, null !== root && (finishedWork.updateQueue = null, attachSuspenseRetryListeners(finishedWork, root)));
+          break;
+        case 22:
+          pendingChildren = null !== finishedWork.memoizedState;
+          var wasHidden = null !== current && null !== current.memoizedState;
+          if (finishedWork.mode & 1) {
+            var prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden,
+              prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+            offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden || pendingChildren;
+            offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || wasHidden;
+            recursivelyTraverseMutationEffects(root, finishedWork);
+            offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+            offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
+          } else recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          flags & 8192 && (root = finishedWork.stateNode, root._visibility = pendingChildren ? root._visibility & -2 : root._visibility | 1, pendingChildren && (null === current || wasHidden || offscreenSubtreeIsHidden || offscreenSubtreeWasHidden || 0 !== (finishedWork.mode & 1) && recursivelyTraverseDisappearLayoutEffects(finishedWork)));
+          flags & 4 && (root = finishedWork.updateQueue, null !== root && (flags = root.retryQueue, null !== flags && (root.retryQueue = null, attachSuspenseRetryListeners(finishedWork, flags))));
+          break;
+        case 19:
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          flags & 4 && (root = finishedWork.updateQueue, null !== root && (finishedWork.updateQueue = null, attachSuspenseRetryListeners(finishedWork, root)));
+          break;
+        case 30:
+          break;
+        case 21:
+          break;
+        default:
+          recursivelyTraverseMutationEffects(root, finishedWork), commitReconciliationEffects(finishedWork);
+      }
+    }
+    function commitReconciliationEffects(finishedWork) {
+      var flags = finishedWork.flags;
+      if (flags & 2) {
+        try {
+          runWithFiberInDEV(finishedWork, commitPlacement, finishedWork);
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        }
+        finishedWork.flags &= -3;
+      }
+      flags & 4096 && (finishedWork.flags &= -4097);
+    }
+    function recursivelyTraverseLayoutEffects(root, parentFiber) {
+      if (parentFiber.subtreeFlags & 8772) for (parentFiber = parentFiber.child; null !== parentFiber;) commitLayoutEffectOnFiber(root, parentFiber.alternate, parentFiber), parentFiber = parentFiber.sibling;
+    }
+    function disappearLayoutEffects(finishedWork) {
+      switch (finishedWork.tag) {
+        case 0:
+        case 11:
+        case 14:
+        case 15:
+          commitHookLayoutUnmountEffects(finishedWork, finishedWork.return, Layout);
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+          break;
+        case 1:
+          safelyDetachRef(finishedWork, finishedWork.return);
+          var instance = finishedWork.stateNode;
+          "function" === typeof instance.componentWillUnmount && safelyCallComponentWillUnmount(finishedWork, finishedWork.return, instance);
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+          break;
+        case 27:
+        case 26:
+        case 5:
+          safelyDetachRef(finishedWork, finishedWork.return);
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+          break;
+        case 22:
+          null === finishedWork.memoizedState && recursivelyTraverseDisappearLayoutEffects(finishedWork);
+          break;
+        case 30:
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+          break;
+        default:
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+      }
+    }
+    function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
+      for (parentFiber = parentFiber.child; null !== parentFiber;) disappearLayoutEffects(parentFiber), parentFiber = parentFiber.sibling;
+    }
+    function reappearLayoutEffects(finishedRoot, current, finishedWork, includeWorkInProgressEffects) {
+      var flags = finishedWork.flags;
+      switch (finishedWork.tag) {
+        case 0:
+        case 11:
+        case 15:
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+          commitHookLayoutEffects(finishedWork, Layout);
+          break;
+        case 1:
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+          commitClassDidMount(finishedWork);
+          current = finishedWork.updateQueue;
+          if (null !== current) {
+            finishedRoot = finishedWork.stateNode;
+            try {
+              runWithFiberInDEV(finishedWork, commitHiddenCallbacks, current, finishedRoot);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+          includeWorkInProgressEffects && flags & 64 && commitClassCallbacks(finishedWork);
+          safelyAttachRef(finishedWork, finishedWork.return);
+          break;
+        case 27:
+        case 26:
+        case 5:
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+          includeWorkInProgressEffects && null === current && flags & 4 && commitHostMount(finishedWork);
+          safelyAttachRef(finishedWork, finishedWork.return);
+          break;
+        case 12:
+          if (includeWorkInProgressEffects && flags & 4) {
+            flags = pushNestedEffectDurations();
+            recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+            includeWorkInProgressEffects = finishedWork.stateNode;
+            includeWorkInProgressEffects.effectDuration += bubbleNestedEffectDurations(flags);
+            try {
+              runWithFiberInDEV(finishedWork, commitProfiler, finishedWork, current, commitStartTime, includeWorkInProgressEffects.effectDuration);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          } else recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+          break;
+        case 13:
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+          break;
+        case 22:
+          null === finishedWork.memoizedState && recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+          safelyAttachRef(finishedWork, finishedWork.return);
+          break;
+        case 30:
+          break;
+        default:
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+      }
+    }
+    function recursivelyTraverseReappearLayoutEffects(finishedRoot, parentFiber, includeWorkInProgressEffects) {
+      includeWorkInProgressEffects = includeWorkInProgressEffects && 0 !== (parentFiber.subtreeFlags & 8772);
+      for (parentFiber = parentFiber.child; null !== parentFiber;) reappearLayoutEffects(finishedRoot, parentFiber.alternate, parentFiber, includeWorkInProgressEffects), parentFiber = parentFiber.sibling;
+    }
+    function commitOffscreenPassiveMountEffects(current, finishedWork) {
+      var previousCache = null;
+      null !== current && null !== current.memoizedState && null !== current.memoizedState.cachePool && (previousCache = current.memoizedState.cachePool.pool);
+      current = null;
+      null !== finishedWork.memoizedState && null !== finishedWork.memoizedState.cachePool && (current = finishedWork.memoizedState.cachePool.pool);
+      current !== previousCache && (null != current && retainCache(current), null != previousCache && releaseCache(previousCache));
+    }
+    function commitCachePassiveMountEffect(current, finishedWork) {
+      current = null;
+      null !== finishedWork.alternate && (current = finishedWork.alternate.memoizedState.cache);
+      finishedWork = finishedWork.memoizedState.cache;
+      finishedWork !== current && (retainCache(finishedWork), null != current && releaseCache(current));
+    }
+    function recursivelyTraversePassiveMountEffects(root, parentFiber, committedLanes, committedTransitions) {
+      if (parentFiber.subtreeFlags & 10256) for (parentFiber = parentFiber.child; null !== parentFiber;) commitPassiveMountOnFiber(root, parentFiber, committedLanes, committedTransitions), parentFiber = parentFiber.sibling;
+    }
+    function commitPassiveMountOnFiber(finishedRoot, finishedWork, committedLanes, committedTransitions) {
+      var flags = finishedWork.flags;
+      switch (finishedWork.tag) {
+        case 0:
+        case 11:
+        case 15:
+          recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+          flags & 2048 && commitHookPassiveMountEffects(finishedWork, Passive | HasEffect);
+          break;
+        case 1:
+          recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+          break;
+        case 3:
+          var prevEffectDuration = pushNestedEffectDurations();
+          recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+          flags & 2048 && (committedLanes = null, null !== finishedWork.alternate && (committedLanes = finishedWork.alternate.memoizedState.cache), finishedWork = finishedWork.memoizedState.cache, finishedWork !== committedLanes && (retainCache(finishedWork), null != committedLanes && releaseCache(committedLanes)));
+          finishedRoot.passiveEffectDuration += popNestedEffectDurations(prevEffectDuration);
+          break;
+        case 12:
+          if (flags & 2048) {
+            flags = pushNestedEffectDurations();
+            recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+            finishedRoot = finishedWork.stateNode;
+            finishedRoot.passiveEffectDuration += bubbleNestedEffectDurations(flags);
+            try {
+              runWithFiberInDEV(finishedWork, commitProfilerPostCommitImpl, finishedWork, finishedWork.alternate, commitStartTime, finishedRoot.passiveEffectDuration);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          } else recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+          break;
+        case 13:
+          recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+          break;
+        case 23:
+          break;
+        case 22:
+          prevEffectDuration = finishedWork.stateNode;
+          var _current = finishedWork.alternate;
+          null !== finishedWork.memoizedState ? prevEffectDuration._visibility & 2 ? recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions) : finishedWork.mode & 1 ? recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork) : (prevEffectDuration._visibility |= 2, recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions)) : prevEffectDuration._visibility & 2 ? recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions) : (prevEffectDuration._visibility |= 2, recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, 0 !== (finishedWork.subtreeFlags & 10256)));
+          flags & 2048 && commitOffscreenPassiveMountEffects(_current, finishedWork);
+          break;
+        case 24:
+          recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+          flags & 2048 && commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
+          break;
+        default:
+          recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+      }
+    }
+    function recursivelyTraverseReconnectPassiveEffects(finishedRoot, parentFiber, committedLanes, committedTransitions, includeWorkInProgressEffects) {
+      includeWorkInProgressEffects = includeWorkInProgressEffects && 0 !== (parentFiber.subtreeFlags & 10256);
+      for (parentFiber = parentFiber.child; null !== parentFiber;) reconnectPassiveEffects(finishedRoot, parentFiber, committedLanes, committedTransitions, includeWorkInProgressEffects), parentFiber = parentFiber.sibling;
+    }
+    function reconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects) {
+      var flags = finishedWork.flags;
+      switch (finishedWork.tag) {
+        case 0:
+        case 11:
+        case 15:
+          recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+          commitHookPassiveMountEffects(finishedWork, Passive);
+          break;
+        case 23:
+          break;
+        case 22:
+          var _instance2 = finishedWork.stateNode;
+          null !== finishedWork.memoizedState ? _instance2._visibility & 2 ? recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects) : finishedWork.mode & 1 ? recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork) : (_instance2._visibility |= 2, recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects)) : (_instance2._visibility |= 2, recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects));
+          includeWorkInProgressEffects && flags & 2048 && commitOffscreenPassiveMountEffects(finishedWork.alternate, finishedWork);
+          break;
+        case 24:
+          recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+          includeWorkInProgressEffects && flags & 2048 && commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
+          break;
+        default:
+          recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+      }
+    }
+    function recursivelyTraverseAtomicPassiveEffects(finishedRoot$jscomp$0, parentFiber) {
+      if (parentFiber.subtreeFlags & 10256) for (parentFiber = parentFiber.child; null !== parentFiber;) {
+        var finishedRoot = finishedRoot$jscomp$0,
+          finishedWork = parentFiber,
+          flags = finishedWork.flags;
+        switch (finishedWork.tag) {
+          case 22:
+            recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+            flags & 2048 && commitOffscreenPassiveMountEffects(finishedWork.alternate, finishedWork);
+            break;
+          case 24:
+            recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+            flags & 2048 && commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
+            break;
+          default:
+            recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+        }
+        parentFiber = parentFiber.sibling;
+      }
+    }
+    function recursivelyAccumulateSuspenseyCommit(parentFiber) {
+      if (parentFiber.subtreeFlags & suspenseyCommitFlag) for (parentFiber = parentFiber.child; null !== parentFiber;) accumulateSuspenseyCommitOnFiber(parentFiber), parentFiber = parentFiber.sibling;
+    }
+    function accumulateSuspenseyCommitOnFiber(fiber) {
+      switch (fiber.tag) {
+        case 26:
+          recursivelyAccumulateSuspenseyCommit(fiber);
+          fiber.flags & suspenseyCommitFlag && null !== fiber.memoizedState && suspendResource();
+          break;
+        case 5:
+          recursivelyAccumulateSuspenseyCommit(fiber);
+          break;
+        case 3:
+        case 4:
+          recursivelyAccumulateSuspenseyCommit(fiber);
+          break;
+        case 22:
+          if (null === fiber.memoizedState) {
+            var current = fiber.alternate;
+            null !== current && null !== current.memoizedState ? (current = suspenseyCommitFlag, suspenseyCommitFlag = 16777216, recursivelyAccumulateSuspenseyCommit(fiber), suspenseyCommitFlag = current) : recursivelyAccumulateSuspenseyCommit(fiber);
+          }
+          break;
+        default:
+          recursivelyAccumulateSuspenseyCommit(fiber);
+      }
+    }
+    function detachAlternateSiblings(parentFiber) {
+      var previousFiber = parentFiber.alternate;
+      if (null !== previousFiber && (parentFiber = previousFiber.child, null !== parentFiber)) {
+        previousFiber.child = null;
+        do previousFiber = parentFiber.sibling, parentFiber.sibling = null, parentFiber = previousFiber; while (null !== parentFiber);
+      }
+    }
+    function recursivelyTraversePassiveUnmountEffects(parentFiber) {
+      var deletions = parentFiber.deletions;
+      if (0 !== (parentFiber.flags & 16)) {
+        if (null !== deletions) for (var i = 0; i < deletions.length; i++) {
+          var childToDelete = deletions[i];
+          nextEffect = childToDelete;
+          commitPassiveUnmountEffectsInsideOfDeletedTree_begin(childToDelete, parentFiber);
+        }
+        detachAlternateSiblings(parentFiber);
+      }
+      if (parentFiber.subtreeFlags & 10256) for (parentFiber = parentFiber.child; null !== parentFiber;) commitPassiveUnmountOnFiber(parentFiber), parentFiber = parentFiber.sibling;
+    }
+    function commitPassiveUnmountOnFiber(finishedWork) {
+      switch (finishedWork.tag) {
+        case 0:
+        case 11:
+        case 15:
+          recursivelyTraversePassiveUnmountEffects(finishedWork);
+          finishedWork.flags & 2048 && commitHookPassiveUnmountEffects(finishedWork, finishedWork.return, Passive | HasEffect);
+          break;
+        case 3:
+          var prevEffectDuration = pushNestedEffectDurations();
+          recursivelyTraversePassiveUnmountEffects(finishedWork);
+          finishedWork.stateNode.passiveEffectDuration += popNestedEffectDurations(prevEffectDuration);
+          break;
+        case 12:
+          prevEffectDuration = pushNestedEffectDurations();
+          recursivelyTraversePassiveUnmountEffects(finishedWork);
+          finishedWork.stateNode.passiveEffectDuration += bubbleNestedEffectDurations(prevEffectDuration);
+          break;
+        case 22:
+          prevEffectDuration = finishedWork.stateNode;
+          null !== finishedWork.memoizedState && prevEffectDuration._visibility & 2 && (null === finishedWork.return || 13 !== finishedWork.return.tag) ? (prevEffectDuration._visibility &= -3, recursivelyTraverseDisconnectPassiveEffects(finishedWork)) : recursivelyTraversePassiveUnmountEffects(finishedWork);
+          break;
+        default:
+          recursivelyTraversePassiveUnmountEffects(finishedWork);
+      }
+    }
+    function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
+      var deletions = parentFiber.deletions;
+      if (0 !== (parentFiber.flags & 16)) {
+        if (null !== deletions) for (var i = 0; i < deletions.length; i++) {
+          var childToDelete = deletions[i];
+          nextEffect = childToDelete;
+          commitPassiveUnmountEffectsInsideOfDeletedTree_begin(childToDelete, parentFiber);
+        }
+        detachAlternateSiblings(parentFiber);
+      }
+      for (parentFiber = parentFiber.child; null !== parentFiber;) disconnectPassiveEffect(parentFiber), parentFiber = parentFiber.sibling;
+    }
+    function disconnectPassiveEffect(finishedWork) {
+      switch (finishedWork.tag) {
+        case 0:
+        case 11:
+        case 15:
+          commitHookPassiveUnmountEffects(finishedWork, finishedWork.return, Passive);
+          recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+          break;
+        case 22:
+          var instance = finishedWork.stateNode;
+          instance._visibility & 2 && (instance._visibility &= -3, recursivelyTraverseDisconnectPassiveEffects(finishedWork));
+          break;
+        default:
+          recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+      }
+    }
+    function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(deletedSubtreeRoot, nearestMountedAncestor) {
+      for (; null !== nextEffect;) {
+        var fiber = nextEffect,
+          current = fiber;
+        switch (current.tag) {
+          case 0:
+          case 11:
+          case 15:
+            commitHookPassiveUnmountEffects(current, nearestMountedAncestor, Passive);
+            break;
+          case 23:
+          case 22:
+            null !== current.memoizedState && null !== current.memoizedState.cachePool && (current = current.memoizedState.cachePool.pool, null != current && retainCache(current));
+            break;
+          case 24:
+            releaseCache(current.memoizedState.cache);
+        }
+        current = fiber.child;
+        if (null !== current) current.return = fiber, nextEffect = current;else a: for (fiber = deletedSubtreeRoot; null !== nextEffect;) {
+          current = nextEffect;
+          var sibling = current.sibling,
+            returnFiber = current.return;
+          detachFiberAfterEffects(current);
+          if (current === fiber) {
+            nextEffect = null;
+            break a;
+          }
+          if (null !== sibling) {
+            sibling.return = returnFiber;
+            nextEffect = sibling;
+            break a;
+          }
+          nextEffect = returnFiber;
+        }
+      }
+    }
+    function invokeLayoutEffectMountInDEV(fiber) {
+      switch (fiber.tag) {
+        case 0:
+        case 11:
+        case 15:
+          commitHookEffectListMount(Layout | HasEffect, fiber);
+          break;
+        case 1:
+          commitClassDidMount(fiber);
+      }
+    }
+    function invokePassiveEffectMountInDEV(fiber) {
+      switch (fiber.tag) {
+        case 0:
+        case 11:
+        case 15:
+          commitHookEffectListMount(Passive | HasEffect, fiber);
+      }
+    }
+    function invokeLayoutEffectUnmountInDEV(fiber) {
+      switch (fiber.tag) {
+        case 0:
+        case 11:
+        case 15:
+          commitHookEffectListUnmount(Layout | HasEffect, fiber, fiber.return);
+          break;
+        case 1:
+          var instance = fiber.stateNode;
+          "function" === typeof instance.componentWillUnmount && safelyCallComponentWillUnmount(fiber, fiber.return, instance);
+      }
+    }
+    function invokePassiveEffectUnmountInDEV(fiber) {
+      switch (fiber.tag) {
+        case 0:
+        case 11:
+        case 15:
+          commitHookEffectListUnmount(Passive | HasEffect, fiber, fiber.return);
+      }
+    }
+    function isConcurrentActEnvironment() {
+      var isReactActEnvironmentGlobal = "undefined" !== typeof IS_REACT_ACT_ENVIRONMENT ? IS_REACT_ACT_ENVIRONMENT : void 0;
+      isReactActEnvironmentGlobal || null === ReactSharedInternals.actQueue || console.error("The current testing environment is not configured to support act(...)");
+      return isReactActEnvironmentGlobal;
+    }
+    function requestUpdateLane(fiber) {
+      if (0 === (fiber.mode & 1)) return 2;
+      if ((executionContext & RenderContext) !== NoContext && 0 !== workInProgressRootRenderLanes) return workInProgressRootRenderLanes & -workInProgressRootRenderLanes;
+      var transition = ReactSharedInternals.T;
+      return null !== transition ? (transition._updatedFibers || (transition._updatedFibers = new Set()), transition._updatedFibers.add(fiber), fiber = currentEntangledLane, 0 !== fiber ? fiber : requestTransitionLane()) : resolveUpdatePriority();
+    }
+    function requestDeferredLane() {
+      0 === workInProgressDeferredLane && (workInProgressDeferredLane = 0 !== (workInProgressRootRenderLanes & 536870912) ? 536870912 : claimNextTransitionLane());
+      var suspenseHandler = suspenseHandlerStackCursor.current;
+      null !== suspenseHandler && (suspenseHandler.flags |= 32);
+      return workInProgressDeferredLane;
+    }
+    function scheduleUpdateOnFiber(root, fiber, lane) {
+      isRunningInsertionEffect && console.error("useInsertionEffect must not schedule updates.");
+      isFlushingPassiveEffects && (didScheduleUpdateDuringPassiveEffects = !0);
+      if (root === workInProgressRoot && (workInProgressSuspendedReason === SuspendedOnData || workInProgressSuspendedReason === SuspendedOnAction) || null !== root.cancelPendingCommit) prepareFreshStack(root, 0), markRootSuspended(root, workInProgressRootRenderLanes, workInProgressDeferredLane, !1);
+      markRootUpdated$1(root, lane);
+      if (0 !== (executionContext & RenderContext) && root === workInProgressRoot) {
+        if (isRendering) switch (fiber.tag) {
+          case 0:
+          case 11:
+          case 15:
+            root = workInProgress && getComponentNameFromFiber(workInProgress) || "Unknown";
+            didWarnAboutUpdateInRenderForAnotherComponent.has(root) || (didWarnAboutUpdateInRenderForAnotherComponent.add(root), fiber = getComponentNameFromFiber(fiber) || "Unknown", console.error("Cannot update a component (`%s`) while rendering a different component (`%s`). To locate the bad setState() call inside `%s`, follow the stack trace as described in https://react.dev/link/setstate-in-render", fiber, root, root));
+            break;
+          case 1:
+            didWarnAboutUpdateInRender || (console.error("Cannot update during an existing state transition (such as within `render`). Render methods should be a pure function of props and state."), didWarnAboutUpdateInRender = !0);
+        }
+      } else isDevToolsPresent && addFiberToLanesMap(root, fiber, lane), warnIfUpdatesNotWrappedWithActDEV(fiber), root === workInProgressRoot && ((executionContext & RenderContext) === NoContext && (workInProgressRootInterleavedUpdatedLanes |= lane), workInProgressRootExitStatus === RootSuspendedWithDelay && markRootSuspended(root, workInProgressRootRenderLanes, workInProgressDeferredLane, !1)), ensureRootIsScheduled(root), 2 !== lane || executionContext !== NoContext || 0 !== (fiber.mode & 1) || ReactSharedInternals.isBatchingLegacy || (workInProgressRootRenderTargetTime = now$1() + RENDER_TIMEOUT_MS, flushSyncWorkAcrossRoots_impl(0, !0));
+    }
+    function performWorkOnRoot(root, lanes, forceSync) {
+      if ((executionContext & (RenderContext | CommitContext)) !== NoContext) throw Error("Should not already be working.");
+      var shouldTimeSlice = !forceSync && 0 === (lanes & 124) && 0 === (lanes & root.expiredLanes) || checkIfRootIsPrerendering(root, lanes),
+        exitStatus = shouldTimeSlice ? renderRootConcurrent(root, lanes) : renderRootSync(root, lanes, !0),
+        renderWasConcurrent = shouldTimeSlice;
+      do {
+        if (exitStatus === RootInProgress) {
+          workInProgressRootIsPrerendering && !shouldTimeSlice && markRootSuspended(root, lanes, 0, !1);
+          break;
+        } else {
+          forceSync = root.current.alternate;
+          if (renderWasConcurrent && !isRenderConsistentWithExternalStores(forceSync)) {
+            exitStatus = renderRootSync(root, lanes, !1);
+            renderWasConcurrent = !1;
+            continue;
+          }
+          if (0 !== root.tag && exitStatus === RootErrored) {
+            var lanesThatJustErrored = lanes;
+            root.errorRecoveryDisabledLanes & lanesThatJustErrored ? renderWasConcurrent = 0 : (renderWasConcurrent = root.pendingLanes & -536870913, renderWasConcurrent = 0 !== renderWasConcurrent ? renderWasConcurrent : renderWasConcurrent & 536870912 ? 536870912 : 0);
+            if (0 !== renderWasConcurrent) {
+              lanes = renderWasConcurrent;
+              a: {
+                exitStatus = root;
+                var originallyAttemptedLanes = lanesThatJustErrored;
+                lanesThatJustErrored = workInProgressRootConcurrentErrors;
+                var wasRootDehydrated = supportsHydration;
+                renderWasConcurrent = renderRootSync(exitStatus, renderWasConcurrent, !1);
+                if (renderWasConcurrent !== RootErrored) {
+                  if (workInProgressRootDidAttachPingListener && !wasRootDehydrated) {
+                    exitStatus.errorRecoveryDisabledLanes |= originallyAttemptedLanes;
+                    workInProgressRootInterleavedUpdatedLanes |= originallyAttemptedLanes;
+                    exitStatus = RootSuspendedWithDelay;
+                    break a;
+                  }
+                  exitStatus = workInProgressRootRecoverableErrors;
+                  workInProgressRootRecoverableErrors = lanesThatJustErrored;
+                  null !== exitStatus && (null === workInProgressRootRecoverableErrors ? workInProgressRootRecoverableErrors = exitStatus : workInProgressRootRecoverableErrors.push.apply(workInProgressRootRecoverableErrors, exitStatus));
+                }
+                exitStatus = renderWasConcurrent;
+              }
+              renderWasConcurrent = !1;
+              if (exitStatus !== RootErrored) continue;
+            }
+          }
+          if (exitStatus === RootFatalErrored) {
+            prepareFreshStack(root, 0);
+            markRootSuspended(root, lanes, 0, !0);
+            break;
+          }
+          a: {
+            shouldTimeSlice = root;
+            renderWasConcurrent = exitStatus;
+            switch (renderWasConcurrent) {
+              case RootInProgress:
+              case RootFatalErrored:
+                throw Error("Root did not complete. This is a bug in React.");
+              case RootSuspendedWithDelay:
+                if ((lanes & 4194048) !== lanes) break;
+              case RootSuspendedAtTheShell:
+                markRootSuspended(shouldTimeSlice, lanes, workInProgressDeferredLane, !workInProgressRootDidSkipSuspendedSiblings);
+                break a;
+              case RootErrored:
+                workInProgressRootRecoverableErrors = null;
+                break;
+              case RootSuspended:
+              case RootCompleted:
+                break;
+              default:
+                throw Error("Unknown root exit status.");
+            }
+            if (null !== ReactSharedInternals.actQueue) commitRoot(shouldTimeSlice, forceSync, lanes, workInProgressRootRecoverableErrors, workInProgressTransitions, workInProgressRootDidIncludeRecursiveRenderUpdate, workInProgressDeferredLane, workInProgressRootInterleavedUpdatedLanes, workInProgressSuspendedRetryLanes);else {
+              if ((lanes & 62914560) === lanes && renderWasConcurrent === RootSuspended && (exitStatus = globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now$1(), 10 < exitStatus)) {
+                markRootSuspended(shouldTimeSlice, lanes, workInProgressDeferredLane, !workInProgressRootDidSkipSuspendedSiblings);
+                if (0 !== getNextLanes(shouldTimeSlice, 0, !0)) break a;
+                shouldTimeSlice.timeoutHandle = scheduleTimeout(commitRootWhenReady.bind(null, shouldTimeSlice, forceSync, workInProgressRootRecoverableErrors, workInProgressTransitions, workInProgressRootDidIncludeRecursiveRenderUpdate, lanes, workInProgressDeferredLane, workInProgressRootInterleavedUpdatedLanes, workInProgressSuspendedRetryLanes, workInProgressRootDidSkipSuspendedSiblings, renderWasConcurrent, THROTTLED_COMMIT, -0, 0), exitStatus);
+                break a;
+              }
+              commitRootWhenReady(shouldTimeSlice, forceSync, workInProgressRootRecoverableErrors, workInProgressTransitions, workInProgressRootDidIncludeRecursiveRenderUpdate, lanes, workInProgressDeferredLane, workInProgressRootInterleavedUpdatedLanes, workInProgressSuspendedRetryLanes, workInProgressRootDidSkipSuspendedSiblings, renderWasConcurrent, IMMEDIATE_COMMIT, -0, 0);
+            }
+          }
+        }
+        break;
+      } while (1);
+      ensureRootIsScheduled(root);
+    }
+    function commitRootWhenReady(root, finishedWork, recoverableErrors, transitions, didIncludeRenderPhaseUpdate, lanes, spawnedLane, updatedLanes, suspendedRetryLanes) {
+      root.timeoutHandle = noTimeout;
+      var subtreeFlags = finishedWork.subtreeFlags;
+      (subtreeFlags & 8192 || 16785408 === (subtreeFlags & 16785408)) && accumulateSuspenseyCommitOnFiber(finishedWork);
+      commitRoot(root, finishedWork, lanes, recoverableErrors, transitions, didIncludeRenderPhaseUpdate, spawnedLane, updatedLanes, suspendedRetryLanes);
+    }
+    function isRenderConsistentWithExternalStores(finishedWork) {
+      for (var node = finishedWork;;) {
+        var tag = node.tag;
+        if ((0 === tag || 11 === tag || 15 === tag) && node.flags & 16384 && (tag = node.updateQueue, null !== tag && (tag = tag.stores, null !== tag))) for (var i = 0; i < tag.length; i++) {
+          var check = tag[i],
+            getSnapshot = check.getSnapshot;
+          check = check.value;
+          try {
+            if (!objectIs(getSnapshot(), check)) return !1;
+          } catch (error) {
+            return !1;
+          }
+        }
+        tag = node.child;
+        if (node.subtreeFlags & 16384 && null !== tag) tag.return = node, node = tag;else {
+          if (node === finishedWork) break;
+          for (; null === node.sibling;) {
+            if (null === node.return || node.return === finishedWork) return !0;
+            node = node.return;
+          }
+          node.sibling.return = node.return;
+          node = node.sibling;
+        }
+      }
+      return !0;
+    }
+    function markRootSuspended(root, suspendedLanes, spawnedLane, didAttemptEntireTree) {
+      suspendedLanes &= ~workInProgressRootPingedLanes;
+      suspendedLanes &= ~workInProgressRootInterleavedUpdatedLanes;
+      root.suspendedLanes |= suspendedLanes;
+      root.pingedLanes &= ~suspendedLanes;
+      didAttemptEntireTree && (root.warmLanes |= suspendedLanes);
+      didAttemptEntireTree = root.expirationTimes;
+      for (var lanes = suspendedLanes; 0 < lanes;) {
+        var index = 31 - clz32(lanes),
+          lane = 1 << index;
+        didAttemptEntireTree[index] = -1;
+        lanes &= ~lane;
+      }
+      0 !== spawnedLane && markSpawnedDeferredLane(root, spawnedLane, suspendedLanes);
+    }
+    function flushSyncWork() {
+      return (executionContext & (RenderContext | CommitContext)) === NoContext ? (flushSyncWorkAcrossRoots_impl(0, !1), !1) : !0;
+    }
+    function resetWorkInProgressStack() {
+      if (null !== workInProgress) {
+        if (workInProgressSuspendedReason === NotSuspended) var interruptedWork = workInProgress.return;else interruptedWork = workInProgress, resetContextDependencies(), resetHooksOnUnwind(interruptedWork), thenableState = null, thenableIndexCounter = 0, interruptedWork = workInProgress;
+        for (; null !== interruptedWork;) unwindInterruptedWork(interruptedWork.alternate, interruptedWork), interruptedWork = interruptedWork.return;
+        workInProgress = null;
+      }
+    }
+    function prepareFreshStack(root, lanes) {
+      var timeoutHandle = root.timeoutHandle;
+      timeoutHandle !== noTimeout && (root.timeoutHandle = noTimeout, cancelTimeout(timeoutHandle));
+      timeoutHandle = root.cancelPendingCommit;
+      null !== timeoutHandle && (root.cancelPendingCommit = null, timeoutHandle());
+      resetWorkInProgressStack();
+      workInProgressRoot = root;
+      workInProgress = timeoutHandle = createWorkInProgress(root.current, null);
+      workInProgressRootRenderLanes = lanes;
+      workInProgressSuspendedReason = NotSuspended;
+      workInProgressThrownValue = null;
+      workInProgressRootDidSkipSuspendedSiblings = !1;
+      workInProgressRootIsPrerendering = checkIfRootIsPrerendering(root, lanes);
+      workInProgressRootDidAttachPingListener = !1;
+      workInProgressRootExitStatus = RootInProgress;
+      workInProgressSuspendedRetryLanes = workInProgressDeferredLane = workInProgressRootPingedLanes = workInProgressRootInterleavedUpdatedLanes = workInProgressRootSkippedLanes = 0;
+      workInProgressRootRecoverableErrors = workInProgressRootConcurrentErrors = null;
+      workInProgressRootDidIncludeRecursiveRenderUpdate = !1;
+      0 !== (lanes & 8) && (lanes |= lanes & 32);
+      var allEntangledLanes = root.entangledLanes;
+      if (0 !== allEntangledLanes) for (root = root.entanglements, allEntangledLanes &= lanes; 0 < allEntangledLanes;) {
+        var index = 31 - clz32(allEntangledLanes),
+          lane = 1 << index;
+        lanes |= root[index];
+        allEntangledLanes &= ~lane;
+      }
+      entangledRenderLanes = lanes;
+      finishQueueingConcurrentUpdates();
+      lanes = getCurrentTime();
+      1e3 < lanes - lastResetTime && (ReactSharedInternals.recentlyCreatedOwnerStacks = 0, lastResetTime = lanes);
+      ReactStrictModeWarnings.discardPendingWarnings();
+      return timeoutHandle;
+    }
+    function handleThrow(root, thrownValue) {
+      currentlyRenderingFiber = null;
+      ReactSharedInternals.H = ContextOnlyDispatcher;
+      ReactSharedInternals.getCurrentStack = null;
+      isRendering = !1;
+      current = null;
+      thrownValue === SuspenseException || thrownValue === SuspenseActionException ? (thrownValue = getSuspendedThenable(), workInProgressSuspendedReason = SuspendedOnImmediate) : thrownValue === SuspenseyCommitException ? (thrownValue = getSuspendedThenable(), workInProgressSuspendedReason = SuspendedOnInstance) : workInProgressSuspendedReason = thrownValue === SelectiveHydrationException ? SuspendedOnHydration : null !== thrownValue && "object" === typeof thrownValue && "function" === typeof thrownValue.then ? SuspendedOnDeprecatedThrowPromise : SuspendedOnError;
+      workInProgressThrownValue = thrownValue;
+      var erroredWork = workInProgress;
+      if (null === erroredWork) workInProgressRootExitStatus = RootFatalErrored, logUncaughtError(root, createCapturedValueAtFiber(thrownValue, root.current));else switch (erroredWork.mode & 2 && stopProfilerTimerIfRunningAndRecordDuration(erroredWork), markComponentRenderStopped(), workInProgressSuspendedReason) {
+        case SuspendedOnError:
+          null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markComponentErrored && injectedProfilingHooks.markComponentErrored(erroredWork, thrownValue, workInProgressRootRenderLanes);
+          break;
+        case SuspendedOnData:
+        case SuspendedOnAction:
+        case SuspendedOnImmediate:
+        case SuspendedOnDeprecatedThrowPromise:
+        case SuspendedAndReadyToContinue:
+          null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markComponentSuspended && injectedProfilingHooks.markComponentSuspended(erroredWork, thrownValue, workInProgressRootRenderLanes);
+      }
+    }
+    function pushDispatcher() {
+      var prevDispatcher = ReactSharedInternals.H;
+      ReactSharedInternals.H = ContextOnlyDispatcher;
+      return null === prevDispatcher ? ContextOnlyDispatcher : prevDispatcher;
+    }
+    function pushAsyncDispatcher() {
+      var prevAsyncDispatcher = ReactSharedInternals.A;
+      ReactSharedInternals.A = DefaultAsyncDispatcher;
+      return prevAsyncDispatcher;
+    }
+    function renderDidSuspendDelayIfPossible() {
+      workInProgressRootExitStatus = RootSuspendedWithDelay;
+      workInProgressRootDidSkipSuspendedSiblings || (workInProgressRootRenderLanes & 4194048) !== workInProgressRootRenderLanes && null !== suspenseHandlerStackCursor.current || (workInProgressRootIsPrerendering = !0);
+      0 === (workInProgressRootSkippedLanes & 134217727) && 0 === (workInProgressRootInterleavedUpdatedLanes & 134217727) || null === workInProgressRoot || markRootSuspended(workInProgressRoot, workInProgressRootRenderLanes, workInProgressDeferredLane, !1);
+    }
+    function renderRootSync(root, lanes, shouldYieldForPrerendering) {
+      var prevExecutionContext = executionContext;
+      executionContext |= RenderContext;
+      var prevDispatcher = pushDispatcher(),
+        prevAsyncDispatcher = pushAsyncDispatcher();
+      if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
+        if (isDevToolsPresent) {
+          var memoizedUpdaters = root.memoizedUpdaters;
+          0 < memoizedUpdaters.size && (restorePendingUpdaters(root, workInProgressRootRenderLanes), memoizedUpdaters.clear());
+          movePendingFibersToMemoized(root, lanes);
+        }
+        workInProgressTransitions = null;
+        prepareFreshStack(root, lanes);
+      }
+      markRenderStarted(lanes);
+      lanes = !1;
+      memoizedUpdaters = workInProgressRootExitStatus;
+      a: do try {
+        if (workInProgressSuspendedReason !== NotSuspended && null !== workInProgress) {
+          var unitOfWork = workInProgress,
+            thrownValue = workInProgressThrownValue;
+          switch (workInProgressSuspendedReason) {
+            case SuspendedOnHydration:
+              resetWorkInProgressStack();
+              memoizedUpdaters = RootSuspendedAtTheShell;
+              break a;
+            case SuspendedOnImmediate:
+            case SuspendedOnData:
+            case SuspendedOnAction:
+            case SuspendedOnDeprecatedThrowPromise:
+              null === suspenseHandlerStackCursor.current && (lanes = !0);
+              var reason = workInProgressSuspendedReason;
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              throwAndUnwindWorkLoop(root, unitOfWork, thrownValue, reason);
+              if (shouldYieldForPrerendering && workInProgressRootIsPrerendering) {
+                memoizedUpdaters = RootInProgress;
+                break a;
+              }
+              break;
+            default:
+              reason = workInProgressSuspendedReason, workInProgressSuspendedReason = NotSuspended, workInProgressThrownValue = null, throwAndUnwindWorkLoop(root, unitOfWork, thrownValue, reason);
+          }
+        }
+        workLoopSync();
+        memoizedUpdaters = workInProgressRootExitStatus;
+        break;
+      } catch (thrownValue$5) {
+        handleThrow(root, thrownValue$5);
+      } while (1);
+      lanes && root.shellSuspendCounter++;
+      resetContextDependencies();
+      executionContext = prevExecutionContext;
+      ReactSharedInternals.H = prevDispatcher;
+      ReactSharedInternals.A = prevAsyncDispatcher;
+      markRenderStopped();
+      null === workInProgress && (workInProgressRoot = null, workInProgressRootRenderLanes = 0, finishQueueingConcurrentUpdates());
+      return memoizedUpdaters;
+    }
+    function workLoopSync() {
+      for (; null !== workInProgress;) performUnitOfWork(workInProgress);
+    }
+    function renderRootConcurrent(root, lanes) {
+      var prevExecutionContext = executionContext;
+      executionContext |= RenderContext;
+      var prevDispatcher = pushDispatcher(),
+        prevAsyncDispatcher = pushAsyncDispatcher();
+      if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
+        if (isDevToolsPresent) {
+          var memoizedUpdaters = root.memoizedUpdaters;
+          0 < memoizedUpdaters.size && (restorePendingUpdaters(root, workInProgressRootRenderLanes), memoizedUpdaters.clear());
+          movePendingFibersToMemoized(root, lanes);
+        }
+        workInProgressTransitions = null;
+        workInProgressRootRenderTargetTime = now$1() + RENDER_TIMEOUT_MS;
+        prepareFreshStack(root, lanes);
+      } else workInProgressRootIsPrerendering = checkIfRootIsPrerendering(root, lanes);
+      markRenderStarted(lanes);
+      a: do try {
+        if (workInProgressSuspendedReason !== NotSuspended && null !== workInProgress) b: switch (lanes = workInProgress, memoizedUpdaters = workInProgressThrownValue, workInProgressSuspendedReason) {
+          case SuspendedOnError:
+            workInProgressSuspendedReason = NotSuspended;
+            workInProgressThrownValue = null;
+            throwAndUnwindWorkLoop(root, lanes, memoizedUpdaters, SuspendedOnError);
+            break;
+          case SuspendedOnData:
+          case SuspendedOnAction:
+            if (isThenableResolved(memoizedUpdaters)) {
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              replaySuspendedUnitOfWork(lanes);
+              break;
+            }
+            lanes = function lanes() {
+              workInProgressSuspendedReason !== SuspendedOnData && workInProgressSuspendedReason !== SuspendedOnAction || workInProgressRoot !== root || (workInProgressSuspendedReason = SuspendedAndReadyToContinue);
+              ensureRootIsScheduled(root);
+            };
+            memoizedUpdaters.then(lanes, lanes);
+            break a;
+          case SuspendedOnImmediate:
+            workInProgressSuspendedReason = SuspendedAndReadyToContinue;
+            break a;
+          case SuspendedOnInstance:
+            workInProgressSuspendedReason = SuspendedOnInstanceAndReadyToContinue;
+            break a;
+          case SuspendedAndReadyToContinue:
+            isThenableResolved(memoizedUpdaters) ? (workInProgressSuspendedReason = NotSuspended, workInProgressThrownValue = null, replaySuspendedUnitOfWork(lanes)) : (workInProgressSuspendedReason = NotSuspended, workInProgressThrownValue = null, throwAndUnwindWorkLoop(root, lanes, memoizedUpdaters, SuspendedAndReadyToContinue));
+            break;
+          case SuspendedOnInstanceAndReadyToContinue:
+            var resource = null;
+            switch (workInProgress.tag) {
+              case 26:
+                resource = workInProgress.memoizedState;
+              case 5:
+              case 27:
+                var hostFiber = workInProgress;
+                if (resource ? preloadResource(resource) : 1) {
+                  workInProgressSuspendedReason = NotSuspended;
+                  workInProgressThrownValue = null;
+                  var sibling = hostFiber.sibling;
+                  if (null !== sibling) workInProgress = sibling;else {
+                    var returnFiber = hostFiber.return;
+                    null !== returnFiber ? (workInProgress = returnFiber, completeUnitOfWork(returnFiber)) : workInProgress = null;
+                  }
+                  break b;
+                }
+                break;
+              default:
+                console.error("Unexpected type of fiber triggered a suspensey commit. This is a bug in React.");
+            }
+            workInProgressSuspendedReason = NotSuspended;
+            workInProgressThrownValue = null;
+            throwAndUnwindWorkLoop(root, lanes, memoizedUpdaters, SuspendedOnInstanceAndReadyToContinue);
+            break;
+          case SuspendedOnDeprecatedThrowPromise:
+            workInProgressSuspendedReason = NotSuspended;
+            workInProgressThrownValue = null;
+            throwAndUnwindWorkLoop(root, lanes, memoizedUpdaters, SuspendedOnDeprecatedThrowPromise);
+            break;
+          case SuspendedOnHydration:
+            resetWorkInProgressStack();
+            workInProgressRootExitStatus = RootSuspendedAtTheShell;
+            break a;
+          default:
+            throw Error("Unexpected SuspendedReason. This is a bug in React.");
+        }
+        null !== ReactSharedInternals.actQueue ? workLoopSync() : workLoopConcurrentByScheduler();
+        break;
+      } catch (thrownValue$6) {
+        handleThrow(root, thrownValue$6);
+      } while (1);
+      resetContextDependencies();
+      ReactSharedInternals.H = prevDispatcher;
+      ReactSharedInternals.A = prevAsyncDispatcher;
+      executionContext = prevExecutionContext;
+      if (null !== workInProgress) return null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markRenderYielded && injectedProfilingHooks.markRenderYielded(), RootInProgress;
+      markRenderStopped();
+      workInProgressRoot = null;
+      workInProgressRootRenderLanes = 0;
+      finishQueueingConcurrentUpdates();
+      return workInProgressRootExitStatus;
+    }
+    function workLoopConcurrentByScheduler() {
+      for (; null !== workInProgress && !shouldYield();) performUnitOfWork(workInProgress);
+    }
+    function performUnitOfWork(unitOfWork) {
+      var current = unitOfWork.alternate;
+      0 !== (unitOfWork.mode & 2) ? (startProfilerTimer(unitOfWork), current = runWithFiberInDEV(unitOfWork, beginWork, current, unitOfWork, entangledRenderLanes), stopProfilerTimerIfRunningAndRecordDuration(unitOfWork)) : current = runWithFiberInDEV(unitOfWork, beginWork, current, unitOfWork, entangledRenderLanes);
+      unitOfWork.memoizedProps = unitOfWork.pendingProps;
+      null === current ? completeUnitOfWork(unitOfWork) : workInProgress = current;
+    }
+    function replaySuspendedUnitOfWork(unitOfWork) {
+      var next = runWithFiberInDEV(unitOfWork, replayBeginWork, unitOfWork);
+      unitOfWork.memoizedProps = unitOfWork.pendingProps;
+      null === next ? completeUnitOfWork(unitOfWork) : workInProgress = next;
+    }
+    function replayBeginWork(unitOfWork) {
+      var current = unitOfWork.alternate,
+        isProfilingMode = 0 !== (unitOfWork.mode & 2);
+      isProfilingMode && startProfilerTimer(unitOfWork);
+      switch (unitOfWork.tag) {
+        case 15:
+        case 0:
+          current = replayFunctionComponent(current, unitOfWork, unitOfWork.pendingProps, unitOfWork.type, void 0, workInProgressRootRenderLanes);
+          break;
+        case 11:
+          current = replayFunctionComponent(current, unitOfWork, unitOfWork.pendingProps, unitOfWork.type.render, unitOfWork.ref, workInProgressRootRenderLanes);
+          break;
+        case 5:
+          resetHooksOnUnwind(unitOfWork);
+        default:
+          unwindInterruptedWork(current, unitOfWork), unitOfWork = workInProgress = resetWorkInProgress(unitOfWork, entangledRenderLanes), current = beginWork(current, unitOfWork, entangledRenderLanes);
+      }
+      isProfilingMode && stopProfilerTimerIfRunningAndRecordDuration(unitOfWork);
+      return current;
+    }
+    function throwAndUnwindWorkLoop(root, unitOfWork, thrownValue, suspendedReason) {
+      resetContextDependencies();
+      resetHooksOnUnwind(unitOfWork);
+      thenableState = null;
+      thenableIndexCounter = 0;
+      var returnFiber = unitOfWork.return;
+      try {
+        if (throwException(root, returnFiber, unitOfWork, thrownValue, workInProgressRootRenderLanes)) {
+          workInProgressRootExitStatus = RootFatalErrored;
+          logUncaughtError(root, createCapturedValueAtFiber(thrownValue, root.current));
+          workInProgress = null;
+          return;
+        }
+      } catch (error) {
+        if (null !== returnFiber) throw workInProgress = returnFiber, error;
+        workInProgressRootExitStatus = RootFatalErrored;
+        logUncaughtError(root, createCapturedValueAtFiber(thrownValue, root.current));
+        workInProgress = null;
+        return;
+      }
+      if (unitOfWork.flags & 32768) {
+        if (suspendedReason === SuspendedOnError) root = !0;else if (workInProgressRootIsPrerendering || 0 !== (workInProgressRootRenderLanes & 536870912)) root = !1;else if (workInProgressRootDidSkipSuspendedSiblings = root = !0, suspendedReason === SuspendedOnData || suspendedReason === SuspendedOnAction || suspendedReason === SuspendedOnImmediate || suspendedReason === SuspendedOnDeprecatedThrowPromise) suspendedReason = suspenseHandlerStackCursor.current, null !== suspendedReason && 13 === suspendedReason.tag && (suspendedReason.flags |= 16384);
+        unwindUnitOfWork(unitOfWork, root);
+      } else completeUnitOfWork(unitOfWork);
+    }
+    function completeUnitOfWork(unitOfWork) {
+      var completedWork = unitOfWork;
+      do {
+        if (0 !== (completedWork.flags & 32768)) {
+          unwindUnitOfWork(completedWork, workInProgressRootDidSkipSuspendedSiblings);
+          return;
+        }
+        var current = completedWork.alternate;
+        unitOfWork = completedWork.return;
+        startProfilerTimer(completedWork);
+        current = runWithFiberInDEV(completedWork, completeWork, current, completedWork, entangledRenderLanes);
+        0 !== (completedWork.mode & 2) && stopProfilerTimerIfRunningAndRecordIncompleteDuration(completedWork);
+        if (null !== current) {
+          workInProgress = current;
+          return;
+        }
+        completedWork = completedWork.sibling;
+        if (null !== completedWork) {
+          workInProgress = completedWork;
+          return;
+        }
+        workInProgress = completedWork = unitOfWork;
+      } while (null !== completedWork);
+      workInProgressRootExitStatus === RootInProgress && (workInProgressRootExitStatus = RootCompleted);
+    }
+    function unwindUnitOfWork(unitOfWork, skipSiblings) {
+      do {
+        var next = unwindWork(unitOfWork.alternate, unitOfWork);
+        if (null !== next) {
+          next.flags &= 32767;
+          workInProgress = next;
+          return;
+        }
+        if (0 !== (unitOfWork.mode & 2)) {
+          stopProfilerTimerIfRunningAndRecordIncompleteDuration(unitOfWork);
+          next = unitOfWork.actualDuration;
+          for (var child = unitOfWork.child; null !== child;) next += child.actualDuration, child = child.sibling;
+          unitOfWork.actualDuration = next;
+        }
+        next = unitOfWork.return;
+        null !== next && (next.flags |= 32768, next.subtreeFlags = 0, next.deletions = null);
+        if (!skipSiblings && (unitOfWork = unitOfWork.sibling, null !== unitOfWork)) {
+          workInProgress = unitOfWork;
+          return;
+        }
+        workInProgress = unitOfWork = next;
+      } while (null !== unitOfWork);
+      workInProgressRootExitStatus = RootSuspendedAtTheShell;
+      workInProgress = null;
+    }
+    function commitRoot(root, finishedWork, lanes, recoverableErrors, transitions, didIncludeRenderPhaseUpdate, spawnedLane, updatedLanes, suspendedRetryLanes) {
+      root.cancelPendingCommit = null;
+      do flushPendingEffects(); while (pendingEffectsStatus !== NO_PENDING_EFFECTS);
+      ReactStrictModeWarnings.flushLegacyContextWarning();
+      ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();
+      if ((executionContext & (RenderContext | CommitContext)) !== NoContext) throw Error("Should not already be working.");
+      null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markCommitStarted && injectedProfilingHooks.markCommitStarted(lanes);
+      if (null === finishedWork) markCommitStopped();else {
+        0 === lanes && console.error("finishedLanes should not be empty during a commit. This is a bug in React.");
+        if (finishedWork === root.current) throw Error("Cannot commit the same tree as before. This error is likely caused by a bug in React. Please file an issue.");
+        didIncludeRenderPhaseUpdate = finishedWork.lanes | finishedWork.childLanes;
+        didIncludeRenderPhaseUpdate |= concurrentlyUpdatedLanes;
+        markRootFinished(root, lanes, didIncludeRenderPhaseUpdate, spawnedLane, updatedLanes, suspendedRetryLanes);
+        root === workInProgressRoot && (workInProgress = workInProgressRoot = null, workInProgressRootRenderLanes = 0);
+        pendingFinishedWork = finishedWork;
+        pendingEffectsRoot = root;
+        pendingEffectsLanes = lanes;
+        pendingEffectsRemainingLanes = didIncludeRenderPhaseUpdate;
+        pendingPassiveTransitions = transitions;
+        pendingRecoverableErrors = recoverableErrors;
+        0 !== (finishedWork.subtreeFlags & 10256) || 0 !== (finishedWork.flags & 10256) ? (root.callbackNode = null, root.callbackPriority = 0, scheduleCallback(NormalPriority$1, function () {
+          flushPassiveEffects(!0);
+          return null;
+        })) : (root.callbackNode = null, root.callbackPriority = 0);
+        commitStartTime = now();
+        recoverableErrors = 0 !== (finishedWork.flags & 13878);
+        if (0 !== (finishedWork.subtreeFlags & 13878) || recoverableErrors) {
+          recoverableErrors = ReactSharedInternals.T;
+          ReactSharedInternals.T = null;
+          transitions = currentUpdatePriority;
+          currentUpdatePriority = DiscreteEventPriority;
+          spawnedLane = executionContext;
+          executionContext |= CommitContext;
+          try {
+            commitBeforeMutationEffects(root, finishedWork, lanes);
+          } finally {
+            executionContext = spawnedLane, currentUpdatePriority = transitions, ReactSharedInternals.T = recoverableErrors;
+          }
+        }
+        pendingEffectsStatus = PENDING_MUTATION_PHASE;
+        flushMutationEffects();
+        flushLayoutEffects();
+        flushSpawnedWork();
+      }
+    }
+    function flushMutationEffects() {
+      if (pendingEffectsStatus === PENDING_MUTATION_PHASE) {
+        pendingEffectsStatus = NO_PENDING_EFFECTS;
+        var root = pendingEffectsRoot,
+          finishedWork = pendingFinishedWork,
+          lanes = pendingEffectsLanes,
+          rootMutationHasEffect = 0 !== (finishedWork.flags & 13878);
+        if (0 !== (finishedWork.subtreeFlags & 13878) || rootMutationHasEffect) {
+          rootMutationHasEffect = ReactSharedInternals.T;
+          ReactSharedInternals.T = null;
+          var previousPriority = currentUpdatePriority;
+          currentUpdatePriority = DiscreteEventPriority;
+          var prevExecutionContext = executionContext;
+          executionContext |= CommitContext;
+          try {
+            inProgressLanes = lanes, inProgressRoot = root, commitMutationEffectsOnFiber(finishedWork, root), inProgressRoot = inProgressLanes = null;
+          } finally {
+            executionContext = prevExecutionContext, currentUpdatePriority = previousPriority, ReactSharedInternals.T = rootMutationHasEffect;
+          }
+        }
+        root.current = finishedWork;
+        pendingEffectsStatus = PENDING_LAYOUT_PHASE;
+      }
+    }
+    function flushLayoutEffects() {
+      if (pendingEffectsStatus === PENDING_LAYOUT_PHASE) {
+        pendingEffectsStatus = NO_PENDING_EFFECTS;
+        var root = pendingEffectsRoot,
+          finishedWork = pendingFinishedWork,
+          lanes = pendingEffectsLanes,
+          rootHasLayoutEffect = 0 !== (finishedWork.flags & 8772);
+        if (0 !== (finishedWork.subtreeFlags & 8772) || rootHasLayoutEffect) {
+          rootHasLayoutEffect = ReactSharedInternals.T;
+          ReactSharedInternals.T = null;
+          var previousPriority = currentUpdatePriority;
+          currentUpdatePriority = DiscreteEventPriority;
+          var prevExecutionContext = executionContext;
+          executionContext |= CommitContext;
+          try {
+            null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markLayoutEffectsStarted && injectedProfilingHooks.markLayoutEffectsStarted(lanes), inProgressLanes = lanes, inProgressRoot = root, commitLayoutEffectOnFiber(root, finishedWork.alternate, finishedWork), inProgressRoot = inProgressLanes = null, null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markLayoutEffectsStopped && injectedProfilingHooks.markLayoutEffectsStopped();
+          } finally {
+            executionContext = prevExecutionContext, currentUpdatePriority = previousPriority, ReactSharedInternals.T = rootHasLayoutEffect;
+          }
+        }
+        pendingEffectsStatus = PENDING_AFTER_MUTATION_PHASE;
+      }
+    }
+    function flushSpawnedWork() {
+      if (pendingEffectsStatus === PENDING_SPAWNED_WORK || pendingEffectsStatus === PENDING_AFTER_MUTATION_PHASE) {
+        pendingEffectsStatus = NO_PENDING_EFFECTS;
+        requestPaint();
+        var root = pendingEffectsRoot,
+          finishedWork = pendingFinishedWork,
+          lanes = pendingEffectsLanes,
+          recoverableErrors = pendingRecoverableErrors,
+          rootDidHavePassiveEffects = 0 !== (finishedWork.subtreeFlags & 10256) || 0 !== (finishedWork.flags & 10256);
+        rootDidHavePassiveEffects ? pendingEffectsStatus = PENDING_PASSIVE_PHASE : (pendingEffectsStatus = NO_PENDING_EFFECTS, pendingFinishedWork = pendingEffectsRoot = null, releaseRootPooledCache(root, root.pendingLanes), nestedPassiveUpdateCount = 0, rootWithPassiveNestedUpdates = null);
+        var remainingLanes = root.pendingLanes;
+        0 === remainingLanes && (legacyErrorBoundariesThatAlreadyFailed = null);
+        rootDidHavePassiveEffects || commitDoubleInvokeEffectsInDEV(root, !1);
+        rootDidHavePassiveEffects = lanesToEventPriority(lanes);
+        finishedWork = finishedWork.stateNode;
+        if (injectedHook && "function" === typeof injectedHook.onCommitFiberRoot) try {
+          var didError = 128 === (finishedWork.current.flags & 128);
+          switch (rootDidHavePassiveEffects) {
+            case DiscreteEventPriority:
+              var schedulerPriority = ImmediatePriority;
+              break;
+            case ContinuousEventPriority:
+              schedulerPriority = UserBlockingPriority;
+              break;
+            case DefaultEventPriority:
+              schedulerPriority = NormalPriority$1;
+              break;
+            case IdleEventPriority:
+              schedulerPriority = IdlePriority;
+              break;
+            default:
+              schedulerPriority = NormalPriority$1;
+          }
+          injectedHook.onCommitFiberRoot(rendererID, finishedWork, schedulerPriority, didError);
+        } catch (err) {
+          hasLoggedError || (hasLoggedError = !0, console.error("React instrumentation encountered an error: %s", err));
+        }
+        isDevToolsPresent && root.memoizedUpdaters.clear();
+        if (null !== recoverableErrors) {
+          didError = ReactSharedInternals.T;
+          schedulerPriority = currentUpdatePriority;
+          currentUpdatePriority = DiscreteEventPriority;
+          ReactSharedInternals.T = null;
+          try {
+            var onRecoverableError = root.onRecoverableError;
+            for (finishedWork = 0; finishedWork < recoverableErrors.length; finishedWork++) {
+              var recoverableError = recoverableErrors[finishedWork],
+                errorInfo = makeErrorInfo(recoverableError.stack);
+              runWithFiberInDEV(recoverableError.source, onRecoverableError, recoverableError.value, errorInfo);
+            }
+          } finally {
+            ReactSharedInternals.T = didError, currentUpdatePriority = schedulerPriority;
+          }
+        }
+        0 !== (pendingEffectsLanes & 3) && 0 !== root.tag && flushPendingEffects();
+        ensureRootIsScheduled(root);
+        remainingLanes = root.pendingLanes;
+        0 !== (lanes & 4194090) && 0 !== (remainingLanes & 42) ? (nestedUpdateScheduled = !0, root === rootWithNestedUpdates ? nestedUpdateCount++ : (nestedUpdateCount = 0, rootWithNestedUpdates = root)) : nestedUpdateCount = 0;
+        flushSyncWorkAcrossRoots_impl(0, !1);
+        markCommitStopped();
+      }
+    }
+    function makeErrorInfo(componentStack) {
+      componentStack = {
+        componentStack: componentStack
+      };
+      Object.defineProperty(componentStack, "digest", {
+        get: function get() {
+          console.error('You are accessing "digest" from the errorInfo object passed to onRecoverableError. This property is no longer provided as part of errorInfo but can be accessed as a property of the Error instance itself.');
+        }
+      });
+      return componentStack;
+    }
+    function releaseRootPooledCache(root, remainingLanes) {
+      0 === (root.pooledCacheLanes &= remainingLanes) && (remainingLanes = root.pooledCache, null != remainingLanes && (root.pooledCache = null, releaseCache(remainingLanes)));
+    }
+    function flushPendingEffects(wasDelayedCommit) {
+      flushMutationEffects();
+      flushLayoutEffects();
+      flushSpawnedWork();
+      return flushPassiveEffects(wasDelayedCommit);
+    }
+    function flushPassiveEffects() {
+      if (pendingEffectsStatus !== PENDING_PASSIVE_PHASE) return !1;
+      var root = pendingEffectsRoot,
+        remainingLanes = pendingEffectsRemainingLanes;
+      pendingEffectsRemainingLanes = 0;
+      var renderPriority = lanesToEventPriority(pendingEffectsLanes),
+        priority = 0 === DefaultEventPriority || DefaultEventPriority > renderPriority ? DefaultEventPriority : renderPriority;
+      renderPriority = ReactSharedInternals.T;
+      var previousPriority = currentUpdatePriority;
+      try {
+        currentUpdatePriority = priority;
+        ReactSharedInternals.T = null;
+        priority = pendingPassiveTransitions;
+        pendingPassiveTransitions = null;
+        var root$jscomp$0 = pendingEffectsRoot,
+          lanes = pendingEffectsLanes;
+        pendingEffectsStatus = NO_PENDING_EFFECTS;
+        pendingFinishedWork = pendingEffectsRoot = null;
+        pendingEffectsLanes = 0;
+        if ((executionContext & (RenderContext | CommitContext)) !== NoContext) throw Error("Cannot flush passive effects while already rendering.");
+        isFlushingPassiveEffects = !0;
+        didScheduleUpdateDuringPassiveEffects = !1;
+        null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markPassiveEffectsStarted && injectedProfilingHooks.markPassiveEffectsStarted(lanes);
+        var prevExecutionContext = executionContext;
+        executionContext |= CommitContext;
+        commitPassiveUnmountOnFiber(root$jscomp$0.current);
+        commitPassiveMountOnFiber(root$jscomp$0, root$jscomp$0.current, lanes, priority);
+        null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markPassiveEffectsStopped && injectedProfilingHooks.markPassiveEffectsStopped();
+        commitDoubleInvokeEffectsInDEV(root$jscomp$0, !0);
+        executionContext = prevExecutionContext;
+        flushSyncWorkAcrossRoots_impl(0, !1);
+        didScheduleUpdateDuringPassiveEffects ? root$jscomp$0 === rootWithPassiveNestedUpdates ? nestedPassiveUpdateCount++ : (nestedPassiveUpdateCount = 0, rootWithPassiveNestedUpdates = root$jscomp$0) : nestedPassiveUpdateCount = 0;
+        didScheduleUpdateDuringPassiveEffects = isFlushingPassiveEffects = !1;
+        if (injectedHook && "function" === typeof injectedHook.onPostCommitFiberRoot) try {
+          injectedHook.onPostCommitFiberRoot(rendererID, root$jscomp$0);
+        } catch (err) {
+          hasLoggedError || (hasLoggedError = !0, console.error("React instrumentation encountered an error: %s", err));
+        }
+        var stateNode = root$jscomp$0.current.stateNode;
+        stateNode.effectDuration = 0;
+        stateNode.passiveEffectDuration = 0;
+        return !0;
+      } finally {
+        currentUpdatePriority = previousPriority, ReactSharedInternals.T = renderPriority, releaseRootPooledCache(root, remainingLanes);
+      }
+    }
+    function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
+      sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
+      sourceFiber = createRootErrorUpdate(rootFiber.stateNode, sourceFiber, 2);
+      rootFiber = enqueueUpdate(rootFiber, sourceFiber, 2);
+      null !== rootFiber && (markRootUpdated$1(rootFiber, 2), ensureRootIsScheduled(rootFiber));
+    }
+    function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {
+      isRunningInsertionEffect = !1;
+      if (3 === sourceFiber.tag) captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);else {
+        for (; null !== nearestMountedAncestor;) {
+          if (3 === nearestMountedAncestor.tag) {
+            captureCommitPhaseErrorOnRoot(nearestMountedAncestor, sourceFiber, error);
+            return;
+          }
+          if (1 === nearestMountedAncestor.tag) {
+            var instance = nearestMountedAncestor.stateNode;
+            if ("function" === typeof nearestMountedAncestor.type.getDerivedStateFromError || "function" === typeof instance.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(instance))) {
+              sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
+              error = createClassErrorUpdate(2);
+              instance = enqueueUpdate(nearestMountedAncestor, error, 2);
+              null !== instance && (initializeClassErrorUpdate(error, instance, nearestMountedAncestor, sourceFiber), markRootUpdated$1(instance, 2), ensureRootIsScheduled(instance));
+              return;
+            }
+          }
+          nearestMountedAncestor = nearestMountedAncestor.return;
+        }
+        console.error("Internal React error: Attempted to capture a commit phase error inside a detached tree. This indicates a bug in React. Potential causes include deleting the same fiber more than once, committing an already-finished tree, or an inconsistent return pointer.\n\nError message:\n\n%s", error);
+      }
+    }
+    function attachPingListener(root, wakeable, lanes) {
+      var pingCache = root.pingCache;
+      if (null === pingCache) {
+        pingCache = root.pingCache = new PossiblyWeakMap();
+        var threadIDs = new Set();
+        pingCache.set(wakeable, threadIDs);
+      } else threadIDs = pingCache.get(wakeable), void 0 === threadIDs && (threadIDs = new Set(), pingCache.set(wakeable, threadIDs));
+      threadIDs.has(lanes) || (workInProgressRootDidAttachPingListener = !0, threadIDs.add(lanes), pingCache = pingSuspendedRoot.bind(null, root, wakeable, lanes), isDevToolsPresent && restorePendingUpdaters(root, lanes), wakeable.then(pingCache, pingCache));
+    }
+    function pingSuspendedRoot(root, wakeable, pingedLanes) {
+      var pingCache = root.pingCache;
+      null !== pingCache && pingCache.delete(wakeable);
+      root.pingedLanes |= root.suspendedLanes & pingedLanes;
+      root.warmLanes &= ~pingedLanes;
+      0 !== root.tag && isConcurrentActEnvironment() && null === ReactSharedInternals.actQueue && console.error("A suspended resource finished loading inside a test, but the event was not wrapped in act(...).\n\nWhen testing, code that resolves suspended data should be wrapped into act(...):\n\nact(() => {\n  /* finish loading suspended data */\n});\n/* assert on the output */\n\nThis ensures that you're testing the behavior the user would see in the browser. Learn more at https://react.dev/link/wrap-tests-with-act");
+      workInProgressRoot === root && (workInProgressRootRenderLanes & pingedLanes) === pingedLanes && (workInProgressRootExitStatus === RootSuspendedWithDelay || workInProgressRootExitStatus === RootSuspended && (workInProgressRootRenderLanes & 62914560) === workInProgressRootRenderLanes && now$1() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS ? (executionContext & RenderContext) === NoContext && prepareFreshStack(root, 0) : workInProgressRootPingedLanes |= pingedLanes, workInProgressSuspendedRetryLanes === workInProgressRootRenderLanes && (workInProgressSuspendedRetryLanes = 0));
+      ensureRootIsScheduled(root);
+    }
+    function retryTimedOutBoundary(boundaryFiber, retryLane) {
+      0 === retryLane && (retryLane = 0 === (boundaryFiber.mode & 1) ? 2 : claimNextRetryLane());
+      boundaryFiber = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
+      null !== boundaryFiber && (markRootUpdated$1(boundaryFiber, retryLane), ensureRootIsScheduled(boundaryFiber));
+    }
+    function retryDehydratedSuspenseBoundary(boundaryFiber) {
+      var suspenseState = boundaryFiber.memoizedState,
+        retryLane = 0;
+      null !== suspenseState && (retryLane = suspenseState.retryLane);
+      retryTimedOutBoundary(boundaryFiber, retryLane);
+    }
+    function resolveRetryWakeable(boundaryFiber, wakeable) {
+      var retryLane = 0;
+      switch (boundaryFiber.tag) {
+        case 13:
+          var retryCache = boundaryFiber.stateNode;
+          var suspenseState = boundaryFiber.memoizedState;
+          null !== suspenseState && (retryLane = suspenseState.retryLane);
+          break;
+        case 19:
+          retryCache = boundaryFiber.stateNode;
+          break;
+        case 22:
+          retryCache = boundaryFiber.stateNode._retryCache;
+          break;
+        default:
+          throw Error("Pinged unknown suspense boundary type. This is probably a bug in React.");
+      }
+      null !== retryCache && retryCache.delete(wakeable);
+      retryTimedOutBoundary(boundaryFiber, retryLane);
+    }
+    function recursivelyTraverseAndDoubleInvokeEffectsInDEV(root$jscomp$0, parentFiber, isInStrictMode) {
+      if (0 !== (parentFiber.subtreeFlags & 67117056)) for (parentFiber = parentFiber.child; null !== parentFiber;) {
+        var root = root$jscomp$0,
+          fiber = parentFiber,
+          isStrictModeFiber = fiber.type === REACT_STRICT_MODE_TYPE;
+        isStrictModeFiber = isInStrictMode || isStrictModeFiber;
+        22 !== fiber.tag ? fiber.flags & 67108864 ? isStrictModeFiber && runWithFiberInDEV(fiber, doubleInvokeEffectsOnFiber, root, fiber, 0 === (fiber.mode & 64)) : recursivelyTraverseAndDoubleInvokeEffectsInDEV(root, fiber, isStrictModeFiber) : null === fiber.memoizedState && (isStrictModeFiber && fiber.flags & 8192 ? runWithFiberInDEV(fiber, doubleInvokeEffectsOnFiber, root, fiber) : fiber.subtreeFlags & 67108864 && runWithFiberInDEV(fiber, recursivelyTraverseAndDoubleInvokeEffectsInDEV, root, fiber, isStrictModeFiber));
+        parentFiber = parentFiber.sibling;
+      }
+    }
+    function doubleInvokeEffectsOnFiber(root, fiber) {
+      var shouldDoubleInvokePassiveEffects = 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : !0;
+      setIsStrictModeForDevtools(!0);
+      try {
+        disappearLayoutEffects(fiber), shouldDoubleInvokePassiveEffects && disconnectPassiveEffect(fiber), reappearLayoutEffects(root, fiber.alternate, fiber, !1), shouldDoubleInvokePassiveEffects && reconnectPassiveEffects(root, fiber, 0, null, !1, 0);
+      } finally {
+        setIsStrictModeForDevtools(!1);
+      }
+    }
+    function commitDoubleInvokeEffectsInDEV(root, hasPassiveEffects) {
+      0 !== root.tag ? (hasPassiveEffects = !0, 1 !== root.tag || root.current.mode & 24 || (hasPassiveEffects = !1), recursivelyTraverseAndDoubleInvokeEffectsInDEV(root, root.current, hasPassiveEffects)) : runWithFiberInDEV(root.current, legacyCommitDoubleInvokeEffectsInDEV, root.current, hasPassiveEffects);
+    }
+    function legacyCommitDoubleInvokeEffectsInDEV(fiber, hasPassiveEffects) {
+      invokeEffectsInDev(fiber, 134217728, invokeLayoutEffectUnmountInDEV);
+      hasPassiveEffects && invokeEffectsInDev(fiber, 268435456, invokePassiveEffectUnmountInDEV);
+      invokeEffectsInDev(fiber, 134217728, invokeLayoutEffectMountInDEV);
+      hasPassiveEffects && invokeEffectsInDev(fiber, 268435456, invokePassiveEffectMountInDEV);
+    }
+    function invokeEffectsInDev(firstChild, fiberFlags, invokeEffectFn) {
+      for (var subtreeRoot = null; null != firstChild;) {
+        var primarySubtreeFlag = firstChild.subtreeFlags & fiberFlags;
+        firstChild !== subtreeRoot && null != firstChild.child && 0 !== primarySubtreeFlag ? firstChild = firstChild.child : (0 !== (firstChild.flags & fiberFlags) && invokeEffectFn(firstChild), firstChild = null !== firstChild.sibling ? firstChild.sibling : subtreeRoot = firstChild.return);
+      }
+    }
+    function warnAboutUpdateOnNotYetMountedFiberInDEV(fiber) {
+      if ((executionContext & RenderContext) === NoContext && fiber.mode & 1) {
+        var tag = fiber.tag;
+        if (3 === tag || 1 === tag || 0 === tag || 11 === tag || 14 === tag || 15 === tag) {
+          tag = getComponentNameFromFiber(fiber) || "ReactComponent";
+          if (null !== didWarnStateUpdateForNotYetMountedComponent) {
+            if (didWarnStateUpdateForNotYetMountedComponent.has(tag)) return;
+            didWarnStateUpdateForNotYetMountedComponent.add(tag);
+          } else didWarnStateUpdateForNotYetMountedComponent = new Set([tag]);
+          runWithFiberInDEV(fiber, function () {
+            console.error("Can't perform a React state update on a component that hasn't mounted yet. This indicates that you have a side-effect in your render function that asynchronously later calls tries to update the component. Move this work to useEffect instead.");
+          });
+        }
+      }
+    }
+    function restorePendingUpdaters(root, lanes) {
+      isDevToolsPresent && root.memoizedUpdaters.forEach(function (schedulingFiber) {
+        addFiberToLanesMap(root, schedulingFiber, lanes);
+      });
+    }
+    function scheduleCallback(priorityLevel, callback) {
+      var actQueue = ReactSharedInternals.actQueue;
+      return null !== actQueue ? (actQueue.push(callback), fakeActCallbackNode) : scheduleCallback$3(priorityLevel, callback);
+    }
+    function warnIfUpdatesNotWrappedWithActDEV(fiber) {
+      if (fiber.mode & 1) {
+        if (!isConcurrentActEnvironment()) return;
+      } else {
+        "undefined" !== typeof IS_REACT_ACT_ENVIRONMENT ? IS_REACT_ACT_ENVIRONMENT : void 0;
+        var JSCompiler_inline_result = warnsIfNotActing;
+        if (!JSCompiler_inline_result || executionContext !== NoContext || 0 !== fiber.tag && 11 !== fiber.tag && 15 !== fiber.tag) return;
+      }
+      null === ReactSharedInternals.actQueue && runWithFiberInDEV(fiber, function () {
+        console.error("An update to %s inside a test was not wrapped in act(...).\n\nWhen testing, code that causes React state updates should be wrapped into act(...):\n\nact(() => {\n  /* fire events that update state */\n});\n/* assert on the output */\n\nThis ensures that you're testing the behavior the user would see in the browser. Learn more at https://react.dev/link/wrap-tests-with-act", getComponentNameFromFiber(fiber));
+      });
+    }
+    function resolveFunctionForHotReloading(type) {
+      if (null === resolveFamily) return type;
+      var family = resolveFamily(type);
+      return void 0 === family ? type : family.current;
+    }
+    function resolveForwardRefForHotReloading(type) {
+      if (null === resolveFamily) return type;
+      var family = resolveFamily(type);
+      return void 0 === family ? null !== type && void 0 !== type && "function" === typeof type.render && (family = resolveFunctionForHotReloading(type.render), type.render !== family) ? (family = {
+        $$typeof: REACT_FORWARD_REF_TYPE,
+        render: family
+      }, void 0 !== type.displayName && (family.displayName = type.displayName), family) : type : family.current;
+    }
+    function isCompatibleFamilyForHotReloading(fiber, element) {
+      if (null === resolveFamily) return !1;
+      var prevType = fiber.elementType;
+      element = element.type;
+      var needsCompareFamilies = !1,
+        $$typeofNextType = "object" === typeof element && null !== element ? element.$$typeof : null;
+      switch (fiber.tag) {
+        case 1:
+          "function" === typeof element && (needsCompareFamilies = !0);
+          break;
+        case 0:
+          "function" === typeof element ? needsCompareFamilies = !0 : $$typeofNextType === REACT_LAZY_TYPE && (needsCompareFamilies = !0);
+          break;
+        case 11:
+          $$typeofNextType === REACT_FORWARD_REF_TYPE ? needsCompareFamilies = !0 : $$typeofNextType === REACT_LAZY_TYPE && (needsCompareFamilies = !0);
+          break;
+        case 14:
+        case 15:
+          $$typeofNextType === REACT_MEMO_TYPE ? needsCompareFamilies = !0 : $$typeofNextType === REACT_LAZY_TYPE && (needsCompareFamilies = !0);
+          break;
+        default:
+          return !1;
+      }
+      return needsCompareFamilies && (fiber = resolveFamily(prevType), void 0 !== fiber && fiber === resolveFamily(element)) ? !0 : !1;
+    }
+    function markFailedErrorBoundaryForHotReloading(fiber) {
+      null !== resolveFamily && "function" === typeof WeakSet && (null === failedBoundaries && (failedBoundaries = new WeakSet()), failedBoundaries.add(fiber));
+    }
+    function scheduleFibersWithFamiliesRecursively(fiber, updatedFamilies, staleFamilies) {
+      var alternate = fiber.alternate,
+        child = fiber.child,
+        sibling = fiber.sibling,
+        tag = fiber.tag,
+        type = fiber.type,
+        candidateType = null;
+      switch (tag) {
+        case 0:
+        case 15:
+        case 1:
+          candidateType = type;
+          break;
+        case 11:
+          candidateType = type.render;
+      }
+      if (null === resolveFamily) throw Error("Expected resolveFamily to be set during hot reload.");
+      var needsRender = !1;
+      type = !1;
+      null !== candidateType && (candidateType = resolveFamily(candidateType), void 0 !== candidateType && (staleFamilies.has(candidateType) ? type = !0 : updatedFamilies.has(candidateType) && (1 === tag ? type = !0 : needsRender = !0)));
+      null !== failedBoundaries && (failedBoundaries.has(fiber) || null !== alternate && failedBoundaries.has(alternate)) && (type = !0);
+      type && (fiber._debugNeedsRemount = !0);
+      if (type || needsRender) alternate = enqueueConcurrentRenderForLane(fiber, 2), null !== alternate && scheduleUpdateOnFiber(alternate, fiber, 2);
+      null === child || type || scheduleFibersWithFamiliesRecursively(child, updatedFamilies, staleFamilies);
+      null !== sibling && scheduleFibersWithFamiliesRecursively(sibling, updatedFamilies, staleFamilies);
+    }
+    function FiberNode(tag, pendingProps, key, mode) {
+      this.tag = tag;
+      this.key = key;
+      this.sibling = this.child = this.return = this.stateNode = this.type = this.elementType = null;
+      this.index = 0;
+      this.refCleanup = this.ref = null;
+      this.pendingProps = pendingProps;
+      this.dependencies = this.memoizedState = this.updateQueue = this.memoizedProps = null;
+      this.mode = mode;
+      this.subtreeFlags = this.flags = 0;
+      this.deletions = null;
+      this.childLanes = this.lanes = 0;
+      this.alternate = null;
+      this.actualDuration = -0;
+      this.actualStartTime = -1.1;
+      this.treeBaseDuration = this.selfBaseDuration = -0;
+      this._debugTask = this._debugStack = this._debugOwner = this._debugInfo = null;
+      this._debugNeedsRemount = !1;
+      this._debugHookTypes = null;
+      hasBadMapPolyfill || "function" !== typeof Object.preventExtensions || Object.preventExtensions(this);
+    }
+    function shouldConstruct(Component) {
+      Component = Component.prototype;
+      return !(!Component || !Component.isReactComponent);
+    }
+    function createWorkInProgress(current, pendingProps) {
+      var workInProgress = current.alternate;
+      null === workInProgress ? (workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode), workInProgress.elementType = current.elementType, workInProgress.type = current.type, workInProgress.stateNode = current.stateNode, workInProgress._debugOwner = current._debugOwner, workInProgress._debugStack = current._debugStack, workInProgress._debugTask = current._debugTask, workInProgress._debugHookTypes = current._debugHookTypes, workInProgress.alternate = current, current.alternate = workInProgress) : (workInProgress.pendingProps = pendingProps, workInProgress.type = current.type, workInProgress.flags = 0, workInProgress.subtreeFlags = 0, workInProgress.deletions = null, workInProgress.actualDuration = -0, workInProgress.actualStartTime = -1.1);
+      workInProgress.flags = current.flags & 65011712;
+      workInProgress.childLanes = current.childLanes;
+      workInProgress.lanes = current.lanes;
+      workInProgress.child = current.child;
+      workInProgress.memoizedProps = current.memoizedProps;
+      workInProgress.memoizedState = current.memoizedState;
+      workInProgress.updateQueue = current.updateQueue;
+      pendingProps = current.dependencies;
+      workInProgress.dependencies = null === pendingProps ? null : {
+        lanes: pendingProps.lanes,
+        firstContext: pendingProps.firstContext,
+        _debugThenableState: pendingProps._debugThenableState
+      };
+      workInProgress.sibling = current.sibling;
+      workInProgress.index = current.index;
+      workInProgress.ref = current.ref;
+      workInProgress.refCleanup = current.refCleanup;
+      workInProgress.selfBaseDuration = current.selfBaseDuration;
+      workInProgress.treeBaseDuration = current.treeBaseDuration;
+      workInProgress._debugInfo = current._debugInfo;
+      workInProgress._debugNeedsRemount = current._debugNeedsRemount;
+      switch (workInProgress.tag) {
+        case 0:
+        case 15:
+          workInProgress.type = resolveFunctionForHotReloading(current.type);
+          break;
+        case 1:
+          workInProgress.type = resolveFunctionForHotReloading(current.type);
+          break;
+        case 11:
+          workInProgress.type = resolveForwardRefForHotReloading(current.type);
+      }
+      return workInProgress;
+    }
+    function resetWorkInProgress(workInProgress, renderLanes) {
+      workInProgress.flags &= 65011714;
+      var current = workInProgress.alternate;
+      null === current ? (workInProgress.childLanes = 0, workInProgress.lanes = renderLanes, workInProgress.child = null, workInProgress.subtreeFlags = 0, workInProgress.memoizedProps = null, workInProgress.memoizedState = null, workInProgress.updateQueue = null, workInProgress.dependencies = null, workInProgress.stateNode = null, workInProgress.selfBaseDuration = 0, workInProgress.treeBaseDuration = 0) : (workInProgress.childLanes = current.childLanes, workInProgress.lanes = current.lanes, workInProgress.child = current.child, workInProgress.subtreeFlags = 0, workInProgress.deletions = null, workInProgress.memoizedProps = current.memoizedProps, workInProgress.memoizedState = current.memoizedState, workInProgress.updateQueue = current.updateQueue, workInProgress.type = current.type, renderLanes = current.dependencies, workInProgress.dependencies = null === renderLanes ? null : {
+        lanes: renderLanes.lanes,
+        firstContext: renderLanes.firstContext,
+        _debugThenableState: renderLanes._debugThenableState
+      }, workInProgress.selfBaseDuration = current.selfBaseDuration, workInProgress.treeBaseDuration = current.treeBaseDuration);
+      return workInProgress;
+    }
+    function createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, lanes) {
+      var fiberTag = 0,
+        resolvedType = type;
+      if ("function" === typeof type) shouldConstruct(type) && (fiberTag = 1), resolvedType = resolveFunctionForHotReloading(resolvedType);else if ("string" === typeof type) fiberTag = 5;else a: switch (type) {
+        case REACT_ACTIVITY_TYPE:
+          return key = createFiber(31, pendingProps, key, mode), key.elementType = REACT_ACTIVITY_TYPE, key.lanes = lanes, key;
+        case REACT_FRAGMENT_TYPE:
+          return createFiberFromFragment(pendingProps.children, mode, lanes, key);
+        case REACT_STRICT_MODE_TYPE:
+          fiberTag = 8;
+          mode |= 8;
+          0 !== (mode & 1) && (mode |= 16);
+          break;
+        case REACT_PROFILER_TYPE:
+          return type = pendingProps, owner = mode, "string" !== typeof type.id && console.error('Profiler must specify an "id" of type `string` as a prop. Received the type `%s` instead.', typeof type.id), key = createFiber(12, type, key, owner | 2), key.elementType = REACT_PROFILER_TYPE, key.lanes = lanes, key.stateNode = {
+            effectDuration: 0,
+            passiveEffectDuration: 0
+          }, key;
+        case REACT_SUSPENSE_TYPE:
+          return key = createFiber(13, pendingProps, key, mode), key.elementType = REACT_SUSPENSE_TYPE, key.lanes = lanes, key;
+        case REACT_SUSPENSE_LIST_TYPE:
+          return key = createFiber(19, pendingProps, key, mode), key.elementType = REACT_SUSPENSE_LIST_TYPE, key.lanes = lanes, key;
+        default:
+          if ("object" === typeof type && null !== type) switch (type.$$typeof) {
+            case REACT_PROVIDER_TYPE:
+            case REACT_CONTEXT_TYPE:
+              fiberTag = 10;
+              break a;
+            case REACT_CONSUMER_TYPE:
+              fiberTag = 9;
+              break a;
+            case REACT_FORWARD_REF_TYPE:
+              fiberTag = 11;
+              resolvedType = resolveForwardRefForHotReloading(resolvedType);
+              break a;
+            case REACT_MEMO_TYPE:
+              fiberTag = 14;
+              break a;
+            case REACT_LAZY_TYPE:
+              fiberTag = 16;
+              resolvedType = null;
+              break a;
+          }
+          resolvedType = "";
+          if (void 0 === type || "object" === typeof type && null !== type && 0 === Object.keys(type).length) resolvedType += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.";
+          null === type ? pendingProps = "null" : isArrayImpl(type) ? pendingProps = "array" : void 0 !== type && type.$$typeof === REACT_ELEMENT_TYPE ? (pendingProps = "<" + (getComponentNameFromType(type.type) || "Unknown") + " />", resolvedType = " Did you accidentally export a JSX literal instead of a component?") : pendingProps = typeof type;
+          fiberTag = owner ? "number" === typeof owner.tag ? getComponentNameFromFiber(owner) : "string" === typeof owner.name ? owner.name : null : null;
+          fiberTag && (resolvedType += "\n\nCheck the render method of `" + fiberTag + "`.");
+          fiberTag = 29;
+          pendingProps = Error("Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: " + (pendingProps + "." + resolvedType));
+          resolvedType = null;
+      }
+      key = createFiber(fiberTag, pendingProps, key, mode);
+      key.elementType = type;
+      key.type = resolvedType;
+      key.lanes = lanes;
+      key._debugOwner = owner;
+      return key;
+    }
+    function createFiberFromElement(element, mode, lanes) {
+      mode = createFiberFromTypeAndProps(element.type, element.key, element.props, element._owner, mode, lanes);
+      mode._debugOwner = element._owner;
+      mode._debugStack = element._debugStack;
+      mode._debugTask = element._debugTask;
+      return mode;
+    }
+    function createFiberFromFragment(elements, mode, lanes, key) {
+      elements = createFiber(7, elements, key, mode);
+      elements.lanes = lanes;
+      return elements;
+    }
+    function createFiberFromText(content, mode, lanes) {
+      content = createFiber(6, content, null, mode);
+      content.lanes = lanes;
+      return content;
+    }
+    function createFiberFromPortal(portal, mode, lanes) {
+      mode = createFiber(4, null !== portal.children ? portal.children : [], portal.key, mode);
+      mode.lanes = lanes;
+      mode.stateNode = {
+        containerInfo: portal.containerInfo,
+        pendingChildren: null,
+        implementation: portal.implementation
+      };
+      return mode;
+    }
+    function FiberRootNode(containerInfo, tag, hydrate, identifierPrefix, onUncaughtError, onCaughtError, onRecoverableError, formState) {
+      this.tag = tag;
+      this.containerInfo = containerInfo;
+      this.pingCache = this.current = this.pendingChildren = null;
+      this.timeoutHandle = noTimeout;
+      this.callbackNode = this.next = this.pendingContext = this.context = this.cancelPendingCommit = null;
+      this.callbackPriority = 0;
+      this.expirationTimes = createLaneMap(-1);
+      this.entangledLanes = this.shellSuspendCounter = this.errorRecoveryDisabledLanes = this.expiredLanes = this.warmLanes = this.pingedLanes = this.suspendedLanes = this.pendingLanes = 0;
+      this.entanglements = createLaneMap(0);
+      this.hiddenUpdates = createLaneMap(null);
+      this.identifierPrefix = identifierPrefix;
+      this.onUncaughtError = onUncaughtError;
+      this.onCaughtError = onCaughtError;
+      this.onRecoverableError = onRecoverableError;
+      this.pooledCache = null;
+      this.pooledCacheLanes = 0;
+      this.formState = formState;
+      this.incompleteTransitions = new Map();
+      this.passiveEffectDuration = this.effectDuration = -0;
+      this.memoizedUpdaters = new Set();
+      containerInfo = this.pendingUpdatersLaneMap = [];
+      for (identifierPrefix = 0; 31 > identifierPrefix; identifierPrefix++) containerInfo.push(new Set());
+      switch (tag) {
+        case 1:
+          this._debugRootType = hydrate ? "hydrateRoot()" : "createRoot()";
+          break;
+        case 0:
+          this._debugRootType = hydrate ? "hydrate()" : "render()";
+      }
+    }
+    function testStringCoercion(value) {
+      return "" + value;
+    }
+    function createPortal$1(children, containerInfo, implementation) {
+      var key = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
+      try {
+        testStringCoercion(key);
+        var JSCompiler_inline_result = !1;
+      } catch (e$7) {
+        JSCompiler_inline_result = !0;
+      }
+      JSCompiler_inline_result && (console.error("The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", "function" === typeof Symbol && Symbol.toStringTag && key[Symbol.toStringTag] || key.constructor.name || "Object"), testStringCoercion(key));
+      return {
+        $$typeof: REACT_PORTAL_TYPE,
+        key: null == key ? null : "" + key,
+        children: children,
+        containerInfo: containerInfo,
+        implementation: implementation
+      };
+    }
+    function findHostInstanceWithWarning(component, methodName) {
+      var fiber = component._reactInternals;
+      if (void 0 === fiber) {
+        if ("function" === typeof component.render) throw Error("Unable to find node on an unmounted component.");
+        component = Object.keys(component).join(",");
+        throw Error("Argument appears to not be a ReactComponent. Keys: " + component);
+      }
+      component = findCurrentHostFiber(fiber);
+      if (null === component) return null;
+      if (component.mode & 8) {
+        var componentName = getComponentNameFromFiber(fiber) || "Component";
+        didWarnAboutFindNodeInStrictMode[componentName] || (didWarnAboutFindNodeInStrictMode[componentName] = !0, runWithFiberInDEV(component, function () {
+          fiber.mode & 8 ? console.error("%s is deprecated in StrictMode. %s was passed an instance of %s which is inside StrictMode. Instead, add a ref directly to the element you want to reference. Learn more about using refs safely here: https://react.dev/link/strict-mode-find-node", methodName, methodName, componentName) : console.error("%s is deprecated in StrictMode. %s was passed an instance of %s which renders StrictMode children. Instead, add a ref directly to the element you want to reference. Learn more about using refs safely here: https://react.dev/link/strict-mode-find-node", methodName, methodName, componentName);
+        }));
+      }
+      return getPublicInstance(component.stateNode);
+    }
+    function updateContainer(element, container, parentComponent, callback) {
+      var current = container.current,
+        lane = requestUpdateLane(current);
+      updateContainerImpl(current, lane, element, container, parentComponent, callback);
+      return lane;
+    }
+    function updateContainerImpl(rootFiber, lane, element, container, parentComponent, callback) {
+      if (injectedHook && "function" === typeof injectedHook.onScheduleFiberRoot) try {
+        injectedHook.onScheduleFiberRoot(rendererID, container, element);
+      } catch (err) {
+        hasLoggedError || (hasLoggedError = !0, console.error("React instrumentation encountered an error: %s", err));
+      }
+      null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markRenderScheduled && injectedProfilingHooks.markRenderScheduled(lane);
+      parentComponent = emptyContextObject;
+      null === container.context ? container.context = parentComponent : container.pendingContext = parentComponent;
+      isRendering && null !== current && !didWarnAboutNestedUpdates && (didWarnAboutNestedUpdates = !0, console.error("Render methods should be a pure function of props and state; triggering nested component updates from render is not allowed. If necessary, trigger nested updates in componentDidUpdate.\n\nCheck the render method of %s.", getComponentNameFromFiber(current) || "Unknown"));
+      container = createUpdate(lane);
+      container.payload = {
+        element: element
+      };
+      callback = void 0 === callback ? null : callback;
+      null !== callback && ("function" !== typeof callback && console.error("Expected the last optional `callback` argument to be a function. Instead received: %s.", callback), container.callback = callback);
+      element = enqueueUpdate(rootFiber, container, lane);
+      null !== element && (scheduleUpdateOnFiber(element, rootFiber, lane), entangleTransitions(element, rootFiber, lane));
+    }
+    function getCurrentFiberForDevTools() {
+      return current;
+    }
+    function getLaneLabelMap() {
+      for (var map = new Map(), lane = 1, index = 0; 31 > index; index++) {
+        var label = getLabelForLane(lane);
+        map.set(lane, label);
+        lane *= 2;
+      }
+      return map;
+    }
+    function findNodeHandle(componentOrHandle) {
+      var owner = current;
+      null !== owner && isRendering && null !== owner.stateNode && (owner.stateNode._warnedAboutRefsInRender || console.error("%s is accessing findNodeHandle inside its render(). render() should be a pure function of props and state. It should never access something that requires stale data from the previous render, such as refs. Move this logic to componentDidMount and componentDidUpdate instead.", getComponentNameFromType(owner.type) || "A component"), owner.stateNode._warnedAboutRefsInRender = !0);
+      if (null == componentOrHandle) return null;
+      if ("number" === typeof componentOrHandle) return componentOrHandle;
+      if (componentOrHandle._nativeTag) return componentOrHandle._nativeTag;
+      if (null != componentOrHandle.canonical && null != componentOrHandle.canonical.nativeTag) return componentOrHandle.canonical.nativeTag;
+      if (owner = ReactNativePrivateInterface.getNativeTagFromPublicInstance(componentOrHandle)) return owner;
+      componentOrHandle = findHostInstanceWithWarning(componentOrHandle, "findNodeHandle");
+      return null == componentOrHandle ? componentOrHandle : null != componentOrHandle._nativeTag ? componentOrHandle._nativeTag : ReactNativePrivateInterface.getNativeTagFromPublicInstance(componentOrHandle);
+    }
+    function getNodeFromInternalInstanceHandle(internalInstanceHandle) {
+      return internalInstanceHandle && internalInstanceHandle.stateNode && internalInstanceHandle.stateNode.node;
+    }
+    function shim$1() {
+      throw Error("The current renderer does not support hydration. This error is likely caused by a bug in React. Please file an issue.");
+    }
+    function shim() {
+      throw Error("The current renderer does not support Resources. This error is likely caused by a bug in React. Please file an issue.");
+    }
+    function createTextInstance(text, rootContainerInstance, hostContext, internalInstanceHandle) {
+      hostContext.isInAParentText || console.error("Text strings must be rendered within a <Text> component.");
+      hostContext = nextReactTag;
+      nextReactTag += 2;
+      return {
+        node: createNode(hostContext, "RCTRawText", rootContainerInstance.containerTag, {
+          text: text
+        }, internalInstanceHandle)
+      };
+    }
+    function getPublicInstance(instance) {
+      if (null != instance.canonical) {
+        if (null == instance.canonical.publicInstance) {
+          var $jscomp$nullish$tmp0;
+          instance.canonical.publicInstance = ReactNativePrivateInterface.createPublicInstance(instance.canonical.nativeTag, instance.canonical.viewConfig, instance.canonical.internalInstanceHandle, null != ($jscomp$nullish$tmp0 = instance.canonical.publicRootInstance) ? $jscomp$nullish$tmp0 : null);
+          instance.canonical.publicRootInstance = null;
+        }
+        return instance.canonical.publicInstance;
+      }
+      return null != instance._nativeTag ? instance : null;
+    }
+    function resolveUpdatePriority() {
+      if (0 !== currentUpdatePriority) return currentUpdatePriority;
+      var currentEventPriority = fabricGetCurrentEventPriority ? fabricGetCurrentEventPriority() : null;
+      if (null != currentEventPriority) switch (currentEventPriority) {
+        case FabricDiscretePriority:
+          return DiscreteEventPriority;
+      }
+      return DefaultEventPriority;
+    }
+    function cloneHiddenInstance(instance) {
+      var node = instance.node;
+      var updatePayload = fastAddProperties(null, {
+        style: {
+          display: "none"
+        }
+      }, instance.canonical.viewConfig.validAttributes);
+      return {
+        node: cloneNodeWithNewProps(node, updatePayload),
+        canonical: instance.canonical
+      };
+    }
+    function replaceContainerChildren() {}
+    function nativeOnUncaughtError(error, errorInfo) {
+      !1 !== ReactNativePrivateInterface.ReactFiberErrorDialog.showErrorDialog({
+        errorBoundary: null,
+        error: error,
+        componentStack: null != errorInfo.componentStack ? errorInfo.componentStack : ""
+      }) && (reportGlobalError(error), console.warn("%s\n\n%s\n", componentName ? "An error occurred in the <" + componentName + "> component." : "An error occurred in one of your React components.", "Consider adding an error boundary to your tree to customize error handling behavior.\nVisit https://react.dev/link/error-boundaries to learn more about error boundaries."));
+    }
+    function nativeOnCaughtError(error, errorInfo) {
+      if (!1 !== ReactNativePrivateInterface.ReactFiberErrorDialog.showErrorDialog({
+        errorBoundary: errorInfo.errorBoundary,
+        error: error,
+        componentStack: null != errorInfo.componentStack ? errorInfo.componentStack : ""
+      })) {
+        var componentNameMessage = componentName ? "The above error occurred in the <" + componentName + "> component." : "The above error occurred in one of your React components.",
+          recreateMessage = "React will try to recreate this component tree from scratch using the error boundary you provided, " + ((errorBoundaryName || "Anonymous") + ".");
+        "object" === typeof error && null !== error && "string" === typeof error.environmentName ? (errorInfo = error.environmentName, error = ["%o\n\n%s\n\n%s\n", error, componentNameMessage, recreateMessage].slice(0), "string" === typeof error[0] ? error.splice(0, 1, "[%s] " + error[0], " " + errorInfo + " ") : error.splice(0, 0, "[%s] ", " " + errorInfo + " "), error.unshift(console), error = bind.apply(console.error, error), error()) : console.error("%o\n\n%s\n\n%s\n", error, componentNameMessage, recreateMessage);
+      }
+    }
+    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    _$$_REQUIRE(_dependencyMap[0], "react-native/Libraries/ReactPrivate/ReactNativePrivateInitializeCore");
+    var React = _$$_REQUIRE(_dependencyMap[1], "react"),
+      ReactNativePrivateInterface = _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface"),
+      Scheduler = _$$_REQUIRE(_dependencyMap[3], "scheduler"),
+      isArrayImpl = Array.isArray,
+      ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,
+      assign = Object.assign,
+      disabledDepth = 0,
+      prevLog,
+      prevInfo,
+      prevWarn,
+      prevError,
+      prevGroup,
+      prevGroupCollapsed,
+      prevGroupEnd;
+    disabledLog.__reactDisabledLog = !0;
+    var prefix,
+      suffix,
+      reentry = !1;
+    var componentFrameCache = new ("function" === typeof WeakMap ? WeakMap : Map)();
+    var REACT_LEGACY_ELEMENT_TYPE = Symbol.for("react.element"),
+      REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
+      REACT_PORTAL_TYPE = Symbol.for("react.portal"),
+      REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
+      REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
+      REACT_PROFILER_TYPE = Symbol.for("react.profiler"),
+      REACT_PROVIDER_TYPE = Symbol.for("react.provider"),
+      REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
+      REACT_CONTEXT_TYPE = Symbol.for("react.context"),
+      REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
+      REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
+      REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
+      REACT_MEMO_TYPE = Symbol.for("react.memo"),
+      REACT_LAZY_TYPE = Symbol.for("react.lazy");
+    Symbol.for("react.scope");
+    var REACT_ACTIVITY_TYPE = Symbol.for("react.activity");
+    Symbol.for("react.legacy_hidden");
+    Symbol.for("react.tracing_marker");
+    var REACT_MEMO_CACHE_SENTINEL = Symbol.for("react.memo_cache_sentinel");
+    Symbol.for("react.view_transition");
+    var MAYBE_ITERATOR_SYMBOL = Symbol.iterator,
+      REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"),
+      current = null,
+      isRendering = !1,
+      hasError = !1,
+      caughtError = null,
+      getFiberCurrentPropsFromNode$1 = null,
+      getInstanceFromNode$1 = null,
+      getNodeFromInstance$1 = null;
+    assign(SyntheticEvent.prototype, {
+      preventDefault: function preventDefault() {
+        this.defaultPrevented = !0;
+        var event = this.nativeEvent;
+        event && (event.preventDefault ? event.preventDefault() : "unknown" !== typeof event.returnValue && (event.returnValue = !1), this.isDefaultPrevented = functionThatReturnsTrue);
+      },
+      stopPropagation: function stopPropagation() {
+        var event = this.nativeEvent;
+        event && (event.stopPropagation ? event.stopPropagation() : "unknown" !== typeof event.cancelBubble && (event.cancelBubble = !0), this.isPropagationStopped = functionThatReturnsTrue);
+      },
+      persist: function persist() {
+        this.isPersistent = functionThatReturnsTrue;
+      },
+      isPersistent: functionThatReturnsFalse,
+      destructor: function destructor() {
+        var Interface = this.constructor.Interface,
+          propName;
+        for (propName in Interface) Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName]));
+        this.nativeEvent = this._targetInst = this.dispatchConfig = null;
+        this.isPropagationStopped = this.isDefaultPrevented = functionThatReturnsFalse;
+        this._dispatchInstances = this._dispatchListeners = null;
+        Object.defineProperty(this, "nativeEvent", getPooledWarningPropertyDefinition("nativeEvent", null));
+        Object.defineProperty(this, "isDefaultPrevented", getPooledWarningPropertyDefinition("isDefaultPrevented", functionThatReturnsFalse));
+        Object.defineProperty(this, "isPropagationStopped", getPooledWarningPropertyDefinition("isPropagationStopped", functionThatReturnsFalse));
+        Object.defineProperty(this, "preventDefault", getPooledWarningPropertyDefinition("preventDefault", function () {}));
+        Object.defineProperty(this, "stopPropagation", getPooledWarningPropertyDefinition("stopPropagation", function () {}));
+      }
+    });
+    SyntheticEvent.Interface = {
+      type: null,
+      target: null,
+      currentTarget: function currentTarget() {
+        return null;
+      },
+      eventPhase: null,
+      bubbles: null,
+      cancelable: null,
+      timeStamp: function timeStamp(event) {
+        return event.timeStamp || Date.now();
+      },
+      defaultPrevented: null,
+      isTrusted: null
+    };
+    SyntheticEvent.extend = function (Interface) {
+      function E() {}
+      function Class() {
+        return Super.apply(this, arguments);
+      }
+      var Super = this;
+      E.prototype = Super.prototype;
+      var prototype = new E();
+      assign(prototype, Class.prototype);
+      Class.prototype = prototype;
+      Class.prototype.constructor = Class;
+      Class.Interface = assign({}, Super.Interface, Interface);
+      Class.extend = Super.extend;
+      addEventPoolingTo(Class);
+      return Class;
+    };
+    addEventPoolingTo(SyntheticEvent);
+    var ResponderSyntheticEvent = SyntheticEvent.extend({
+        touchHistory: function touchHistory() {
+          return null;
+        }
+      }),
+      startDependencies = ["topTouchStart"],
+      moveDependencies = ["topTouchMove"],
+      endDependencies = ["topTouchCancel", "topTouchEnd"],
+      touchBank = [],
+      touchHistory = {
+        touchBank: touchBank,
+        numberActiveTouches: 0,
+        indexOfSingleActiveTouch: -1,
+        mostRecentTimeStamp: 0
+      },
+      instrumentationCallback,
+      ResponderTouchHistoryStore = {
+        instrument: function instrument(callback) {
+          instrumentationCallback = callback;
+        },
+        recordTouchTrack: function recordTouchTrack(topLevelType, nativeEvent) {
+          null != instrumentationCallback && instrumentationCallback(topLevelType, nativeEvent);
+          if (isMoveish(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchMove);else if (isStartish(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchStart), touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches && (touchHistory.indexOfSingleActiveTouch = nativeEvent.touches[0].identifier);else if ("topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType) if (nativeEvent.changedTouches.forEach(recordTouchEnd), touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches) {
+            for (topLevelType = 0; topLevelType < touchBank.length; topLevelType++) if (nativeEvent = touchBank[topLevelType], null != nativeEvent && nativeEvent.touchActive) {
+              touchHistory.indexOfSingleActiveTouch = topLevelType;
+              break;
+            }
+            topLevelType = touchBank[touchHistory.indexOfSingleActiveTouch];
+            null != topLevelType && topLevelType.touchActive || console.error("Cannot find single active touch.");
+          }
+        },
+        touchHistory: touchHistory
+      },
+      responderInst = null,
+      trackedTouchCount = 0,
+      eventTypes = {
+        startShouldSetResponder: {
+          phasedRegistrationNames: {
+            bubbled: "onStartShouldSetResponder",
+            captured: "onStartShouldSetResponderCapture"
+          },
+          dependencies: startDependencies
+        },
+        scrollShouldSetResponder: {
+          phasedRegistrationNames: {
+            bubbled: "onScrollShouldSetResponder",
+            captured: "onScrollShouldSetResponderCapture"
+          },
+          dependencies: ["topScroll"]
+        },
+        selectionChangeShouldSetResponder: {
+          phasedRegistrationNames: {
+            bubbled: "onSelectionChangeShouldSetResponder",
+            captured: "onSelectionChangeShouldSetResponderCapture"
+          },
+          dependencies: ["topSelectionChange"]
+        },
+        moveShouldSetResponder: {
+          phasedRegistrationNames: {
+            bubbled: "onMoveShouldSetResponder",
+            captured: "onMoveShouldSetResponderCapture"
+          },
+          dependencies: moveDependencies
+        },
+        responderStart: {
+          registrationName: "onResponderStart",
+          dependencies: startDependencies
+        },
+        responderMove: {
+          registrationName: "onResponderMove",
+          dependencies: moveDependencies
+        },
+        responderEnd: {
+          registrationName: "onResponderEnd",
+          dependencies: endDependencies
+        },
+        responderRelease: {
+          registrationName: "onResponderRelease",
+          dependencies: endDependencies
+        },
+        responderTerminationRequest: {
+          registrationName: "onResponderTerminationRequest",
+          dependencies: []
+        },
+        responderGrant: {
+          registrationName: "onResponderGrant",
+          dependencies: []
+        },
+        responderReject: {
+          registrationName: "onResponderReject",
+          dependencies: []
+        },
+        responderTerminate: {
+          registrationName: "onResponderTerminate",
+          dependencies: []
+        }
+      },
+      ResponderEventPlugin = {
+        _getResponder: function _getResponder() {
+          return responderInst;
+        },
+        eventTypes: eventTypes,
+        extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+          if (isStartish(topLevelType)) trackedTouchCount += 1;else if ("topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType) if (0 <= trackedTouchCount) --trackedTouchCount;else return console.warn("Ended a touch event which was not counted in `trackedTouchCount`."), null;
+          ResponderTouchHistoryStore.recordTouchTrack(topLevelType, nativeEvent);
+          if (targetInst && ("topScroll" === topLevelType && !nativeEvent.responderIgnoreScroll || 0 < trackedTouchCount && "topSelectionChange" === topLevelType || isStartish(topLevelType) || isMoveish(topLevelType))) {
+            var shouldSetEventType = isStartish(topLevelType) ? eventTypes.startShouldSetResponder : isMoveish(topLevelType) ? eventTypes.moveShouldSetResponder : "topSelectionChange" === topLevelType ? eventTypes.selectionChangeShouldSetResponder : eventTypes.scrollShouldSetResponder;
+            if (responderInst) b: {
+              var JSCompiler_temp = responderInst;
+              for (var depthA = 0, tempA = JSCompiler_temp; tempA; tempA = getParent$1(tempA)) depthA++;
+              tempA = 0;
+              for (var tempB = targetInst; tempB; tempB = getParent$1(tempB)) tempA++;
+              for (; 0 < depthA - tempA;) JSCompiler_temp = getParent$1(JSCompiler_temp), depthA--;
+              for (; 0 < tempA - depthA;) targetInst = getParent$1(targetInst), tempA--;
+              for (; depthA--;) {
+                if (JSCompiler_temp === targetInst || JSCompiler_temp === targetInst.alternate) break b;
+                JSCompiler_temp = getParent$1(JSCompiler_temp);
+                targetInst = getParent$1(targetInst);
+              }
+              JSCompiler_temp = null;
+            } else JSCompiler_temp = targetInst;
+            targetInst = JSCompiler_temp === responderInst;
+            JSCompiler_temp = ResponderSyntheticEvent.getPooled(shouldSetEventType, JSCompiler_temp, nativeEvent, nativeEventTarget);
+            JSCompiler_temp.touchHistory = ResponderTouchHistoryStore.touchHistory;
+            targetInst ? forEachAccumulated(JSCompiler_temp, accumulateTwoPhaseDispatchesSingleSkipTarget) : forEachAccumulated(JSCompiler_temp, accumulateTwoPhaseDispatchesSingle$1);
+            b: {
+              shouldSetEventType = JSCompiler_temp._dispatchListeners;
+              targetInst = JSCompiler_temp._dispatchInstances;
+              validateEventDispatches(JSCompiler_temp);
+              if (isArrayImpl(shouldSetEventType)) for (depthA = 0; depthA < shouldSetEventType.length && !JSCompiler_temp.isPropagationStopped(); depthA++) {
+                if (shouldSetEventType[depthA](JSCompiler_temp, targetInst[depthA])) {
+                  shouldSetEventType = targetInst[depthA];
+                  break b;
+                }
+              } else if (shouldSetEventType && shouldSetEventType(JSCompiler_temp, targetInst)) {
+                shouldSetEventType = targetInst;
+                break b;
+              }
+              shouldSetEventType = null;
+            }
+            JSCompiler_temp._dispatchInstances = null;
+            JSCompiler_temp._dispatchListeners = null;
+            JSCompiler_temp.isPersistent() || JSCompiler_temp.constructor.release(JSCompiler_temp);
+            if (shouldSetEventType && shouldSetEventType !== responderInst) {
+              if (JSCompiler_temp = ResponderSyntheticEvent.getPooled(eventTypes.responderGrant, shouldSetEventType, nativeEvent, nativeEventTarget), JSCompiler_temp.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(JSCompiler_temp, accumulateDirectDispatchesSingle$1), targetInst = !0 === executeDirectDispatch(JSCompiler_temp), responderInst) {
+                if (depthA = ResponderSyntheticEvent.getPooled(eventTypes.responderTerminationRequest, responderInst, nativeEvent, nativeEventTarget), depthA.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(depthA, accumulateDirectDispatchesSingle$1), tempA = !depthA._dispatchListeners || executeDirectDispatch(depthA), depthA.isPersistent() || depthA.constructor.release(depthA), tempA) {
+                  depthA = ResponderSyntheticEvent.getPooled(eventTypes.responderTerminate, responderInst, nativeEvent, nativeEventTarget);
+                  depthA.touchHistory = ResponderTouchHistoryStore.touchHistory;
+                  forEachAccumulated(depthA, accumulateDirectDispatchesSingle$1);
+                  var JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, [JSCompiler_temp, depthA]);
+                  changeResponder(shouldSetEventType, targetInst);
+                } else shouldSetEventType = ResponderSyntheticEvent.getPooled(eventTypes.responderReject, shouldSetEventType, nativeEvent, nativeEventTarget), shouldSetEventType.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(shouldSetEventType, accumulateDirectDispatchesSingle$1), JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, shouldSetEventType);
+              } else JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, JSCompiler_temp), changeResponder(shouldSetEventType, targetInst);
+            } else JSCompiler_temp$jscomp$0 = null;
+          } else JSCompiler_temp$jscomp$0 = null;
+          shouldSetEventType = responderInst && isStartish(topLevelType);
+          JSCompiler_temp = responderInst && isMoveish(topLevelType);
+          targetInst = responderInst && ("topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType);
+          if (shouldSetEventType = shouldSetEventType ? eventTypes.responderStart : JSCompiler_temp ? eventTypes.responderMove : targetInst ? eventTypes.responderEnd : null) shouldSetEventType = ResponderSyntheticEvent.getPooled(shouldSetEventType, responderInst, nativeEvent, nativeEventTarget), shouldSetEventType.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(shouldSetEventType, accumulateDirectDispatchesSingle$1), JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, shouldSetEventType);
+          shouldSetEventType = responderInst && "topTouchCancel" === topLevelType;
+          if (topLevelType = responderInst && !shouldSetEventType && ("topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType)) a: {
+            if ((topLevelType = nativeEvent.touches) && 0 !== topLevelType.length) for (JSCompiler_temp = 0; JSCompiler_temp < topLevelType.length; JSCompiler_temp++) if (targetInst = topLevelType[JSCompiler_temp].target, null !== targetInst && void 0 !== targetInst && 0 !== targetInst) {
+              depthA = getInstanceFromNode$1(targetInst);
+              b: {
+                for (targetInst = responderInst; depthA;) {
+                  if (targetInst === depthA || targetInst === depthA.alternate) {
+                    targetInst = !0;
+                    break b;
+                  }
+                  depthA = getParent$1(depthA);
+                }
+                targetInst = !1;
+              }
+              if (targetInst) {
+                topLevelType = !1;
+                break a;
+              }
+            }
+            topLevelType = !0;
+          }
+          if (topLevelType = shouldSetEventType ? eventTypes.responderTerminate : topLevelType ? eventTypes.responderRelease : null) nativeEvent = ResponderSyntheticEvent.getPooled(topLevelType, responderInst, nativeEvent, nativeEventTarget), nativeEvent.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(nativeEvent, accumulateDirectDispatchesSingle$1), JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, nativeEvent), changeResponder(null);
+          return JSCompiler_temp$jscomp$0;
+        },
+        GlobalResponderHandler: null,
+        injection: {
+          injectGlobalResponderHandler: function injectGlobalResponderHandler(GlobalResponderHandler) {
+            ResponderEventPlugin.GlobalResponderHandler = GlobalResponderHandler;
+          }
+        }
+      },
+      eventPluginOrder = null,
+      namesToPlugins = {},
+      plugins = [],
+      eventNameDispatchConfigs = {},
+      registrationNameModules = {},
+      customBubblingEventTypes = ReactNativePrivateInterface.ReactNativeViewConfigRegistry.customBubblingEventTypes,
+      customDirectEventTypes = ReactNativePrivateInterface.ReactNativeViewConfigRegistry.customDirectEventTypes;
+    if (eventPluginOrder) throw Error("EventPluginRegistry: Cannot inject event plugin ordering more than once. You are likely trying to load more than one copy of React.");
+    eventPluginOrder = Array.prototype.slice.call(["ResponderEventPlugin", "ReactNativeBridgeEventPlugin"]);
+    recomputePluginOrdering();
+    (function (injectedNamesToPlugins) {
+      var isOrderingDirty = !1,
+        pluginName;
+      for (pluginName in injectedNamesToPlugins) if (injectedNamesToPlugins.hasOwnProperty(pluginName)) {
+        var pluginModule = injectedNamesToPlugins[pluginName];
+        if (!namesToPlugins.hasOwnProperty(pluginName) || namesToPlugins[pluginName] !== pluginModule) {
+          if (namesToPlugins[pluginName]) throw Error("EventPluginRegistry: Cannot inject two different event plugins using the same name, `" + (pluginName + "`."));
+          namesToPlugins[pluginName] = pluginModule;
+          isOrderingDirty = !0;
+        }
+      }
+      isOrderingDirty && recomputePluginOrdering();
+    })({
+      ResponderEventPlugin: ResponderEventPlugin,
+      ReactNativeBridgeEventPlugin: {
+        eventTypes: {},
+        extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+          if (null == targetInst) return null;
+          var bubbleDispatchConfig = customBubblingEventTypes[topLevelType],
+            directDispatchConfig = customDirectEventTypes[topLevelType];
+          if (!bubbleDispatchConfig && !directDispatchConfig) throw Error('Unsupported top level event type "' + topLevelType + '" dispatched');
+          topLevelType = SyntheticEvent.getPooled(bubbleDispatchConfig || directDispatchConfig, targetInst, nativeEvent, nativeEventTarget);
+          if (bubbleDispatchConfig) null != topLevelType && null != topLevelType.dispatchConfig.phasedRegistrationNames && topLevelType.dispatchConfig.phasedRegistrationNames.skipBubbling ? topLevelType && topLevelType.dispatchConfig.phasedRegistrationNames && traverseTwoPhase(topLevelType._targetInst, accumulateDirectionalDispatches, topLevelType, !0) : forEachAccumulated(topLevelType, accumulateTwoPhaseDispatchesSingle);else if (directDispatchConfig) forEachAccumulated(topLevelType, accumulateDirectDispatchesSingle);else return null;
+          return topLevelType;
+        }
+      }
+    });
+    var emptyObject$1 = {},
+      removedKeys = null,
+      removedKeyCount = 0,
+      deepDifferOptions = {
+        unsafelyIgnoreFunctions: !0
+      },
+      isInsideEventHandler = !1,
+      eventQueue = null,
+      scheduleCallback$3 = Scheduler.unstable_scheduleCallback,
+      cancelCallback$1 = Scheduler.unstable_cancelCallback,
+      shouldYield = Scheduler.unstable_shouldYield,
+      requestPaint = Scheduler.unstable_requestPaint,
+      now$1 = Scheduler.unstable_now,
+      ImmediatePriority = Scheduler.unstable_ImmediatePriority,
+      UserBlockingPriority = Scheduler.unstable_UserBlockingPriority,
+      NormalPriority$1 = Scheduler.unstable_NormalPriority,
+      IdlePriority = Scheduler.unstable_IdlePriority,
+      log$1 = Scheduler.log,
+      unstable_setDisableYieldValue = Scheduler.unstable_setDisableYieldValue,
+      rendererID = null,
+      injectedHook = null,
+      injectedProfilingHooks = null,
+      hasLoggedError = !1,
+      isDevToolsPresent = "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__,
+      clz32 = Math.clz32 ? Math.clz32 : clz32Fallback,
+      log = Math.log,
+      LN2 = Math.LN2,
+      nextTransitionLane = 256,
+      nextRetryLane = 4194304,
+      DiscreteEventPriority = 2,
+      ContinuousEventPriority = 8,
+      DefaultEventPriority = 32,
+      IdleEventPriority = 268435456,
+      instanceCache = new Map(),
+      bind = Function.prototype.bind,
+      valueStack = [];
+    var fiberStack = [];
+    var index$jscomp$0 = -1,
+      emptyContextObject = {};
+    Object.freeze(emptyContextObject);
+    var CapturedStacks = new WeakMap(),
+      contextStackCursor = createCursor(null),
+      contextFiberStackCursor = createCursor(null),
+      rootInstanceStackCursor = createCursor(null),
+      hostTransitionProviderCursor = createCursor(null),
+      needsEscaping = /["'&<>\n\t]|^\s|\s$/,
+      hydrationDiffRootDEV = null,
+      hydrationErrors = null,
+      lastResetTime = 0;
+    if ("object" === typeof performance && "function" === typeof performance.now) {
+      var localPerformance = performance;
+      var getCurrentTime = function getCurrentTime() {
+        return localPerformance.now();
+      };
+    } else {
+      var localDate = Date;
+      getCurrentTime = function getCurrentTime() {
+        return localDate.now();
+      };
+    }
+    var objectIs = "function" === typeof Object.is ? Object.is : is,
+      valueCursor = createCursor(null);
+    var renderer2CursorDEV = createCursor(null);
+    var rendererSigil = {};
+    var currentlyRenderingFiber$1 = null,
+      lastContextDependency = null,
+      isDisallowedContextReadInDEV = !1,
+      AbortControllerLocal = "undefined" !== typeof AbortController ? AbortController : function () {
+        var listeners = [],
+          signal = this.signal = {
+            aborted: !1,
+            addEventListener: function addEventListener(type, listener) {
+              listeners.push(listener);
+            }
+          };
+        this.abort = function () {
+          signal.aborted = !0;
+          listeners.forEach(function (listener) {
+            return listener();
+          });
+        };
+      },
+      scheduleCallback$2 = Scheduler.unstable_scheduleCallback,
+      NormalPriority = Scheduler.unstable_NormalPriority,
+      CacheContext = {
+        $$typeof: REACT_CONTEXT_TYPE,
+        Consumer: null,
+        Provider: null,
+        _currentValue: null,
+        _currentValue2: null,
+        _threadCount: 0,
+        _currentRenderer: null,
+        _currentRenderer2: null
+      },
+      now = Scheduler.unstable_now,
+      commitStartTime = -0,
+      profilerStartTime = -1.1,
+      profilerEffectDuration = -0,
+      currentUpdateIsNested = !1,
+      nestedUpdateScheduled = !1,
+      firstScheduledRoot = null,
+      lastScheduledRoot = null,
+      didScheduleMicrotask = !1,
+      didScheduleMicrotask_act = !1,
+      mightHavePendingSyncWork = !1,
+      isFlushingWork = !1,
+      currentEventTransitionLane = 0,
+      fakeActCallbackNode$1 = {},
+      currentEntangledListeners = null,
+      currentEntangledPendingCount = 0,
+      currentEntangledLane = 0,
+      currentEntangledActionThenable = null,
+      prevOnStartTransitionFinish = ReactSharedInternals.S;
+    ReactSharedInternals.S = function (transition, returnValue) {
+      "object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && entangleAsyncAction(transition, returnValue);
+      null !== prevOnStartTransitionFinish && prevOnStartTransitionFinish(transition, returnValue);
+    };
+    var resumedCache = createCursor(null),
+      hasOwnProperty = Object.prototype.hasOwnProperty,
+      ReactStrictModeWarnings = {
+        recordUnsafeLifecycleWarnings: function recordUnsafeLifecycleWarnings() {},
+        flushPendingUnsafeLifecycleWarnings: function flushPendingUnsafeLifecycleWarnings() {},
+        recordLegacyContextWarning: function recordLegacyContextWarning() {},
+        flushLegacyContextWarning: function flushLegacyContextWarning() {},
+        discardPendingWarnings: function discardPendingWarnings() {}
+      },
+      pendingComponentWillMountWarnings = [],
+      pendingUNSAFE_ComponentWillMountWarnings = [],
+      pendingComponentWillReceivePropsWarnings = [],
+      pendingUNSAFE_ComponentWillReceivePropsWarnings = [],
+      pendingComponentWillUpdateWarnings = [],
+      pendingUNSAFE_ComponentWillUpdateWarnings = [],
+      didWarnAboutUnsafeLifecycles = new Set();
+    ReactStrictModeWarnings.recordUnsafeLifecycleWarnings = function (fiber, instance) {
+      didWarnAboutUnsafeLifecycles.has(fiber.type) || ("function" === typeof instance.componentWillMount && !0 !== instance.componentWillMount.__suppressDeprecationWarning && pendingComponentWillMountWarnings.push(fiber), fiber.mode & 8 && "function" === typeof instance.UNSAFE_componentWillMount && pendingUNSAFE_ComponentWillMountWarnings.push(fiber), "function" === typeof instance.componentWillReceiveProps && !0 !== instance.componentWillReceiveProps.__suppressDeprecationWarning && pendingComponentWillReceivePropsWarnings.push(fiber), fiber.mode & 8 && "function" === typeof instance.UNSAFE_componentWillReceiveProps && pendingUNSAFE_ComponentWillReceivePropsWarnings.push(fiber), "function" === typeof instance.componentWillUpdate && !0 !== instance.componentWillUpdate.__suppressDeprecationWarning && pendingComponentWillUpdateWarnings.push(fiber), fiber.mode & 8 && "function" === typeof instance.UNSAFE_componentWillUpdate && pendingUNSAFE_ComponentWillUpdateWarnings.push(fiber));
+    };
+    ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings = function () {
+      var componentWillMountUniqueNames = new Set();
+      0 < pendingComponentWillMountWarnings.length && (pendingComponentWillMountWarnings.forEach(function (fiber) {
+        componentWillMountUniqueNames.add(getComponentNameFromFiber(fiber) || "Component");
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      }), pendingComponentWillMountWarnings = []);
+      var UNSAFE_componentWillMountUniqueNames = new Set();
+      0 < pendingUNSAFE_ComponentWillMountWarnings.length && (pendingUNSAFE_ComponentWillMountWarnings.forEach(function (fiber) {
+        UNSAFE_componentWillMountUniqueNames.add(getComponentNameFromFiber(fiber) || "Component");
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      }), pendingUNSAFE_ComponentWillMountWarnings = []);
+      var componentWillReceivePropsUniqueNames = new Set();
+      0 < pendingComponentWillReceivePropsWarnings.length && (pendingComponentWillReceivePropsWarnings.forEach(function (fiber) {
+        componentWillReceivePropsUniqueNames.add(getComponentNameFromFiber(fiber) || "Component");
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      }), pendingComponentWillReceivePropsWarnings = []);
+      var UNSAFE_componentWillReceivePropsUniqueNames = new Set();
+      0 < pendingUNSAFE_ComponentWillReceivePropsWarnings.length && (pendingUNSAFE_ComponentWillReceivePropsWarnings.forEach(function (fiber) {
+        UNSAFE_componentWillReceivePropsUniqueNames.add(getComponentNameFromFiber(fiber) || "Component");
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      }), pendingUNSAFE_ComponentWillReceivePropsWarnings = []);
+      var componentWillUpdateUniqueNames = new Set();
+      0 < pendingComponentWillUpdateWarnings.length && (pendingComponentWillUpdateWarnings.forEach(function (fiber) {
+        componentWillUpdateUniqueNames.add(getComponentNameFromFiber(fiber) || "Component");
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      }), pendingComponentWillUpdateWarnings = []);
+      var UNSAFE_componentWillUpdateUniqueNames = new Set();
+      0 < pendingUNSAFE_ComponentWillUpdateWarnings.length && (pendingUNSAFE_ComponentWillUpdateWarnings.forEach(function (fiber) {
+        UNSAFE_componentWillUpdateUniqueNames.add(getComponentNameFromFiber(fiber) || "Component");
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      }), pendingUNSAFE_ComponentWillUpdateWarnings = []);
+      if (0 < UNSAFE_componentWillMountUniqueNames.size) {
+        var sortedNames = setToSortedString(UNSAFE_componentWillMountUniqueNames);
+        console.error("Using UNSAFE_componentWillMount in strict mode is not recommended and may indicate bugs in your code. See https://react.dev/link/unsafe-component-lifecycles for details.\n\n* Move code with side effects to componentDidMount, and set initial state in the constructor.\n\nPlease update the following components: %s", sortedNames);
+      }
+      0 < UNSAFE_componentWillReceivePropsUniqueNames.size && (sortedNames = setToSortedString(UNSAFE_componentWillReceivePropsUniqueNames), console.error("Using UNSAFE_componentWillReceiveProps in strict mode is not recommended and may indicate bugs in your code. See https://react.dev/link/unsafe-component-lifecycles for details.\n\n* Move data fetching code or side effects to componentDidUpdate.\n* If you're updating state whenever props change, refactor your code to use memoization techniques or move it to static getDerivedStateFromProps. Learn more at: https://react.dev/link/derived-state\n\nPlease update the following components: %s", sortedNames));
+      0 < UNSAFE_componentWillUpdateUniqueNames.size && (sortedNames = setToSortedString(UNSAFE_componentWillUpdateUniqueNames), console.error("Using UNSAFE_componentWillUpdate in strict mode is not recommended and may indicate bugs in your code. See https://react.dev/link/unsafe-component-lifecycles for details.\n\n* Move data fetching code or side effects to componentDidUpdate.\n\nPlease update the following components: %s", sortedNames));
+      0 < componentWillMountUniqueNames.size && (sortedNames = setToSortedString(componentWillMountUniqueNames), console.warn("componentWillMount has been renamed, and is not recommended for use. See https://react.dev/link/unsafe-component-lifecycles for details.\n\n* Move code with side effects to componentDidMount, and set initial state in the constructor.\n* Rename componentWillMount to UNSAFE_componentWillMount to suppress this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. To rename all deprecated lifecycles to their new names, you can run `npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n\nPlease update the following components: %s", sortedNames));
+      0 < componentWillReceivePropsUniqueNames.size && (sortedNames = setToSortedString(componentWillReceivePropsUniqueNames), console.warn("componentWillReceiveProps has been renamed, and is not recommended for use. See https://react.dev/link/unsafe-component-lifecycles for details.\n\n* Move data fetching code or side effects to componentDidUpdate.\n* If you're updating state whenever props change, refactor your code to use memoization techniques or move it to static getDerivedStateFromProps. Learn more at: https://react.dev/link/derived-state\n* Rename componentWillReceiveProps to UNSAFE_componentWillReceiveProps to suppress this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. To rename all deprecated lifecycles to their new names, you can run `npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n\nPlease update the following components: %s", sortedNames));
+      0 < componentWillUpdateUniqueNames.size && (sortedNames = setToSortedString(componentWillUpdateUniqueNames), console.warn("componentWillUpdate has been renamed, and is not recommended for use. See https://react.dev/link/unsafe-component-lifecycles for details.\n\n* Move data fetching code or side effects to componentDidUpdate.\n* Rename componentWillUpdate to UNSAFE_componentWillUpdate to suppress this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. To rename all deprecated lifecycles to their new names, you can run `npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n\nPlease update the following components: %s", sortedNames));
+    };
+    var pendingLegacyContextWarning = new Map(),
+      didWarnAboutLegacyContext = new Set();
+    ReactStrictModeWarnings.recordLegacyContextWarning = function (fiber, instance) {
+      var strictRoot = null;
+      for (var node = fiber; null !== node;) node.mode & 8 && (strictRoot = node), node = node.return;
+      null === strictRoot ? console.error("Expected to find a StrictMode component in a strict mode tree. This error is likely caused by a bug in React. Please file an issue.") : !didWarnAboutLegacyContext.has(fiber.type) && (node = pendingLegacyContextWarning.get(strictRoot), null != fiber.type.contextTypes || null != fiber.type.childContextTypes || null !== instance && "function" === typeof instance.getChildContext) && (void 0 === node && (node = [], pendingLegacyContextWarning.set(strictRoot, node)), node.push(fiber));
+    };
+    ReactStrictModeWarnings.flushLegacyContextWarning = function () {
+      pendingLegacyContextWarning.forEach(function (fiberArray) {
+        if (0 !== fiberArray.length) {
+          var firstFiber = fiberArray[0],
+            uniqueNames = new Set();
+          fiberArray.forEach(function (fiber) {
+            uniqueNames.add(getComponentNameFromFiber(fiber) || "Component");
+            didWarnAboutLegacyContext.add(fiber.type);
+          });
+          var sortedNames = setToSortedString(uniqueNames);
+          runWithFiberInDEV(firstFiber, function () {
+            console.error("Legacy context API has been detected within a strict-mode tree.\n\nThe old API will be supported in all 16.x releases, but applications using it should migrate to the new version.\n\nPlease update the following components: %s\n\nLearn more about this warning here: https://react.dev/link/legacy-context", sortedNames);
+          });
+        }
+      });
+    };
+    ReactStrictModeWarnings.discardPendingWarnings = function () {
+      pendingComponentWillMountWarnings = [];
+      pendingUNSAFE_ComponentWillMountWarnings = [];
+      pendingComponentWillReceivePropsWarnings = [];
+      pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
+      pendingComponentWillUpdateWarnings = [];
+      pendingUNSAFE_ComponentWillUpdateWarnings = [];
+      pendingLegacyContextWarning = new Map();
+    };
+    var SuspenseException = 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`."),
+      SuspenseyCommitException = Error("Suspense Exception: This is not a real error, and should not leak into userspace. If you're seeing this, it's likely a bug in React."),
+      SuspenseActionException = Error("Suspense Exception: This is not a real error! It's an implementation detail of `useActionState` to interrupt the current render. You must either rethrow it immediately, or move the `useActionState` 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."),
+      noopSuspenseyCommitThenable = {
+        then: function then() {
+          console.error('Internal React error: A listener was unexpectedly attached to a "noop" thenable. This is a bug in React. Please file an issue.');
+        }
+      },
+      suspendedThenable = null,
+      needsToResetSuspendedThenableDEV = !1,
+      NoFlags = 0,
+      HasEffect = 1,
+      Insertion = 2,
+      Layout = 4,
+      Passive = 8,
+      concurrentQueues = [],
+      concurrentQueuesIndex = 0,
+      concurrentlyUpdatedLanes = 0,
+      UpdateState = 0,
+      ReplaceState = 1,
+      ForceUpdate = 2,
+      CaptureUpdate = 3,
+      hasForceUpdate = !1;
+    var didWarnUpdateInsideUpdate = !1;
+    var currentlyProcessingQueue = null;
+    var didReadFromEntangledAsyncAction = !1,
+      currentTreeHiddenStackCursor = createCursor(null),
+      prevEntangledRenderLanesCursor = createCursor(0),
+      didWarnUncachedGetSnapshot;
+    var didWarnAboutMismatchedHooksForComponent = new Set();
+    var didWarnAboutUseWrappedInTryCatch = new Set();
+    var didWarnAboutAsyncClientComponent = new Set();
+    var didWarnAboutUseFormState = new Set();
+    var renderLanes = 0,
+      currentlyRenderingFiber = null,
+      currentHook = null,
+      workInProgressHook = null,
+      didScheduleRenderPhaseUpdate = !1,
+      didScheduleRenderPhaseUpdateDuringThisPass = !1,
+      shouldDoubleInvokeUserFnsInHooksDEV = !1,
+      thenableIndexCounter$1 = 0,
+      thenableState$1 = null,
+      globalClientIdCounter = 0,
+      RE_RENDER_LIMIT = 25,
+      currentHookNameInDev = null,
+      hookTypesDev = null,
+      hookTypesUpdateIndexDev = -1,
+      ignorePreviousDependencies = !1,
+      ContextOnlyDispatcher = {
+        readContext: _readContext,
+        use: _use,
+        useCallback: throwInvalidHookError,
+        useContext: throwInvalidHookError,
+        useEffect: throwInvalidHookError,
+        useImperativeHandle: throwInvalidHookError,
+        useLayoutEffect: throwInvalidHookError,
+        useInsertionEffect: throwInvalidHookError,
+        useMemo: throwInvalidHookError,
+        useReducer: throwInvalidHookError,
+        useRef: throwInvalidHookError,
+        useState: throwInvalidHookError,
+        useDebugValue: throwInvalidHookError,
+        useDeferredValue: throwInvalidHookError,
+        useTransition: throwInvalidHookError,
+        useSyncExternalStore: throwInvalidHookError,
+        useId: throwInvalidHookError,
+        useHostTransitionStatus: throwInvalidHookError,
+        useFormState: throwInvalidHookError,
+        useActionState: throwInvalidHookError,
+        useOptimistic: throwInvalidHookError,
+        useMemoCache: throwInvalidHookError,
+        useCacheRefresh: throwInvalidHookError
+      },
+      HooksDispatcherOnMountInDEV = null,
+      HooksDispatcherOnMountWithHookTypesInDEV = null,
+      HooksDispatcherOnUpdateInDEV = null,
+      HooksDispatcherOnRerenderInDEV = null,
+      InvalidNestedHooksDispatcherOnMountInDEV = null,
+      InvalidNestedHooksDispatcherOnUpdateInDEV = null,
+      InvalidNestedHooksDispatcherOnRerenderInDEV = null;
+    HooksDispatcherOnMountInDEV = {
+      readContext: function readContext(context) {
+        return _readContext(context);
+      },
+      use: _use,
+      useCallback: function useCallback(callback, deps) {
+        currentHookNameInDev = "useCallback";
+        mountHookTypesDev();
+        checkDepsAreArrayDev(deps);
+        return mountCallback(callback, deps);
+      },
+      useContext: function useContext(context) {
+        currentHookNameInDev = "useContext";
+        mountHookTypesDev();
+        return _readContext(context);
+      },
+      useEffect: function useEffect(create, createDeps) {
+        currentHookNameInDev = "useEffect";
+        mountHookTypesDev();
+        checkDepsAreArrayDev(createDeps);
+        return mountEffect(create, createDeps);
+      },
+      useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+        currentHookNameInDev = "useImperativeHandle";
+        mountHookTypesDev();
+        checkDepsAreArrayDev(deps);
+        return mountImperativeHandle(ref, create, deps);
+      },
+      useInsertionEffect: function useInsertionEffect(create, deps) {
+        currentHookNameInDev = "useInsertionEffect";
+        mountHookTypesDev();
+        checkDepsAreArrayDev(deps);
+        mountEffectImpl(4, Insertion, create, deps);
+      },
+      useLayoutEffect: function useLayoutEffect(create, deps) {
+        currentHookNameInDev = "useLayoutEffect";
+        mountHookTypesDev();
+        checkDepsAreArrayDev(deps);
+        return mountLayoutEffect(create, deps);
+      },
+      useMemo: function useMemo(create, deps) {
+        currentHookNameInDev = "useMemo";
+        mountHookTypesDev();
+        checkDepsAreArrayDev(deps);
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
+        try {
+          return mountMemo(create, deps);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useReducer: function useReducer(reducer, initialArg, init) {
+        currentHookNameInDev = "useReducer";
+        mountHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
+        try {
+          return mountReducer(reducer, initialArg, init);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useRef: function useRef(initialValue) {
+        currentHookNameInDev = "useRef";
+        mountHookTypesDev();
+        return mountRef(initialValue);
+      },
+      useState: function useState(initialState) {
+        currentHookNameInDev = "useState";
+        mountHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
+        try {
+          return mountState(initialState);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useDebugValue: function useDebugValue() {
+        currentHookNameInDev = "useDebugValue";
+        mountHookTypesDev();
+      },
+      useDeferredValue: function useDeferredValue(value, initialValue) {
+        currentHookNameInDev = "useDeferredValue";
+        mountHookTypesDev();
+        return mountDeferredValue(value, initialValue);
+      },
+      useTransition: function useTransition() {
+        currentHookNameInDev = "useTransition";
+        mountHookTypesDev();
+        return mountTransition();
+      },
+      useSyncExternalStore: function useSyncExternalStore(subscribe, getSnapshot) {
+        currentHookNameInDev = "useSyncExternalStore";
+        mountHookTypesDev();
+        return mountSyncExternalStore(subscribe, getSnapshot);
+      },
+      useId: function useId() {
+        currentHookNameInDev = "useId";
+        mountHookTypesDev();
+        return mountId();
+      },
+      useFormState: function useFormState(action, initialState) {
+        currentHookNameInDev = "useFormState";
+        mountHookTypesDev();
+        warnOnUseFormStateInDev();
+        return mountActionState(action, initialState);
+      },
+      useActionState: function useActionState(action, initialState) {
+        currentHookNameInDev = "useActionState";
+        mountHookTypesDev();
+        return mountActionState(action, initialState);
+      },
+      useOptimistic: function useOptimistic(passthrough) {
+        currentHookNameInDev = "useOptimistic";
+        mountHookTypesDev();
+        return mountOptimistic(passthrough);
+      },
+      useHostTransitionStatus: useHostTransitionStatus,
+      useMemoCache: _useMemoCache,
+      useCacheRefresh: function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        mountHookTypesDev();
+        return mountRefresh();
+      }
+    };
+    HooksDispatcherOnMountWithHookTypesInDEV = {
+      readContext: function readContext(context) {
+        return _readContext(context);
+      },
+      use: _use,
+      useCallback: function useCallback(callback, deps) {
+        currentHookNameInDev = "useCallback";
+        updateHookTypesDev();
+        return mountCallback(callback, deps);
+      },
+      useContext: function useContext(context) {
+        currentHookNameInDev = "useContext";
+        updateHookTypesDev();
+        return _readContext(context);
+      },
+      useEffect: function useEffect(create, createDeps) {
+        currentHookNameInDev = "useEffect";
+        updateHookTypesDev();
+        return mountEffect(create, createDeps);
+      },
+      useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+        currentHookNameInDev = "useImperativeHandle";
+        updateHookTypesDev();
+        return mountImperativeHandle(ref, create, deps);
+      },
+      useInsertionEffect: function useInsertionEffect(create, deps) {
+        currentHookNameInDev = "useInsertionEffect";
+        updateHookTypesDev();
+        mountEffectImpl(4, Insertion, create, deps);
+      },
+      useLayoutEffect: function useLayoutEffect(create, deps) {
+        currentHookNameInDev = "useLayoutEffect";
+        updateHookTypesDev();
+        return mountLayoutEffect(create, deps);
+      },
+      useMemo: function useMemo(create, deps) {
+        currentHookNameInDev = "useMemo";
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
+        try {
+          return mountMemo(create, deps);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useReducer: function useReducer(reducer, initialArg, init) {
+        currentHookNameInDev = "useReducer";
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
+        try {
+          return mountReducer(reducer, initialArg, init);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useRef: function useRef(initialValue) {
+        currentHookNameInDev = "useRef";
+        updateHookTypesDev();
+        return mountRef(initialValue);
+      },
+      useState: function useState(initialState) {
+        currentHookNameInDev = "useState";
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
+        try {
+          return mountState(initialState);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useDebugValue: function useDebugValue() {
+        currentHookNameInDev = "useDebugValue";
+        updateHookTypesDev();
+      },
+      useDeferredValue: function useDeferredValue(value, initialValue) {
+        currentHookNameInDev = "useDeferredValue";
+        updateHookTypesDev();
+        return mountDeferredValue(value, initialValue);
+      },
+      useTransition: function useTransition() {
+        currentHookNameInDev = "useTransition";
+        updateHookTypesDev();
+        return mountTransition();
+      },
+      useSyncExternalStore: function useSyncExternalStore(subscribe, getSnapshot) {
+        currentHookNameInDev = "useSyncExternalStore";
+        updateHookTypesDev();
+        return mountSyncExternalStore(subscribe, getSnapshot);
+      },
+      useId: function useId() {
+        currentHookNameInDev = "useId";
+        updateHookTypesDev();
+        return mountId();
+      },
+      useActionState: function useActionState(action, initialState) {
+        currentHookNameInDev = "useActionState";
+        updateHookTypesDev();
+        return mountActionState(action, initialState);
+      },
+      useFormState: function useFormState(action, initialState) {
+        currentHookNameInDev = "useFormState";
+        updateHookTypesDev();
+        warnOnUseFormStateInDev();
+        return mountActionState(action, initialState);
+      },
+      useOptimistic: function useOptimistic(passthrough) {
+        currentHookNameInDev = "useOptimistic";
+        updateHookTypesDev();
+        return mountOptimistic(passthrough);
+      },
+      useHostTransitionStatus: useHostTransitionStatus,
+      useMemoCache: _useMemoCache,
+      useCacheRefresh: function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        updateHookTypesDev();
+        return mountRefresh();
+      }
+    };
+    HooksDispatcherOnUpdateInDEV = {
+      readContext: function readContext(context) {
+        return _readContext(context);
+      },
+      use: _use,
+      useCallback: function useCallback(callback, deps) {
+        currentHookNameInDev = "useCallback";
+        updateHookTypesDev();
+        return updateCallback(callback, deps);
+      },
+      useContext: function useContext(context) {
+        currentHookNameInDev = "useContext";
+        updateHookTypesDev();
+        return _readContext(context);
+      },
+      useEffect: function useEffect(create, createDeps) {
+        currentHookNameInDev = "useEffect";
+        updateHookTypesDev();
+        updateEffectImpl(2048, Passive, create, createDeps);
+      },
+      useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+        currentHookNameInDev = "useImperativeHandle";
+        updateHookTypesDev();
+        return updateImperativeHandle(ref, create, deps);
+      },
+      useInsertionEffect: function useInsertionEffect(create, deps) {
+        currentHookNameInDev = "useInsertionEffect";
+        updateHookTypesDev();
+        return updateEffectImpl(4, Insertion, create, deps);
+      },
+      useLayoutEffect: function useLayoutEffect(create, deps) {
+        currentHookNameInDev = "useLayoutEffect";
+        updateHookTypesDev();
+        return updateEffectImpl(4, Layout, create, deps);
+      },
+      useMemo: function useMemo(create, deps) {
+        currentHookNameInDev = "useMemo";
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
+        try {
+          return updateMemo(create, deps);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useReducer: function useReducer(reducer, initialArg, init) {
+        currentHookNameInDev = "useReducer";
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
+        try {
+          return updateReducer(reducer, initialArg, init);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useRef: function useRef() {
+        currentHookNameInDev = "useRef";
+        updateHookTypesDev();
+        return updateWorkInProgressHook().memoizedState;
+      },
+      useState: function useState() {
+        currentHookNameInDev = "useState";
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
+        try {
+          return updateReducer(basicStateReducer);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useDebugValue: function useDebugValue() {
+        currentHookNameInDev = "useDebugValue";
+        updateHookTypesDev();
+      },
+      useDeferredValue: function useDeferredValue(value, initialValue) {
+        currentHookNameInDev = "useDeferredValue";
+        updateHookTypesDev();
+        return updateDeferredValue(value, initialValue);
+      },
+      useTransition: function useTransition() {
+        currentHookNameInDev = "useTransition";
+        updateHookTypesDev();
+        return updateTransition();
+      },
+      useSyncExternalStore: function useSyncExternalStore(subscribe, getSnapshot) {
+        currentHookNameInDev = "useSyncExternalStore";
+        updateHookTypesDev();
+        return updateSyncExternalStore(subscribe, getSnapshot);
+      },
+      useId: function useId() {
+        currentHookNameInDev = "useId";
+        updateHookTypesDev();
+        return updateWorkInProgressHook().memoizedState;
+      },
+      useFormState: function useFormState(action) {
+        currentHookNameInDev = "useFormState";
+        updateHookTypesDev();
+        warnOnUseFormStateInDev();
+        return updateActionState(action);
+      },
+      useActionState: function useActionState(action) {
+        currentHookNameInDev = "useActionState";
+        updateHookTypesDev();
+        return updateActionState(action);
+      },
+      useOptimistic: function useOptimistic(passthrough, reducer) {
+        currentHookNameInDev = "useOptimistic";
+        updateHookTypesDev();
+        return updateOptimistic(passthrough, reducer);
+      },
+      useHostTransitionStatus: useHostTransitionStatus,
+      useMemoCache: _useMemoCache,
+      useCacheRefresh: function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        updateHookTypesDev();
+        return updateWorkInProgressHook().memoizedState;
+      }
+    };
+    HooksDispatcherOnRerenderInDEV = {
+      readContext: function readContext(context) {
+        return _readContext(context);
+      },
+      use: _use,
+      useCallback: function useCallback(callback, deps) {
+        currentHookNameInDev = "useCallback";
+        updateHookTypesDev();
+        return updateCallback(callback, deps);
+      },
+      useContext: function useContext(context) {
+        currentHookNameInDev = "useContext";
+        updateHookTypesDev();
+        return _readContext(context);
+      },
+      useEffect: function useEffect(create, createDeps) {
+        currentHookNameInDev = "useEffect";
+        updateHookTypesDev();
+        updateEffectImpl(2048, Passive, create, createDeps);
+      },
+      useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+        currentHookNameInDev = "useImperativeHandle";
+        updateHookTypesDev();
+        return updateImperativeHandle(ref, create, deps);
+      },
+      useInsertionEffect: function useInsertionEffect(create, deps) {
+        currentHookNameInDev = "useInsertionEffect";
+        updateHookTypesDev();
+        return updateEffectImpl(4, Insertion, create, deps);
+      },
+      useLayoutEffect: function useLayoutEffect(create, deps) {
+        currentHookNameInDev = "useLayoutEffect";
+        updateHookTypesDev();
+        return updateEffectImpl(4, Layout, create, deps);
+      },
+      useMemo: function useMemo(create, deps) {
+        currentHookNameInDev = "useMemo";
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnRerenderInDEV;
+        try {
+          return updateMemo(create, deps);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useReducer: function useReducer(reducer, initialArg, init) {
+        currentHookNameInDev = "useReducer";
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnRerenderInDEV;
+        try {
+          return rerenderReducer(reducer, initialArg, init);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useRef: function useRef() {
+        currentHookNameInDev = "useRef";
+        updateHookTypesDev();
+        return updateWorkInProgressHook().memoizedState;
+      },
+      useState: function useState() {
+        currentHookNameInDev = "useState";
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnRerenderInDEV;
+        try {
+          return rerenderReducer(basicStateReducer);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useDebugValue: function useDebugValue() {
+        currentHookNameInDev = "useDebugValue";
+        updateHookTypesDev();
+      },
+      useDeferredValue: function useDeferredValue(value, initialValue) {
+        currentHookNameInDev = "useDeferredValue";
+        updateHookTypesDev();
+        return rerenderDeferredValue(value, initialValue);
+      },
+      useTransition: function useTransition() {
+        currentHookNameInDev = "useTransition";
+        updateHookTypesDev();
+        return rerenderTransition();
+      },
+      useSyncExternalStore: function useSyncExternalStore(subscribe, getSnapshot) {
+        currentHookNameInDev = "useSyncExternalStore";
+        updateHookTypesDev();
+        return updateSyncExternalStore(subscribe, getSnapshot);
+      },
+      useId: function useId() {
+        currentHookNameInDev = "useId";
+        updateHookTypesDev();
+        return updateWorkInProgressHook().memoizedState;
+      },
+      useFormState: function useFormState(action) {
+        currentHookNameInDev = "useFormState";
+        updateHookTypesDev();
+        warnOnUseFormStateInDev();
+        return rerenderActionState(action);
+      },
+      useActionState: function useActionState(action) {
+        currentHookNameInDev = "useActionState";
+        updateHookTypesDev();
+        return rerenderActionState(action);
+      },
+      useOptimistic: function useOptimistic(passthrough, reducer) {
+        currentHookNameInDev = "useOptimistic";
+        updateHookTypesDev();
+        return rerenderOptimistic(passthrough, reducer);
+      },
+      useHostTransitionStatus: useHostTransitionStatus,
+      useMemoCache: _useMemoCache,
+      useCacheRefresh: function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        updateHookTypesDev();
+        return updateWorkInProgressHook().memoizedState;
+      }
+    };
+    InvalidNestedHooksDispatcherOnMountInDEV = {
+      readContext: function readContext(context) {
+        warnInvalidContextAccess();
+        return _readContext(context);
+      },
+      use: function use(usable) {
+        warnInvalidHookAccess();
+        return _use(usable);
+      },
+      useCallback: function useCallback(callback, deps) {
+        currentHookNameInDev = "useCallback";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountCallback(callback, deps);
+      },
+      useContext: function useContext(context) {
+        currentHookNameInDev = "useContext";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return _readContext(context);
+      },
+      useEffect: function useEffect(create, createDeps) {
+        currentHookNameInDev = "useEffect";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountEffect(create, createDeps);
+      },
+      useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+        currentHookNameInDev = "useImperativeHandle";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountImperativeHandle(ref, create, deps);
+      },
+      useInsertionEffect: function useInsertionEffect(create, deps) {
+        currentHookNameInDev = "useInsertionEffect";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        mountEffectImpl(4, Insertion, create, deps);
+      },
+      useLayoutEffect: function useLayoutEffect(create, deps) {
+        currentHookNameInDev = "useLayoutEffect";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountLayoutEffect(create, deps);
+      },
+      useMemo: function useMemo(create, deps) {
+        currentHookNameInDev = "useMemo";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
+        try {
+          return mountMemo(create, deps);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useReducer: function useReducer(reducer, initialArg, init) {
+        currentHookNameInDev = "useReducer";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
+        try {
+          return mountReducer(reducer, initialArg, init);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useRef: function useRef(initialValue) {
+        currentHookNameInDev = "useRef";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountRef(initialValue);
+      },
+      useState: function useState(initialState) {
+        currentHookNameInDev = "useState";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
+        try {
+          return mountState(initialState);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useDebugValue: function useDebugValue() {
+        currentHookNameInDev = "useDebugValue";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+      },
+      useDeferredValue: function useDeferredValue(value, initialValue) {
+        currentHookNameInDev = "useDeferredValue";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountDeferredValue(value, initialValue);
+      },
+      useTransition: function useTransition() {
+        currentHookNameInDev = "useTransition";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountTransition();
+      },
+      useSyncExternalStore: function useSyncExternalStore(subscribe, getSnapshot) {
+        currentHookNameInDev = "useSyncExternalStore";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountSyncExternalStore(subscribe, getSnapshot);
+      },
+      useId: function useId() {
+        currentHookNameInDev = "useId";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountId();
+      },
+      useFormState: function useFormState(action, initialState) {
+        currentHookNameInDev = "useFormState";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountActionState(action, initialState);
+      },
+      useActionState: function useActionState(action, initialState) {
+        currentHookNameInDev = "useActionState";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountActionState(action, initialState);
+      },
+      useOptimistic: function useOptimistic(passthrough) {
+        currentHookNameInDev = "useOptimistic";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountOptimistic(passthrough);
+      },
+      useMemoCache: function useMemoCache(size) {
+        warnInvalidHookAccess();
+        return _useMemoCache(size);
+      },
+      useHostTransitionStatus: useHostTransitionStatus,
+      useCacheRefresh: function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        mountHookTypesDev();
+        return mountRefresh();
+      }
+    };
+    InvalidNestedHooksDispatcherOnUpdateInDEV = {
+      readContext: function readContext(context) {
+        warnInvalidContextAccess();
+        return _readContext(context);
+      },
+      use: function use(usable) {
+        warnInvalidHookAccess();
+        return _use(usable);
+      },
+      useCallback: function useCallback(callback, deps) {
+        currentHookNameInDev = "useCallback";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateCallback(callback, deps);
+      },
+      useContext: function useContext(context) {
+        currentHookNameInDev = "useContext";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return _readContext(context);
+      },
+      useEffect: function useEffect(create, createDeps) {
+        currentHookNameInDev = "useEffect";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        updateEffectImpl(2048, Passive, create, createDeps);
+      },
+      useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+        currentHookNameInDev = "useImperativeHandle";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateImperativeHandle(ref, create, deps);
+      },
+      useInsertionEffect: function useInsertionEffect(create, deps) {
+        currentHookNameInDev = "useInsertionEffect";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateEffectImpl(4, Insertion, create, deps);
+      },
+      useLayoutEffect: function useLayoutEffect(create, deps) {
+        currentHookNameInDev = "useLayoutEffect";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateEffectImpl(4, Layout, create, deps);
+      },
+      useMemo: function useMemo(create, deps) {
+        currentHookNameInDev = "useMemo";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
+        try {
+          return updateMemo(create, deps);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useReducer: function useReducer(reducer, initialArg, init) {
+        currentHookNameInDev = "useReducer";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
+        try {
+          return updateReducer(reducer, initialArg, init);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useRef: function useRef() {
+        currentHookNameInDev = "useRef";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateWorkInProgressHook().memoizedState;
+      },
+      useState: function useState() {
+        currentHookNameInDev = "useState";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
+        try {
+          return updateReducer(basicStateReducer);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useDebugValue: function useDebugValue() {
+        currentHookNameInDev = "useDebugValue";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+      },
+      useDeferredValue: function useDeferredValue(value, initialValue) {
+        currentHookNameInDev = "useDeferredValue";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateDeferredValue(value, initialValue);
+      },
+      useTransition: function useTransition() {
+        currentHookNameInDev = "useTransition";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateTransition();
+      },
+      useSyncExternalStore: function useSyncExternalStore(subscribe, getSnapshot) {
+        currentHookNameInDev = "useSyncExternalStore";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateSyncExternalStore(subscribe, getSnapshot);
+      },
+      useId: function useId() {
+        currentHookNameInDev = "useId";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateWorkInProgressHook().memoizedState;
+      },
+      useFormState: function useFormState(action) {
+        currentHookNameInDev = "useFormState";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateActionState(action);
+      },
+      useActionState: function useActionState(action) {
+        currentHookNameInDev = "useActionState";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateActionState(action);
+      },
+      useOptimistic: function useOptimistic(passthrough, reducer) {
+        currentHookNameInDev = "useOptimistic";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateOptimistic(passthrough, reducer);
+      },
+      useMemoCache: function useMemoCache(size) {
+        warnInvalidHookAccess();
+        return _useMemoCache(size);
+      },
+      useHostTransitionStatus: useHostTransitionStatus,
+      useCacheRefresh: function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        updateHookTypesDev();
+        return updateWorkInProgressHook().memoizedState;
+      }
+    };
+    InvalidNestedHooksDispatcherOnRerenderInDEV = {
+      readContext: function readContext(context) {
+        warnInvalidContextAccess();
+        return _readContext(context);
+      },
+      use: function use(usable) {
+        warnInvalidHookAccess();
+        return _use(usable);
+      },
+      useCallback: function useCallback(callback, deps) {
+        currentHookNameInDev = "useCallback";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateCallback(callback, deps);
+      },
+      useContext: function useContext(context) {
+        currentHookNameInDev = "useContext";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return _readContext(context);
+      },
+      useEffect: function useEffect(create, createDeps) {
+        currentHookNameInDev = "useEffect";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        updateEffectImpl(2048, Passive, create, createDeps);
+      },
+      useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+        currentHookNameInDev = "useImperativeHandle";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateImperativeHandle(ref, create, deps);
+      },
+      useInsertionEffect: function useInsertionEffect(create, deps) {
+        currentHookNameInDev = "useInsertionEffect";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateEffectImpl(4, Insertion, create, deps);
+      },
+      useLayoutEffect: function useLayoutEffect(create, deps) {
+        currentHookNameInDev = "useLayoutEffect";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateEffectImpl(4, Layout, create, deps);
+      },
+      useMemo: function useMemo(create, deps) {
+        currentHookNameInDev = "useMemo";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
+        try {
+          return updateMemo(create, deps);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useReducer: function useReducer(reducer, initialArg, init) {
+        currentHookNameInDev = "useReducer";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
+        try {
+          return rerenderReducer(reducer, initialArg, init);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useRef: function useRef() {
+        currentHookNameInDev = "useRef";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateWorkInProgressHook().memoizedState;
+      },
+      useState: function useState() {
+        currentHookNameInDev = "useState";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
+        try {
+          return rerenderReducer(basicStateReducer);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useDebugValue: function useDebugValue() {
+        currentHookNameInDev = "useDebugValue";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+      },
+      useDeferredValue: function useDeferredValue(value, initialValue) {
+        currentHookNameInDev = "useDeferredValue";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return rerenderDeferredValue(value, initialValue);
+      },
+      useTransition: function useTransition() {
+        currentHookNameInDev = "useTransition";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return rerenderTransition();
+      },
+      useSyncExternalStore: function useSyncExternalStore(subscribe, getSnapshot) {
+        currentHookNameInDev = "useSyncExternalStore";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateSyncExternalStore(subscribe, getSnapshot);
+      },
+      useId: function useId() {
+        currentHookNameInDev = "useId";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateWorkInProgressHook().memoizedState;
+      },
+      useFormState: function useFormState(action) {
+        currentHookNameInDev = "useFormState";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return rerenderActionState(action);
+      },
+      useActionState: function useActionState(action) {
+        currentHookNameInDev = "useActionState";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return rerenderActionState(action);
+      },
+      useOptimistic: function useOptimistic(passthrough, reducer) {
+        currentHookNameInDev = "useOptimistic";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return rerenderOptimistic(passthrough, reducer);
+      },
+      useMemoCache: function useMemoCache(size) {
+        warnInvalidHookAccess();
+        return _useMemoCache(size);
+      },
+      useHostTransitionStatus: useHostTransitionStatus,
+      useCacheRefresh: function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        updateHookTypesDev();
+        return updateWorkInProgressHook().memoizedState;
+      }
+    };
+    var callComponent = {
+        "react-stack-bottom-frame": function reactStackBottomFrame(Component, props, secondArg) {
+          var wasRendering = isRendering;
+          isRendering = !0;
+          try {
+            return Component(props, secondArg);
+          } finally {
+            isRendering = wasRendering;
+          }
+        }
+      },
+      callComponentInDEV = callComponent["react-stack-bottom-frame"].bind(callComponent),
+      callRender = {
+        "react-stack-bottom-frame": function reactStackBottomFrame(instance) {
+          var wasRendering = isRendering;
+          isRendering = !0;
+          try {
+            return instance.render();
+          } finally {
+            isRendering = wasRendering;
+          }
+        }
+      },
+      callRenderInDEV = callRender["react-stack-bottom-frame"].bind(callRender),
+      callComponentDidMount = {
+        "react-stack-bottom-frame": function reactStackBottomFrame(finishedWork, instance) {
+          try {
+            instance.componentDidMount();
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      },
+      callComponentDidMountInDEV = callComponentDidMount["react-stack-bottom-frame"].bind(callComponentDidMount),
+      callComponentDidUpdate = {
+        "react-stack-bottom-frame": function reactStackBottomFrame(finishedWork, instance, prevProps, prevState, snapshot) {
+          try {
+            instance.componentDidUpdate(prevProps, prevState, snapshot);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      },
+      callComponentDidUpdateInDEV = callComponentDidUpdate["react-stack-bottom-frame"].bind(callComponentDidUpdate),
+      callComponentDidCatch = {
+        "react-stack-bottom-frame": function reactStackBottomFrame(instance, errorInfo) {
+          var stack = errorInfo.stack;
+          instance.componentDidCatch(errorInfo.value, {
+            componentStack: null !== stack ? stack : ""
+          });
+        }
+      },
+      callComponentDidCatchInDEV = callComponentDidCatch["react-stack-bottom-frame"].bind(callComponentDidCatch),
+      callComponentWillUnmount = {
+        "react-stack-bottom-frame": function reactStackBottomFrame(current, nearestMountedAncestor, instance) {
+          try {
+            instance.componentWillUnmount();
+          } catch (error) {
+            captureCommitPhaseError(current, nearestMountedAncestor, error);
+          }
+        }
+      },
+      callComponentWillUnmountInDEV = callComponentWillUnmount["react-stack-bottom-frame"].bind(callComponentWillUnmount),
+      callCreate = {
+        "react-stack-bottom-frame": function reactStackBottomFrame(effect) {
+          null != effect.resourceKind && console.error("Expected only SimpleEffects when enableUseEffectCRUDOverload is disabled, got %s", effect.resourceKind);
+          var create = effect.create;
+          effect = effect.inst;
+          create = create();
+          return effect.destroy = create;
+        }
+      },
+      callCreateInDEV = callCreate["react-stack-bottom-frame"].bind(callCreate),
+      callDestroy = {
+        "react-stack-bottom-frame": function reactStackBottomFrame(current, nearestMountedAncestor, destroy) {
+          try {
+            destroy();
+          } catch (error) {
+            captureCommitPhaseError(current, nearestMountedAncestor, error);
+          }
+        }
+      },
+      callDestroyInDEV = callDestroy["react-stack-bottom-frame"].bind(callDestroy),
+      callLazyInit = {
+        "react-stack-bottom-frame": function reactStackBottomFrame(lazy) {
+          var init = lazy._init;
+          return init(lazy._payload);
+        }
+      },
+      callLazyInitInDEV = callLazyInit["react-stack-bottom-frame"].bind(callLazyInit),
+      thenableState = null,
+      thenableIndexCounter = 0,
+      currentDebugInfo = null,
+      didWarnAboutMaps;
+    var didWarnAboutGenerators = didWarnAboutMaps = !1;
+    var ownerHasKeyUseWarning = {};
+    var ownerHasFunctionTypeWarning = {};
+    var ownerHasSymbolTypeWarning = {};
+    warnForMissingKey = function warnForMissingKey(returnFiber, workInProgress, child) {
+      if (null !== child && "object" === typeof child && child._store && (!child._store.validated && null == child.key || 2 === child._store.validated)) {
+        if ("object" !== typeof child._store) throw Error("React Component in warnForMissingKey should have a _store. This error is likely caused by a bug in React. Please file an issue.");
+        child._store.validated = 1;
+        var componentName = getComponentNameFromFiber(returnFiber),
+          componentKey = componentName || "null";
+        if (!ownerHasKeyUseWarning[componentKey]) {
+          ownerHasKeyUseWarning[componentKey] = !0;
+          child = child._owner;
+          returnFiber = returnFiber._debugOwner;
+          var currentComponentErrorInfo = "";
+          returnFiber && "number" === typeof returnFiber.tag && (componentKey = getComponentNameFromFiber(returnFiber)) && (currentComponentErrorInfo = "\n\nCheck the render method of `" + componentKey + "`.");
+          currentComponentErrorInfo || componentName && (currentComponentErrorInfo = "\n\nCheck the top-level render call using <" + componentName + ">.");
+          var childOwnerAppendix = "";
+          null != child && returnFiber !== child && (componentName = null, "number" === typeof child.tag ? componentName = getComponentNameFromFiber(child) : "string" === typeof child.name && (componentName = child.name), componentName && (childOwnerAppendix = " It was passed a child from " + componentName + "."));
+          runWithFiberInDEV(workInProgress, function () {
+            console.error('Each child in a list should have a unique "key" prop.%s%s See https://react.dev/link/warning-keys for more information.', currentComponentErrorInfo, childOwnerAppendix);
+          });
+        }
+      }
+    };
+    var reconcileChildFibers = createChildReconciler(!0),
+      mountChildFibers = createChildReconciler(!1),
+      suspenseHandlerStackCursor = createCursor(null),
+      shellBoundary = null,
+      SubtreeSuspenseContextMask = 1,
+      ForceSuspenseFallback = 2,
+      suspenseStackCursor = createCursor(0),
+      fakeInternalInstance = {};
+    var didWarnAboutStateAssignmentForComponent = new Set();
+    var didWarnAboutUninitializedState = new Set();
+    var didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = new Set();
+    var didWarnAboutLegacyLifecyclesAndDerivedState = new Set();
+    var didWarnAboutDirectlyAssigningPropsToState = new Set();
+    var didWarnAboutUndefinedDerivedState = new Set();
+    var didWarnAboutContextTypes$1 = new Set();
+    var didWarnAboutChildContextTypes = new Set();
+    var didWarnAboutInvalidateContextType = new Set();
+    var didWarnOnInvalidCallback = new Set();
+    Object.freeze(fakeInternalInstance);
+    var classComponentUpdater = {
+        enqueueSetState: function enqueueSetState(inst, payload, callback) {
+          inst = inst._reactInternals;
+          var lane = requestUpdateLane(inst),
+            update = createUpdate(lane);
+          update.payload = payload;
+          void 0 !== callback && null !== callback && (warnOnInvalidCallback(callback), update.callback = callback);
+          payload = enqueueUpdate(inst, update, lane);
+          null !== payload && (scheduleUpdateOnFiber(payload, inst, lane), entangleTransitions(payload, inst, lane));
+          markStateUpdateScheduled(inst, lane);
+        },
+        enqueueReplaceState: function enqueueReplaceState(inst, payload, callback) {
+          inst = inst._reactInternals;
+          var lane = requestUpdateLane(inst),
+            update = createUpdate(lane);
+          update.tag = ReplaceState;
+          update.payload = payload;
+          void 0 !== callback && null !== callback && (warnOnInvalidCallback(callback), update.callback = callback);
+          payload = enqueueUpdate(inst, update, lane);
+          null !== payload && (scheduleUpdateOnFiber(payload, inst, lane), entangleTransitions(payload, inst, lane));
+          markStateUpdateScheduled(inst, lane);
+        },
+        enqueueForceUpdate: function enqueueForceUpdate(inst, callback) {
+          inst = inst._reactInternals;
+          var lane = requestUpdateLane(inst),
+            update = createUpdate(lane);
+          update.tag = ForceUpdate;
+          void 0 !== callback && null !== callback && (warnOnInvalidCallback(callback), update.callback = callback);
+          callback = enqueueUpdate(inst, update, lane);
+          null !== callback && (scheduleUpdateOnFiber(callback, inst, lane), entangleTransitions(callback, inst, lane));
+          null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markForceUpdateScheduled && injectedProfilingHooks.markForceUpdateScheduled(inst, lane);
+        }
+      },
+      reportGlobalError = "function" === typeof reportError ? reportError : function (error) {
+        if ("object" === typeof window && "function" === typeof window.ErrorEvent) {
+          var event = new window.ErrorEvent("error", {
+            bubbles: !0,
+            cancelable: !0,
+            message: "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error),
+            error: error
+          });
+          if (!window.dispatchEvent(event)) return;
+        } else if ("object" === typeof process && "function" === typeof process.emit) {
+          process.emit("uncaughtException", error);
+          return;
+        }
+        console.error(error);
+      },
+      componentName = null,
+      errorBoundaryName = null,
+      SelectiveHydrationException = Error("This is not a real error. It's an implementation detail of React's selective hydration feature. If this leaks into userspace, it's a bug in React. Please file an issue."),
+      didReceiveUpdate = !1;
+    var didWarnAboutBadClass = {};
+    var didWarnAboutContextTypeOnFunctionComponent = {};
+    var didWarnAboutContextTypes = {};
+    var didWarnAboutGetDerivedStateOnFunctionComponent = {};
+    var didWarnAboutReassigningProps = !1;
+    var didWarnAboutRevealOrder = {};
+    var didWarnAboutTailOptions = {};
+    var SUSPENDED_MARKER = {
+        dehydrated: null,
+        treeContext: null,
+        retryLane: 0,
+        hydrationErrors: null
+      },
+      hasWarnedAboutUsingNoValuePropOnContextProvider = !1,
+      didWarnAboutUndefinedSnapshotBeforeUpdate = null;
+    didWarnAboutUndefinedSnapshotBeforeUpdate = new Set();
+    var offscreenSubtreeIsHidden = !1,
+      offscreenSubtreeWasHidden = !1,
+      PossiblyWeakSet = "function" === typeof WeakSet ? WeakSet : Set,
+      nextEffect = null,
+      inProgressLanes = null,
+      inProgressRoot = null,
+      suspenseyCommitFlag = 8192,
+      DefaultAsyncDispatcher = {
+        getCacheForType: function getCacheForType(resourceType) {
+          var cache = _readContext(CacheContext),
+            cacheForType = cache.data.get(resourceType);
+          void 0 === cacheForType && (cacheForType = resourceType(), cache.data.set(resourceType, cacheForType));
+          return cacheForType;
+        },
+        getOwner: function getOwner() {
+          return current;
+        }
+      };
+    if ("function" === typeof Symbol && Symbol.for) {
+      var symbolFor = Symbol.for;
+      symbolFor("selector.component");
+      symbolFor("selector.has_pseudo_class");
+      symbolFor("selector.role");
+      symbolFor("selector.test_id");
+      symbolFor("selector.text");
+    }
+    var PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map,
+      NoContext = 0,
+      RenderContext = 2,
+      CommitContext = 4,
+      RootInProgress = 0,
+      RootFatalErrored = 1,
+      RootErrored = 2,
+      RootSuspended = 3,
+      RootSuspendedWithDelay = 4,
+      RootSuspendedAtTheShell = 6,
+      RootCompleted = 5,
+      executionContext = NoContext,
+      workInProgressRoot = null,
+      workInProgress = null,
+      workInProgressRootRenderLanes = 0,
+      NotSuspended = 0,
+      SuspendedOnError = 1,
+      SuspendedOnData = 2,
+      SuspendedOnImmediate = 3,
+      SuspendedOnInstance = 4,
+      SuspendedOnInstanceAndReadyToContinue = 5,
+      SuspendedOnDeprecatedThrowPromise = 6,
+      SuspendedAndReadyToContinue = 7,
+      SuspendedOnHydration = 8,
+      SuspendedOnAction = 9,
+      workInProgressSuspendedReason = NotSuspended,
+      workInProgressThrownValue = null,
+      workInProgressRootDidSkipSuspendedSiblings = !1,
+      workInProgressRootIsPrerendering = !1,
+      workInProgressRootDidAttachPingListener = !1,
+      entangledRenderLanes = 0,
+      workInProgressRootExitStatus = RootInProgress,
+      workInProgressRootSkippedLanes = 0,
+      workInProgressRootInterleavedUpdatedLanes = 0,
+      workInProgressRootPingedLanes = 0,
+      workInProgressDeferredLane = 0,
+      workInProgressSuspendedRetryLanes = 0,
+      workInProgressRootConcurrentErrors = null,
+      workInProgressRootRecoverableErrors = null,
+      workInProgressRootDidIncludeRecursiveRenderUpdate = !1,
+      globalMostRecentFallbackTime = 0,
+      FALLBACK_THROTTLE_MS = 300,
+      workInProgressRootRenderTargetTime = Infinity,
+      RENDER_TIMEOUT_MS = 500,
+      workInProgressTransitions = null,
+      legacyErrorBoundariesThatAlreadyFailed = null,
+      IMMEDIATE_COMMIT = 0,
+      THROTTLED_COMMIT = 2,
+      NO_PENDING_EFFECTS = 0,
+      PENDING_MUTATION_PHASE = 1,
+      PENDING_LAYOUT_PHASE = 2,
+      PENDING_AFTER_MUTATION_PHASE = 3,
+      PENDING_SPAWNED_WORK = 4,
+      PENDING_PASSIVE_PHASE = 5,
+      pendingEffectsStatus = 0,
+      pendingEffectsRoot = null,
+      pendingFinishedWork = null,
+      pendingEffectsLanes = 0,
+      pendingEffectsRemainingLanes = 0,
+      pendingPassiveTransitions = null,
+      pendingRecoverableErrors = null,
+      NESTED_UPDATE_LIMIT = 50,
+      nestedUpdateCount = 0,
+      rootWithNestedUpdates = null,
+      isFlushingPassiveEffects = !1,
+      didScheduleUpdateDuringPassiveEffects = !1,
+      NESTED_PASSIVE_UPDATE_LIMIT = 50,
+      nestedPassiveUpdateCount = 0,
+      rootWithPassiveNestedUpdates = null,
+      isRunningInsertionEffect = !1,
+      didWarnStateUpdateForNotYetMountedComponent = null,
+      didWarnAboutUpdateInRender = !1;
+    var didWarnAboutUpdateInRenderForAnotherComponent = new Set();
+    var fakeActCallbackNode = {},
+      resolveFamily = null,
+      failedBoundaries = null;
+    var hasBadMapPolyfill = !1;
+    try {
+      var nonExtensibleObject = Object.preventExtensions({});
+      new Map([[nonExtensibleObject, null]]);
+      new Set([nonExtensibleObject]);
+    } catch (e) {
+      hasBadMapPolyfill = !0;
+    }
+    var didWarnAboutNestedUpdates = !1;
+    var didWarnAboutFindNodeInStrictMode = {};
+    var overrideHookState = null,
+      overrideHookStateDeletePath = null,
+      overrideHookStateRenamePath = null,
+      overrideProps = null,
+      overridePropsDeletePath = null,
+      overridePropsRenamePath = null,
+      scheduleUpdate = null,
+      setErrorHandler = null,
+      setSuspenseHandler = null;
+    overrideHookState = function overrideHookState(fiber, id, path, value) {
+      id = findHook(fiber, id);
+      null !== id && (path = copyWithSetImpl(id.memoizedState, path, 0, value), id.memoizedState = path, id.baseState = path, fiber.memoizedProps = assign({}, fiber.memoizedProps), path = enqueueConcurrentRenderForLane(fiber, 2), null !== path && scheduleUpdateOnFiber(path, fiber, 2));
+    };
+    overrideHookStateDeletePath = function overrideHookStateDeletePath(fiber, id, path) {
+      id = findHook(fiber, id);
+      null !== id && (path = copyWithDeleteImpl(id.memoizedState, path, 0), id.memoizedState = path, id.baseState = path, fiber.memoizedProps = assign({}, fiber.memoizedProps), path = enqueueConcurrentRenderForLane(fiber, 2), null !== path && scheduleUpdateOnFiber(path, fiber, 2));
+    };
+    overrideHookStateRenamePath = function overrideHookStateRenamePath(fiber, id, oldPath, newPath) {
+      id = findHook(fiber, id);
+      null !== id && (oldPath = copyWithRename(id.memoizedState, oldPath, newPath), id.memoizedState = oldPath, id.baseState = oldPath, fiber.memoizedProps = assign({}, fiber.memoizedProps), oldPath = enqueueConcurrentRenderForLane(fiber, 2), null !== oldPath && scheduleUpdateOnFiber(oldPath, fiber, 2));
+    };
+    overrideProps = function overrideProps(fiber, path, value) {
+      fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path, 0, value);
+      fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
+      path = enqueueConcurrentRenderForLane(fiber, 2);
+      null !== path && scheduleUpdateOnFiber(path, fiber, 2);
+    };
+    overridePropsDeletePath = function overridePropsDeletePath(fiber, path) {
+      fiber.pendingProps = copyWithDeleteImpl(fiber.memoizedProps, path, 0);
+      fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
+      path = enqueueConcurrentRenderForLane(fiber, 2);
+      null !== path && scheduleUpdateOnFiber(path, fiber, 2);
+    };
+    overridePropsRenamePath = function overridePropsRenamePath(fiber, oldPath, newPath) {
+      fiber.pendingProps = copyWithRename(fiber.memoizedProps, oldPath, newPath);
+      fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
+      oldPath = enqueueConcurrentRenderForLane(fiber, 2);
+      null !== oldPath && scheduleUpdateOnFiber(oldPath, fiber, 2);
+    };
+    scheduleUpdate = function scheduleUpdate(fiber) {
+      var root = enqueueConcurrentRenderForLane(fiber, 2);
+      null !== root && scheduleUpdateOnFiber(root, fiber, 2);
+    };
+    setErrorHandler = function setErrorHandler(newShouldErrorImpl) {
+      shouldErrorImpl = newShouldErrorImpl;
+    };
+    setSuspenseHandler = function setSuspenseHandler(newShouldSuspendImpl) {
+      shouldSuspendImpl = newShouldSuspendImpl;
+    };
+    var emptyObject = Object.freeze({});
+    var getInspectorDataForInstance = function getInspectorDataForInstance(closestInstance) {
+      if (!closestInstance) return {
+        hierarchy: [],
+        props: emptyObject,
+        selectedIndex: null,
+        componentStack: ""
+      };
+      closestInstance = findCurrentFiberUsingSlowPath(closestInstance);
+      if (null === closestInstance) return {
+        hierarchy: [],
+        props: emptyObject,
+        selectedIndex: null,
+        componentStack: ""
+      };
+      var hierarchy = [];
+      traverseOwnerTreeUp(hierarchy, closestInstance);
+      var instance;
+      a: {
+        for (instance = hierarchy.length - 1; 1 < instance; instance--) {
+          var instance$jscomp$0 = hierarchy[instance];
+          if (5 !== instance$jscomp$0.tag) {
+            instance = instance$jscomp$0;
+            break a;
+          }
+        }
+        instance = hierarchy[0];
+      }
+      instance$jscomp$0 = createHierarchy(hierarchy);
+      var props = getHostProps(instance);
+      hierarchy = hierarchy.indexOf(instance);
+      closestInstance = getStackByFiberInDevAndProd(closestInstance);
+      return {
+        closestInstance: instance,
+        hierarchy: instance$jscomp$0,
+        props: props,
+        selectedIndex: hierarchy,
+        componentStack: closestInstance
+      };
+    };
+    var supportsHydration = !1,
+      isSuspenseInstancePending = shim$1,
+      isSuspenseInstanceFallback = shim$1,
+      getSuspenseInstanceFallbackErrorDetails = shim$1,
+      registerSuspenseInstanceRetry = shim$1,
+      preloadResource = shim,
+      suspendResource = shim,
+      _nativeFabricUIManage = nativeFabricUIManager,
+      createNode = _nativeFabricUIManage.createNode,
+      cloneNodeWithNewChildren = _nativeFabricUIManage.cloneNodeWithNewChildren,
+      cloneNodeWithNewChildrenAndProps = _nativeFabricUIManage.cloneNodeWithNewChildrenAndProps,
+      cloneNodeWithNewProps = _nativeFabricUIManage.cloneNodeWithNewProps,
+      createChildNodeSet = _nativeFabricUIManage.createChildSet,
+      appendChildNode = _nativeFabricUIManage.appendChild,
+      appendChildNodeToSet = _nativeFabricUIManage.appendChildToSet,
+      completeRoot = _nativeFabricUIManage.completeRoot,
+      registerEventHandler = _nativeFabricUIManage.registerEventHandler,
+      FabricDiscretePriority = _nativeFabricUIManage.unstable_DiscreteEventPriority,
+      fabricGetCurrentEventPriority = _nativeFabricUIManage.unstable_getCurrentEventPriority,
+      extraDevToolsConfig = {
+        getInspectorDataForInstance: getInspectorDataForInstance,
+        getInspectorDataForViewTag: function getInspectorDataForViewTag(viewTag) {
+          viewTag = instanceCache.get(viewTag) || null;
+          return getInspectorDataForInstance(viewTag);
+        },
+        getInspectorDataForViewAtPoint: function getInspectorDataForViewAtPoint(inspectedView, locationX, locationY, callback) {
+          var closestInstance = null,
+            fabricNode = ReactNativePrivateInterface.getNodeFromPublicInstance(inspectedView);
+          fabricNode ? nativeFabricUIManager.findNodeAtPoint(fabricNode, locationX, locationY, function (internalInstanceHandle) {
+            var node = null != internalInstanceHandle ? getNodeFromInternalInstanceHandle(internalInstanceHandle) : null;
+            if (null == internalInstanceHandle || null == node) callback(assign({
+              pointerY: locationY,
+              frame: {
+                left: 0,
+                top: 0,
+                width: 0,
+                height: 0
+              }
+            }, getInspectorDataForInstance(closestInstance)));else {
+              closestInstance = internalInstanceHandle.stateNode.canonical.internalInstanceHandle;
+              var closestPublicInstance = internalInstanceHandle.stateNode.canonical.publicInstance,
+                nativeViewTag = internalInstanceHandle.stateNode.canonical.nativeTag;
+              nativeFabricUIManager.measure(node, function (x, y, width, height, pageX, pageY) {
+                x = getInspectorDataForInstance(closestInstance);
+                callback(assign({}, x, {
+                  pointerY: locationY,
+                  frame: {
+                    left: pageX,
+                    top: pageY,
+                    width: width,
+                    height: height
+                  },
+                  touchedViewTag: nativeViewTag,
+                  closestPublicInstance: closestPublicInstance
+                }));
+              });
+            }
+          }) : null != inspectedView._internalFiberInstanceHandleDEV ? ReactNativePrivateInterface.UIManager.findSubviewIn(findNodeHandle(inspectedView), [locationX, locationY], function (nativeViewTag, left, top, width, height) {
+            var inspectorData = getInspectorDataForInstance(instanceCache.get(nativeViewTag) || null);
+            callback(assign({}, inspectorData, {
+              pointerY: locationY,
+              frame: {
+                left: left,
+                top: top,
+                width: width,
+                height: height
+              },
+              touchedViewTag: nativeViewTag,
+              closestPublicInstance: nativeViewTag
+            }));
+          }) : console.error("getInspectorDataForViewAtPoint expects to receive a host component");
+        }
+      },
+      getViewConfigForType = ReactNativePrivateInterface.ReactNativeViewConfigRegistry.get,
+      nextReactTag = 2;
+    registerEventHandler && registerEventHandler(dispatchEvent);
+    var currentUpdatePriority = 0,
+      warnsIfNotActing = !1,
+      scheduleTimeout = setTimeout,
+      cancelTimeout = clearTimeout,
+      noTimeout = -1,
+      NotPendingTransition = null,
+      HostTransitionContext = {
+        $$typeof: REACT_CONTEXT_TYPE,
+        Provider: null,
+        Consumer: null,
+        _currentValue: NotPendingTransition,
+        _currentValue2: NotPendingTransition,
+        _threadCount: 0
+      },
+      supportsMicrotasks = "undefined" !== typeof RN$enableMicrotasksInReact && !!RN$enableMicrotasksInReact,
+      scheduleMicrotask = "function" === typeof queueMicrotask ? queueMicrotask : scheduleTimeout;
+    (function (getFiberCurrentPropsFromNodeImpl, getInstanceFromNodeImpl, getNodeFromInstanceImpl) {
+      getFiberCurrentPropsFromNode$1 = getFiberCurrentPropsFromNodeImpl;
+      getInstanceFromNode$1 = getInstanceFromNodeImpl;
+      (getNodeFromInstance$1 = getNodeFromInstanceImpl) && getInstanceFromNode$1 || console.error("Injected module is missing getNodeFromInstance or getInstanceFromNode.");
+    })(function (instance) {
+      return instance.canonical.currentProps;
+    }, function (node) {
+      return null != node.canonical && null != node.canonical.internalInstanceHandle ? node.canonical.internalInstanceHandle : node;
+    }, function (fiber) {
+      fiber = getPublicInstance(fiber.stateNode);
+      if (null == fiber) throw Error("Could not find host instance from fiber");
+      return fiber;
+    });
+    ResponderEventPlugin.injection.injectGlobalResponderHandler({
+      onChange: function onChange(from, to, blockNativeResponder) {
+        from && from.stateNode && nativeFabricUIManager.setIsJSResponder(from.stateNode.node, !1, blockNativeResponder || !1);
+        to && to.stateNode && nativeFabricUIManager.setIsJSResponder(to.stateNode.node, !0, blockNativeResponder || !1);
+      }
+    });
+    if ("function" !== typeof ReactNativePrivateInterface.ReactFiberErrorDialog.showErrorDialog) throw Error("Expected ReactFiberErrorDialog.showErrorDialog to be a function.");
+    batchedUpdatesImpl = function batchedUpdatesImpl(fn, a) {
+      var prevExecutionContext = executionContext;
+      executionContext |= 1;
+      try {
+        return fn(a);
+      } finally {
+        executionContext = prevExecutionContext, executionContext !== NoContext || ReactSharedInternals.isBatchingLegacy || (workInProgressRootRenderTargetTime = now$1() + RENDER_TIMEOUT_MS, flushSyncWorkAcrossRoots_impl(0, !0));
+      }
+    };
+    var roots = new Map();
+    (function () {
+      var internals = {
+        bundleType: 1,
+        version: "19.1.0",
+        rendererPackageName: "react-native-renderer",
+        currentDispatcherRef: ReactSharedInternals,
+        reconcilerVersion: "19.1.0"
+      };
+      null !== extraDevToolsConfig && (internals.rendererConfig = extraDevToolsConfig);
+      internals.overrideHookState = overrideHookState;
+      internals.overrideHookStateDeletePath = overrideHookStateDeletePath;
+      internals.overrideHookStateRenamePath = overrideHookStateRenamePath;
+      internals.overrideProps = overrideProps;
+      internals.overridePropsDeletePath = overridePropsDeletePath;
+      internals.overridePropsRenamePath = overridePropsRenamePath;
+      internals.scheduleUpdate = scheduleUpdate;
+      internals.setErrorHandler = setErrorHandler;
+      internals.setSuspenseHandler = setSuspenseHandler;
+      internals.scheduleRefresh = scheduleRefresh;
+      internals.scheduleRoot = scheduleRoot;
+      internals.setRefreshHandler = setRefreshHandler;
+      internals.getCurrentFiber = getCurrentFiberForDevTools;
+      internals.getLaneLabelMap = getLaneLabelMap;
+      internals.injectProfilingHooks = injectProfilingHooks;
+      return injectInternals(internals);
+    })();
+    exports.createPortal = function (children, containerTag) {
+      return createPortal$1(children, containerTag, null, 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null);
+    };
+    exports.dispatchCommand = function (handle, command, args) {
+      var nativeTag = null != handle._nativeTag ? handle._nativeTag : ReactNativePrivateInterface.getNativeTagFromPublicInstance(handle);
+      null == nativeTag ? console.error("dispatchCommand was called with a ref that isn't a native component. Use React.forwardRef to get access to the underlying native component") : (handle = ReactNativePrivateInterface.getNodeFromPublicInstance(handle), null != handle ? nativeFabricUIManager.dispatchCommand(handle, command, args) : ReactNativePrivateInterface.UIManager.dispatchViewManagerCommand(nativeTag, command, args));
+    };
+    exports.findHostInstance_DEPRECATED = function (componentOrHandle) {
+      var owner = current;
+      null !== owner && isRendering && null !== owner.stateNode && (owner.stateNode._warnedAboutRefsInRender || console.error("%s is accessing findNodeHandle inside its render(). render() should be a pure function of props and state. It should never access something that requires stale data from the previous render, such as refs. Move this logic to componentDidMount and componentDidUpdate instead.", getComponentNameFromType(owner.type) || "A component"), owner.stateNode._warnedAboutRefsInRender = !0);
+      return null == componentOrHandle ? null : componentOrHandle.canonical && componentOrHandle.canonical.publicInstance ? componentOrHandle.canonical.publicInstance : componentOrHandle._nativeTag ? componentOrHandle : findHostInstanceWithWarning(componentOrHandle, "findHostInstance_DEPRECATED");
+    };
+    exports.findNodeHandle = findNodeHandle;
+    exports.getNodeFromInternalInstanceHandle = getNodeFromInternalInstanceHandle;
+    exports.getPublicInstanceFromInternalInstanceHandle = function (internalInstanceHandle) {
+      var instance = internalInstanceHandle.stateNode;
+      return null == instance ? null : 6 === internalInstanceHandle.tag ? (null == instance.publicInstance && (instance.publicInstance = ReactNativePrivateInterface.createPublicTextInstance(internalInstanceHandle)), instance.publicInstance) : getPublicInstance(internalInstanceHandle.stateNode);
+    };
+    exports.getPublicInstanceFromRootTag = function (rootTag) {
+      return (rootTag = roots.get(rootTag)) ? rootTag.containerInfo.publicInstance : null;
+    };
+    exports.isChildPublicInstance = function (parentInstance, childInstance) {
+      if (parentInstance._internalFiberInstanceHandleDEV && childInstance._internalFiberInstanceHandleDEV) return doesFiberContain(parentInstance._internalFiberInstanceHandleDEV, childInstance._internalFiberInstanceHandleDEV);
+      parentInstance = ReactNativePrivateInterface.getInternalInstanceHandleFromPublicInstance(parentInstance);
+      childInstance = ReactNativePrivateInterface.getInternalInstanceHandleFromPublicInstance(childInstance);
+      return null != parentInstance && null != childInstance ? doesFiberContain(parentInstance, childInstance) : !1;
+    };
+    exports.render = function (element, containerTag, callback, concurrentRoot, options) {
+      var root = roots.get(containerTag);
+      if (!root) {
+        root = nativeOnUncaughtError;
+        var onCaughtError = nativeOnCaughtError,
+          onRecoverableError = defaultOnRecoverableError;
+        options && void 0 !== options.onUncaughtError && (root = options.onUncaughtError);
+        options && void 0 !== options.onCaughtError && (onCaughtError = options.onCaughtError);
+        options && void 0 !== options.onRecoverableError && (onRecoverableError = options.onRecoverableError);
+        options = {
+          publicInstance: ReactNativePrivateInterface.createPublicRootInstance(containerTag),
+          containerTag: containerTag
+        };
+        concurrentRoot = concurrentRoot ? 1 : 0;
+        root = new FiberRootNode(options, concurrentRoot, !1, "", root, onCaughtError, onRecoverableError, null);
+        concurrentRoot = 1 === concurrentRoot ? 1 : 0;
+        isDevToolsPresent && (concurrentRoot |= 2);
+        concurrentRoot = createFiber(3, null, null, concurrentRoot);
+        root.current = concurrentRoot;
+        concurrentRoot.stateNode = root;
+        onCaughtError = createCache();
+        retainCache(onCaughtError);
+        root.pooledCache = onCaughtError;
+        retainCache(onCaughtError);
+        concurrentRoot.memoizedState = {
+          element: null,
+          isDehydrated: !1,
+          cache: onCaughtError
+        };
+        initializeUpdateQueue(concurrentRoot);
+        roots.set(containerTag, root);
+      }
+      updateContainer(element, root, null, callback);
+      a: if (element = root.current, element.child) switch (element.child.tag) {
+        case 27:
+        case 5:
+          element = getPublicInstance(element.child.stateNode);
+          break a;
+        default:
+          element = element.child.stateNode;
+      } else element = null;
+      return element;
+    };
+    exports.sendAccessibilityEvent = function (handle, eventType) {
+      var nativeTag = null != handle._nativeTag ? handle._nativeTag : ReactNativePrivateInterface.getNativeTagFromPublicInstance(handle);
+      null == nativeTag ? console.error("sendAccessibilityEvent was called with a ref that isn't a native component. Use React.forwardRef to get access to the underlying native component") : (handle = ReactNativePrivateInterface.getNodeFromPublicInstance(handle), null != handle ? nativeFabricUIManager.sendAccessibilityEvent(handle, eventType) : ReactNativePrivateInterface.legacySendAccessibilityEvent(nativeTag, eventType));
+    };
+    exports.stopSurface = function (containerTag) {
+      var root = roots.get(containerTag);
+      root && updateContainer(null, root, null, function () {
+        root.containerInfo.publicInstance = null;
+        roots.delete(containerTag);
+      });
+    };
+    exports.unmountComponentAtNode = function (containerTag) {
+      this.stopSurface(containerTag);
+    };
+    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  }();
+},109,[110,73,322,516],"../../node_modules/react-native/Libraries/Renderer/implementations/ReactFabric-dev.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  _$$_REQUIRE(_dependencyMap[0], "../Core/InitializeCore");
+},110,[111],"../../node_modules/react-native/Libraries/ReactPrivate/ReactNativePrivateInitializeCore.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use client';
+  'use strict';
+
+  var start = Date.now();
+  _$$_REQUIRE(_dependencyMap[0], "./setUpGlobals");
+  _$$_REQUIRE(_dependencyMap[1], "../../src/private/setup/setUpDOM").default();
+  _$$_REQUIRE(_dependencyMap[2], "./setUpPerformance");
+  _$$_REQUIRE(_dependencyMap[3], "./polyfillPromise");
+  _$$_REQUIRE(_dependencyMap[4], "./setUpTimers");
+  if (__DEV__) {
+    _$$_REQUIRE(_dependencyMap[5], "./setUpReactDevTools");
+  }
+  _$$_REQUIRE(_dependencyMap[6], "./setUpErrorHandling");
+  _$$_REQUIRE(_dependencyMap[7], "./setUpRegeneratorRuntime");
+  _$$_REQUIRE(_dependencyMap[8], "./setUpXHR");
+  _$$_REQUIRE(_dependencyMap[9], "./setUpAlert");
+  _$$_REQUIRE(_dependencyMap[10], "./setUpNavigator");
+  _$$_REQUIRE(_dependencyMap[11], "./setUpBatchedBridge");
+  _$$_REQUIRE(_dependencyMap[12], "./setUpSegmentFetcher");
+  if (__DEV__) {
+    _$$_REQUIRE(_dependencyMap[13], "./checkNativeVersion");
+    _$$_REQUIRE(_dependencyMap[14], "./setUpDeveloperTools");
+    _$$_REQUIRE(_dependencyMap[15], "../LogBox/LogBox").default.install();
+  }
+  _$$_REQUIRE(_dependencyMap[16], "../ReactNative/AppRegistry");
+  _$$_REQUIRE(_dependencyMap[17], "../Utilities/GlobalPerformanceLogger").default.markPoint('initializeCore_start', _$$_REQUIRE(_dependencyMap[17], "../Utilities/GlobalPerformanceLogger").default.currentTimestamp() - (Date.now() - start));
+  _$$_REQUIRE(_dependencyMap[17], "../Utilities/GlobalPerformanceLogger").default.markPoint('initializeCore_end');
+},111,[112,113,139,151,194,202,243,244,247,267,274,275,290,293,296,153,302,250],"../../node_modules/react-native/Libraries/Core/InitializeCore.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use client';
+  'use strict';
+
+  if (global.window === undefined) {
+    global.window = global;
+  }
+  if (global.self === undefined) {
+    global.self = global;
+  }
+  global.process = global.process || {};
+  global.process.env = global.process.env || {};
+  if (!global.process.env.NODE_ENV) {
+    global.process.env.NODE_ENV = __DEV__ ? 'development' : 'production';
+  }
+},112,[],"../../node_modules/react-native/Libraries/Core/setUpGlobals.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = setUpDOM;
+  var initialized = false;
+  function setUpDOM() {
+    if (initialized) {
+      return;
+    }
+    initialized = true;
+    (0, _$$_REQUIRE(_dependencyMap[0], "../../../Libraries/Utilities/PolyfillFunctions").polyfillGlobal)('DOMRect', function () {
+      return _$$_REQUIRE(_dependencyMap[1], "../webapis/geometry/DOMRect").default;
+    });
+    (0, _$$_REQUIRE(_dependencyMap[0], "../../../Libraries/Utilities/PolyfillFunctions").polyfillGlobal)('DOMRectReadOnly', function () {
+      return _$$_REQUIRE(_dependencyMap[2], "../webapis/geometry/DOMRectReadOnly").default;
+    });
+    (0, _$$_REQUIRE(_dependencyMap[0], "../../../Libraries/Utilities/PolyfillFunctions").polyfillGlobal)('DOMRectList', function () {
+      return _$$_REQUIRE(_dependencyMap[3], "../webapis/geometry/DOMRectList").default;
+    });
+    (0, _$$_REQUIRE(_dependencyMap[0], "../../../Libraries/Utilities/PolyfillFunctions").polyfillGlobal)('HTMLCollection', function () {
+      return _$$_REQUIRE(_dependencyMap[4], "../webapis/dom/oldstylecollections/HTMLCollection").default;
+    });
+    (0, _$$_REQUIRE(_dependencyMap[0], "../../../Libraries/Utilities/PolyfillFunctions").polyfillGlobal)('NodeList', function () {
+      return _$$_REQUIRE(_dependencyMap[5], "../webapis/dom/oldstylecollections/NodeList").default;
+    });
+    (0, _$$_REQUIRE(_dependencyMap[0], "../../../Libraries/Utilities/PolyfillFunctions").polyfillGlobal)('Node', function () {
+      return _$$_REQUIRE(_dependencyMap[6], "../webapis/dom/nodes/ReadOnlyNode").default;
+    });
+    (0, _$$_REQUIRE(_dependencyMap[0], "../../../Libraries/Utilities/PolyfillFunctions").polyfillGlobal)('Document', function () {
+      return _$$_REQUIRE(_dependencyMap[7], "../webapis/dom/nodes/ReactNativeDocument").default;
+    });
+    (0, _$$_REQUIRE(_dependencyMap[0], "../../../Libraries/Utilities/PolyfillFunctions").polyfillGlobal)('CharacterData', function () {
+      return _$$_REQUIRE(_dependencyMap[8], "../webapis/dom/nodes/ReadOnlyCharacterData").default;
+    });
+    (0, _$$_REQUIRE(_dependencyMap[0], "../../../Libraries/Utilities/PolyfillFunctions").polyfillGlobal)('Text', function () {
+      return _$$_REQUIRE(_dependencyMap[9], "../webapis/dom/nodes/ReadOnlyText").default;
+    });
+    (0, _$$_REQUIRE(_dependencyMap[0], "../../../Libraries/Utilities/PolyfillFunctions").polyfillGlobal)('Element', function () {
+      return _$$_REQUIRE(_dependencyMap[10], "../webapis/dom/nodes/ReadOnlyElement").default;
+    });
+    (0, _$$_REQUIRE(_dependencyMap[0], "../../../Libraries/Utilities/PolyfillFunctions").polyfillGlobal)('HTMLElement', function () {
+      return _$$_REQUIRE(_dependencyMap[11], "../webapis/dom/nodes/ReactNativeElement").default;
+    });
+  }
+},113,[114,115,116,117,119,120,121,128,137,138,126,129],"../../node_modules/react-native/src/private/setup/setUpDOM.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.polyfillGlobal = polyfillGlobal;
+  exports.polyfillObjectProperty = polyfillObjectProperty;
+  function polyfillObjectProperty(object, name, getValue) {
+    var descriptor = Object.getOwnPropertyDescriptor(object, name);
+    if (__DEV__ && descriptor) {
+      var backupName = `original${name[0].toUpperCase()}${name.slice(1)}`;
+      Object.defineProperty(object, backupName, descriptor);
+    }
+    var _ref = descriptor || {},
+      enumerable = _ref.enumerable,
+      writable = _ref.writable,
+      _ref$configurable = _ref.configurable,
+      configurable = _ref$configurable === void 0 ? false : _ref$configurable;
+    if (descriptor && !configurable) {
+      console.error('Failed to set polyfill. ' + name + ' is not configurable.');
+      return;
+    }
+    _$$_REQUIRE(_dependencyMap[0], "./defineLazyObjectProperty").default(object, name, {
+      get: getValue,
+      enumerable: enumerable !== false,
+      writable: writable !== false
+    });
+  }
+  function polyfillGlobal(name, getValue) {
+    polyfillObjectProperty(global, name, getValue);
+  }
+},114,[50],"../../node_modules/react-native/Libraries/Utilities/PolyfillFunctions.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var _DOMRectReadOnly2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./DOMRectReadOnly"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var DOMRect = exports.default = /*#__PURE__*/function (_DOMRectReadOnly) {
+    function DOMRect() {
+      (0, _classCallCheck2.default)(this, DOMRect);
+      return _callSuper(this, DOMRect, arguments);
+    }
+    (0, _inherits2.default)(DOMRect, _DOMRectReadOnly);
+    return (0, _createClass2.default)(DOMRect, [{
+      key: "x",
+      get: function get() {
+        return this.__getInternalX();
+      },
+      set: function set(x) {
+        this.__setInternalX(x);
+      }
+    }, {
+      key: "y",
+      get: function get() {
+        return this.__getInternalY();
+      },
+      set: function set(y) {
+        this.__setInternalY(y);
+      }
+    }, {
+      key: "width",
+      get: function get() {
+        return this.__getInternalWidth();
+      },
+      set: function set(width) {
+        this.__setInternalWidth(width);
+      }
+    }, {
+      key: "height",
+      get: function get() {
+        return this.__getInternalHeight();
+      },
+      set: function set(height) {
+        this.__setInternalHeight(height);
+      }
+    }], [{
+      key: "fromRect",
+      value: function fromRect(rect) {
+        if (!rect) {
+          return new DOMRect();
+        }
+        return new DOMRect(rect.x, rect.y, rect.width, rect.height);
+      }
+    }]);
+  }(_DOMRectReadOnly2.default);
+},115,[1,11,12,18,20,23,116],"../../node_modules/react-native/src/private/webapis/geometry/DOMRect.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _classPrivateFieldLooseBase2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classPrivateFieldLooseBase"));
+  var _classPrivateFieldLooseKey2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classPrivateFieldLooseKey"));
+  function castToNumber(value) {
+    return value ? Number(value) : 0;
+  }
+  var _x = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("x");
+  var _y = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("y");
+  var _width = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("width");
+  var _height = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("height");
+  var DOMRectReadOnly = exports.default = /*#__PURE__*/function () {
+    function DOMRectReadOnly(x, y, width, height) {
+      (0, _classCallCheck2.default)(this, DOMRectReadOnly);
+      Object.defineProperty(this, _x, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(this, _y, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(this, _width, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(this, _height, {
+        writable: true,
+        value: void 0
+      });
+      this.__setInternalX(x);
+      this.__setInternalY(y);
+      this.__setInternalWidth(width);
+      this.__setInternalHeight(height);
+    }
+    return (0, _createClass2.default)(DOMRectReadOnly, [{
+      key: "x",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _x)[_x];
+      }
+    }, {
+      key: "y",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _y)[_y];
+      }
+    }, {
+      key: "width",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _width)[_width];
+      }
+    }, {
+      key: "height",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _height)[_height];
+      }
+    }, {
+      key: "top",
+      get: function get() {
+        var height = (0, _classPrivateFieldLooseBase2.default)(this, _height)[_height];
+        var y = (0, _classPrivateFieldLooseBase2.default)(this, _y)[_y];
+        if (height < 0) {
+          return y + height;
+        }
+        return y;
+      }
+    }, {
+      key: "right",
+      get: function get() {
+        var width = (0, _classPrivateFieldLooseBase2.default)(this, _width)[_width];
+        var x = (0, _classPrivateFieldLooseBase2.default)(this, _x)[_x];
+        if (width < 0) {
+          return x;
+        }
+        return x + width;
+      }
+    }, {
+      key: "bottom",
+      get: function get() {
+        var height = (0, _classPrivateFieldLooseBase2.default)(this, _height)[_height];
+        var y = (0, _classPrivateFieldLooseBase2.default)(this, _y)[_y];
+        if (height < 0) {
+          return y;
+        }
+        return y + height;
+      }
+    }, {
+      key: "left",
+      get: function get() {
+        var width = (0, _classPrivateFieldLooseBase2.default)(this, _width)[_width];
+        var x = (0, _classPrivateFieldLooseBase2.default)(this, _x)[_x];
+        if (width < 0) {
+          return x + width;
+        }
+        return x;
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON() {
+        var x = this.x,
+          y = this.y,
+          width = this.width,
+          height = this.height,
+          top = this.top,
+          left = this.left,
+          bottom = this.bottom,
+          right = this.right;
+        return {
+          x: x,
+          y: y,
+          width: width,
+          height: height,
+          top: top,
+          left: left,
+          bottom: bottom,
+          right: right
+        };
+      }
+    }, {
+      key: "__getInternalX",
+      value: function __getInternalX() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _x)[_x];
+      }
+    }, {
+      key: "__getInternalY",
+      value: function __getInternalY() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _y)[_y];
+      }
+    }, {
+      key: "__getInternalWidth",
+      value: function __getInternalWidth() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _width)[_width];
+      }
+    }, {
+      key: "__getInternalHeight",
+      value: function __getInternalHeight() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _height)[_height];
+      }
+    }, {
+      key: "__setInternalX",
+      value: function __setInternalX(x) {
+        (0, _classPrivateFieldLooseBase2.default)(this, _x)[_x] = castToNumber(x);
+      }
+    }, {
+      key: "__setInternalY",
+      value: function __setInternalY(y) {
+        (0, _classPrivateFieldLooseBase2.default)(this, _y)[_y] = castToNumber(y);
+      }
+    }, {
+      key: "__setInternalWidth",
+      value: function __setInternalWidth(width) {
+        (0, _classPrivateFieldLooseBase2.default)(this, _width)[_width] = castToNumber(width);
+      }
+    }, {
+      key: "__setInternalHeight",
+      value: function __setInternalHeight(height) {
+        (0, _classPrivateFieldLooseBase2.default)(this, _height)[_height] = castToNumber(height);
+      }
+    }], [{
+      key: "fromRect",
+      value: function fromRect(rect) {
+        if (!rect) {
+          return new DOMRectReadOnly();
+        }
+        return new DOMRectReadOnly(rect.x, rect.y, rect.width, rect.height);
+      }
+    }]);
+  }();
+},116,[1,11,12,26,27],"../../node_modules/react-native/src/private/webapis/geometry/DOMRectReadOnly.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.createDOMRectList = createDOMRectList;
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _classPrivateFieldLooseBase2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classPrivateFieldLooseBase"));
+  var _classPrivateFieldLooseKey2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classPrivateFieldLooseKey"));
+  var _length = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("length");
+  var DOMRectList = exports.default = /*#__PURE__*/function () {
+    function DOMRectList(elements) {
+      (0, _classCallCheck2.default)(this, DOMRectList);
+      Object.defineProperty(this, _length, {
+        writable: true,
+        value: void 0
+      });
+      for (var i = 0; i < elements.length; i++) {
+        Object.defineProperty(this, i, {
+          value: elements[i],
+          enumerable: true,
+          configurable: false,
+          writable: false
+        });
+      }
+      (0, _classPrivateFieldLooseBase2.default)(this, _length)[_length] = elements.length;
+    }
+    return (0, _createClass2.default)(DOMRectList, [{
+      key: "length",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _length)[_length];
+      }
+    }, {
+      key: "item",
+      value: function item(index) {
+        if (index < 0 || index >= (0, _classPrivateFieldLooseBase2.default)(this, _length)[_length]) {
+          return null;
+        }
+        var arrayLike = this;
+        return arrayLike[index];
+      }
+    }, {
+      key: Symbol.iterator,
+      value: function value() {
+        return (0, _$$_REQUIRE(_dependencyMap[5], "../utils/ArrayLikeUtils").createValueIterator)(this);
+      }
+    }]);
+  }();
+  function createDOMRectList(elements) {
+    return new DOMRectList(elements);
+  }
+},117,[1,11,12,26,27,118],"../../node_modules/react-native/src/private/webapis/geometry/DOMRectList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.createEntriesIterator = createEntriesIterator;
+  exports.createKeyIterator = createKeyIterator;
+  exports.createValueIterator = createValueIterator;
+  function* createValueIterator(arrayLike) {
+    for (var i = 0; i < arrayLike.length; i++) {
+      yield arrayLike[i];
+    }
+  }
+  function* createKeyIterator(arrayLike) {
+    for (var i = 0; i < arrayLike.length; i++) {
+      yield i;
+    }
+  }
+  function* createEntriesIterator(arrayLike) {
+    for (var i = 0; i < arrayLike.length; i++) {
+      yield [i, arrayLike[i]];
+    }
+  }
+},118,[],"../../node_modules/react-native/src/private/webapis/utils/ArrayLikeUtils.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.createHTMLCollection = createHTMLCollection;
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _classPrivateFieldLooseBase2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classPrivateFieldLooseBase"));
+  var _classPrivateFieldLooseKey2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classPrivateFieldLooseKey"));
+  var _length = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("length");
+  var HTMLCollection = exports.default = /*#__PURE__*/function () {
+    function HTMLCollection(elements) {
+      (0, _classCallCheck2.default)(this, HTMLCollection);
+      Object.defineProperty(this, _length, {
+        writable: true,
+        value: void 0
+      });
+      for (var i = 0; i < elements.length; i++) {
+        Object.defineProperty(this, i, {
+          value: elements[i],
+          enumerable: true,
+          configurable: false,
+          writable: false
+        });
+      }
+      (0, _classPrivateFieldLooseBase2.default)(this, _length)[_length] = elements.length;
+    }
+    return (0, _createClass2.default)(HTMLCollection, [{
+      key: "length",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _length)[_length];
+      }
+    }, {
+      key: "item",
+      value: function item(index) {
+        if (index < 0 || index >= (0, _classPrivateFieldLooseBase2.default)(this, _length)[_length]) {
+          return null;
+        }
+        var arrayLike = this;
+        return arrayLike[index];
+      }
+    }, {
+      key: "namedItem",
+      value: function namedItem(name) {
+        return null;
+      }
+    }, {
+      key: Symbol.iterator,
+      value: function value() {
+        return (0, _$$_REQUIRE(_dependencyMap[5], "../../utils/ArrayLikeUtils").createValueIterator)(this);
+      }
+    }]);
+  }();
+  function createHTMLCollection(elements) {
+    return new HTMLCollection(elements);
+  }
+},119,[1,11,12,26,27,118],"../../node_modules/react-native/src/private/webapis/dom/oldstylecollections/HTMLCollection.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.createNodeList = createNodeList;
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _classPrivateFieldLooseBase2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classPrivateFieldLooseBase"));
+  var _classPrivateFieldLooseKey2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classPrivateFieldLooseKey"));
+  var _length = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("length");
+  var NodeList = exports.default = /*#__PURE__*/function () {
+    function NodeList(elements) {
+      (0, _classCallCheck2.default)(this, NodeList);
+      Object.defineProperty(this, _length, {
+        writable: true,
+        value: void 0
+      });
+      for (var i = 0; i < elements.length; i++) {
+        Object.defineProperty(this, i, {
+          value: elements[i],
+          writable: false
+        });
+      }
+      (0, _classPrivateFieldLooseBase2.default)(this, _length)[_length] = elements.length;
+    }
+    return (0, _createClass2.default)(NodeList, [{
+      key: "length",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _length)[_length];
+      }
+    }, {
+      key: "item",
+      value: function item(index) {
+        if (index < 0 || index >= (0, _classPrivateFieldLooseBase2.default)(this, _length)[_length]) {
+          return null;
+        }
+        var arrayLike = this;
+        return arrayLike[index];
+      }
+    }, {
+      key: "entries",
+      value: function entries() {
+        return (0, _$$_REQUIRE(_dependencyMap[5], "../../utils/ArrayLikeUtils").createEntriesIterator)(this);
+      }
+    }, {
+      key: "forEach",
+      value: function forEach(callbackFn, thisArg) {
+        var arrayLike = this;
+        for (var _index = 0; _index < (0, _classPrivateFieldLooseBase2.default)(this, _length)[_length]; _index++) {
+          if (thisArg == null) {
+            callbackFn(arrayLike[_index], _index, this);
+          } else {
+            callbackFn.call(thisArg, arrayLike[_index], _index, this);
+          }
+        }
+      }
+    }, {
+      key: "keys",
+      value: function keys() {
+        return (0, _$$_REQUIRE(_dependencyMap[5], "../../utils/ArrayLikeUtils").createKeyIterator)(this);
+      }
+    }, {
+      key: "values",
+      value: function values() {
+        return (0, _$$_REQUIRE(_dependencyMap[5], "../../utils/ArrayLikeUtils").createValueIterator)(this);
+      }
+    }, {
+      key: Symbol.iterator,
+      value: function value() {
+        return (0, _$$_REQUIRE(_dependencyMap[5], "../../utils/ArrayLikeUtils").createValueIterator)(this);
+      }
+    }]);
+  }();
+  function createNodeList(elements) {
+    return new NodeList(elements);
+  }
+},120,[1,11,12,26,27,118],"../../node_modules/react-native/src/private/webapis/dom/oldstylecollections/NodeList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  exports.getChildNodes = getChildNodes;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+  var ReactNativeFeatureFlags = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[4], "../../../featureflags/ReactNativeFeatureFlags"));
+  var _NativeDOM = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./specs/NativeDOM"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var ReadOnlyNode = exports.default = /*#__PURE__*/function () {
+    function ReadOnlyNode(instanceHandle, ownerDocument) {
+      (0, _classCallCheck2.default)(this, ReadOnlyNode);
+      (0, _$$_REQUIRE(_dependencyMap[6], "./internals/NodeInternals").setOwnerDocument)(this, ownerDocument);
+      (0, _$$_REQUIRE(_dependencyMap[6], "./internals/NodeInternals").setInstanceHandle)(this, instanceHandle);
+    }
+    return (0, _createClass2.default)(ReadOnlyNode, [{
+      key: "childNodes",
+      get: function get() {
+        var childNodes = getChildNodes(this);
+        return (0, _$$_REQUIRE(_dependencyMap[7], "../oldstylecollections/NodeList").createNodeList)(childNodes);
+      }
+    }, {
+      key: "firstChild",
+      get: function get() {
+        var childNodes = getChildNodes(this);
+        if (childNodes.length === 0) {
+          return null;
+        }
+        return childNodes[0];
+      }
+    }, {
+      key: "isConnected",
+      get: function get() {
+        var shadowNode = (0, _$$_REQUIRE(_dependencyMap[6], "./internals/NodeInternals").getNativeNodeReference)(this);
+        if (shadowNode == null) {
+          return false;
+        }
+        return _NativeDOM.default.isConnected(shadowNode);
+      }
+    }, {
+      key: "lastChild",
+      get: function get() {
+        var childNodes = getChildNodes(this);
+        if (childNodes.length === 0) {
+          return null;
+        }
+        return childNodes[childNodes.length - 1];
+      }
+    }, {
+      key: "nextSibling",
+      get: function get() {
+        var _getNodeSiblingsAndPo = getNodeSiblingsAndPosition(this),
+          _getNodeSiblingsAndPo2 = (0, _slicedToArray2.default)(_getNodeSiblingsAndPo, 2),
+          siblings = _getNodeSiblingsAndPo2[0],
+          position = _getNodeSiblingsAndPo2[1];
+        if (position === siblings.length - 1) {
+          return null;
+        }
+        return siblings[position + 1];
+      }
+    }, {
+      key: "nodeName",
+      get: function get() {
+        throw new TypeError('`nodeName` is abstract and must be implemented in a subclass of `ReadOnlyNode`');
+      }
+    }, {
+      key: "nodeType",
+      get: function get() {
+        throw new TypeError('`nodeType` is abstract and must be implemented in a subclass of `ReadOnlyNode`');
+      }
+    }, {
+      key: "nodeValue",
+      get: function get() {
+        throw new TypeError('`nodeValue` is abstract and must be implemented in a subclass of `ReadOnlyNode`');
+      }
+    }, {
+      key: "ownerDocument",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[6], "./internals/NodeInternals").getOwnerDocument)(this);
+      }
+    }, {
+      key: "parentElement",
+      get: function get() {
+        var parentNode = this.parentNode;
+        if (parentNode instanceof getReadOnlyElementClass()) {
+          return parentNode;
+        }
+        return null;
+      }
+    }, {
+      key: "parentNode",
+      get: function get() {
+        var _getPublicInstanceFro;
+        var shadowNode = (0, _$$_REQUIRE(_dependencyMap[6], "./internals/NodeInternals").getNativeNodeReference)(this);
+        if (shadowNode == null) {
+          return null;
+        }
+        var parentInstanceHandle = _NativeDOM.default.getParentNode(shadowNode);
+        if (parentInstanceHandle == null) {
+          return null;
+        }
+        return (_getPublicInstanceFro = (0, _$$_REQUIRE(_dependencyMap[6], "./internals/NodeInternals").getPublicInstanceFromInstanceHandle)(parentInstanceHandle)) != null ? _getPublicInstanceFro : null;
+      }
+    }, {
+      key: "previousSibling",
+      get: function get() {
+        var _getNodeSiblingsAndPo3 = getNodeSiblingsAndPosition(this),
+          _getNodeSiblingsAndPo4 = (0, _slicedToArray2.default)(_getNodeSiblingsAndPo3, 2),
+          siblings = _getNodeSiblingsAndPo4[0],
+          position = _getNodeSiblingsAndPo4[1];
+        if (position === 0) {
+          return null;
+        }
+        return siblings[position - 1];
+      }
+    }, {
+      key: "textContent",
+      get: function get() {
+        throw new TypeError('`textContent` is abstract and must be implemented in a subclass of `ReadOnlyNode`');
+      }
+    }, {
+      key: "compareDocumentPosition",
+      value: function compareDocumentPosition(otherNode) {
+        if (otherNode === this) {
+          return 0;
+        }
+        var shadowNode = (0, _$$_REQUIRE(_dependencyMap[6], "./internals/NodeInternals").getNativeNodeReference)(this);
+        var otherShadowNode = (0, _$$_REQUIRE(_dependencyMap[6], "./internals/NodeInternals").getNativeNodeReference)(otherNode);
+        if (shadowNode == null || otherShadowNode == null) {
+          return ReadOnlyNode.DOCUMENT_POSITION_DISCONNECTED;
+        }
+        return _NativeDOM.default.compareDocumentPosition(shadowNode, otherShadowNode);
+      }
+    }, {
+      key: "contains",
+      value: function contains(otherNode) {
+        if (otherNode === this) {
+          return true;
+        }
+        var position = this.compareDocumentPosition(otherNode);
+        return (position & ReadOnlyNode.DOCUMENT_POSITION_CONTAINED_BY) !== 0;
+      }
+    }, {
+      key: "getRootNode",
+      value: function getRootNode() {
+        if (this.isConnected) {
+          var _this$ownerDocument;
+          return (_this$ownerDocument = this.ownerDocument) != null ? _this$ownerDocument : this;
+        }
+        return this;
+      }
+    }, {
+      key: "hasChildNodes",
+      value: function hasChildNodes() {
+        return getChildNodes(this).length > 0;
+      }
+    }]);
+  }();
+  ReadOnlyNode.ELEMENT_NODE = 1;
+  ReadOnlyNode.ATTRIBUTE_NODE = 2;
+  ReadOnlyNode.TEXT_NODE = 3;
+  ReadOnlyNode.CDATA_SECTION_NODE = 4;
+  ReadOnlyNode.ENTITY_REFERENCE_NODE = 5;
+  ReadOnlyNode.ENTITY_NODE = 6;
+  ReadOnlyNode.PROCESSING_INSTRUCTION_NODE = 7;
+  ReadOnlyNode.COMMENT_NODE = 8;
+  ReadOnlyNode.DOCUMENT_NODE = 9;
+  ReadOnlyNode.DOCUMENT_TYPE_NODE = 10;
+  ReadOnlyNode.DOCUMENT_FRAGMENT_NODE = 11;
+  ReadOnlyNode.NOTATION_NODE = 12;
+  ReadOnlyNode.DOCUMENT_POSITION_DISCONNECTED = 1;
+  ReadOnlyNode.DOCUMENT_POSITION_PRECEDING = 2;
+  ReadOnlyNode.DOCUMENT_POSITION_FOLLOWING = 4;
+  ReadOnlyNode.DOCUMENT_POSITION_CONTAINS = 8;
+  ReadOnlyNode.DOCUMENT_POSITION_CONTAINED_BY = 16;
+  ReadOnlyNode.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 32;
+  function getChildNodes(node) {
+    var shadowNode = (0, _$$_REQUIRE(_dependencyMap[6], "./internals/NodeInternals").getNativeNodeReference)(node);
+    if (shadowNode == null) {
+      return [];
+    }
+    var childNodeInstanceHandles = _NativeDOM.default.getChildNodes(shadowNode);
+    return childNodeInstanceHandles.map(function (instanceHandle) {
+      return (0, _$$_REQUIRE(_dependencyMap[6], "./internals/NodeInternals").getPublicInstanceFromInstanceHandle)(instanceHandle);
+    }).filter(Boolean);
+  }
+  function getNodeSiblingsAndPosition(node) {
+    var parent = node.parentNode;
+    if (parent == null) {
+      return [[node], 0];
+    }
+    var siblings = getChildNodes(parent);
+    var position = siblings.indexOf(node);
+    if (position === -1) {
+      throw new TypeError("Missing node in parent's child node list");
+    }
+    return [siblings, position];
+  }
+  var ReadOnlyElementClass;
+  function getReadOnlyElementClass() {
+    if (ReadOnlyElementClass == null) {
+      ReadOnlyElementClass = _$$_REQUIRE(_dependencyMap[8], "./ReadOnlyElement").default;
+    }
+    return ReadOnlyElementClass;
+  }
+},121,[1,34,11,12,52,122,123,120,126],"../../node_modules/react-native/src/private/webapis/dom/nodes/ReadOnlyNode.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  var _nullthrows = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "nullthrows"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var RawNativeDOM = TurboModuleRegistry.get('NativeDOMCxx');
+  var NativeDOM = {
+    compareDocumentPosition: function compareDocumentPosition(nativeNodeReference, otherNativeNodeReference) {
+      return (0, _nullthrows.default)(RawNativeDOM).compareDocumentPosition(nativeNodeReference, otherNativeNodeReference);
+    },
+    getChildNodes: function getChildNodes(nativeNodeReference) {
+      return (0, _nullthrows.default)(RawNativeDOM).getChildNodes(nativeNodeReference);
+    },
+    getParentNode: function getParentNode(nativeNodeReference) {
+      return (0, _nullthrows.default)(RawNativeDOM).getParentNode(nativeNodeReference);
+    },
+    isConnected: function isConnected(nativeNodeReference) {
+      return (0, _nullthrows.default)(RawNativeDOM).isConnected(nativeNodeReference);
+    },
+    getBorderWidth: function getBorderWidth(nativeNodeReference) {
+      return (0, _nullthrows.default)(RawNativeDOM).getBorderWidth(nativeNodeReference);
+    },
+    getBoundingClientRect: function getBoundingClientRect(nativeNodeReference, includeTransform) {
+      return (0, _nullthrows.default)(RawNativeDOM).getBoundingClientRect(nativeNodeReference, includeTransform);
+    },
+    getInnerSize: function getInnerSize(nativeNodeReference) {
+      return (0, _nullthrows.default)(RawNativeDOM).getInnerSize(nativeNodeReference);
+    },
+    getScrollPosition: function getScrollPosition(nativeNodeReference) {
+      return (0, _nullthrows.default)(RawNativeDOM).getScrollPosition(nativeNodeReference);
+    },
+    getScrollSize: function getScrollSize(nativeNodeReference) {
+      return (0, _nullthrows.default)(RawNativeDOM).getScrollSize(nativeNodeReference);
+    },
+    getTagName: function getTagName(nativeNodeReference) {
+      return (0, _nullthrows.default)(RawNativeDOM).getTagName(nativeNodeReference);
+    },
+    getTextContent: function getTextContent(nativeNodeReference) {
+      return (0, _nullthrows.default)(RawNativeDOM).getTextContent(nativeNodeReference);
+    },
+    hasPointerCapture: function hasPointerCapture(nativeNodeReference, pointerId) {
+      return (0, _nullthrows.default)(RawNativeDOM).hasPointerCapture(nativeNodeReference, pointerId);
+    },
+    releasePointerCapture: function releasePointerCapture(nativeNodeReference, pointerId) {
+      return (0, _nullthrows.default)(RawNativeDOM).releasePointerCapture(nativeNodeReference, pointerId);
+    },
+    setPointerCapture: function setPointerCapture(nativeNodeReference, pointerId) {
+      return (0, _nullthrows.default)(RawNativeDOM).setPointerCapture(nativeNodeReference, pointerId);
+    },
+    getOffset: function getOffset(nativeNodeReference) {
+      return (0, _nullthrows.default)(RawNativeDOM).getOffset(nativeNodeReference);
+    },
+    linkRootNode: function linkRootNode(rootTag, instanceHandle) {
+      return (0, _nullthrows.default)(RawNativeDOM == null ? void 0 : RawNativeDOM.linkRootNode)(rootTag, instanceHandle);
+    },
+    measure: function measure(nativeNodeReference, callback) {
+      return (0, _nullthrows.default)(RawNativeDOM).measure(nativeNodeReference, callback);
+    },
+    measureInWindow: function measureInWindow(nativeNodeReference, callback) {
+      return (0, _nullthrows.default)(RawNativeDOM).measureInWindow(nativeNodeReference, callback);
+    },
+    measureLayout: function measureLayout(nativeNodeReference, relativeNode, onFail, onSuccess) {
+      return (0, _nullthrows.default)(RawNativeDOM).measureLayout(nativeNodeReference, relativeNode, onFail, onSuccess);
+    }
+  };
+  var _default = exports.default = NativeDOM;
+},122,[1,31,80],"../../node_modules/react-native/src/private/webapis/dom/nodes/specs/NativeDOM.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.getInstanceHandle = getInstanceHandle;
+  exports.getNativeElementReference = getNativeElementReference;
+  exports.getNativeNodeReference = getNativeNodeReference;
+  exports.getNativeTextReference = getNativeTextReference;
+  exports.getOwnerDocument = getOwnerDocument;
+  exports.getPublicInstanceFromInstanceHandle = getPublicInstanceFromInstanceHandle;
+  exports.setInstanceHandle = setInstanceHandle;
+  exports.setOwnerDocument = setOwnerDocument;
+  var RendererProxy;
+  function getRendererProxy() {
+    if (RendererProxy == null) {
+      RendererProxy = _$$_REQUIRE(_dependencyMap[0], "../../../../../../Libraries/ReactNative/RendererProxy");
+    }
+    return RendererProxy;
+  }
+  var INSTANCE_HANDLE_KEY = Symbol('internalInstanceHandle');
+  var OWNER_DOCUMENT_KEY = Symbol('ownerDocument');
+  function getInstanceHandle(node) {
+    return node[INSTANCE_HANDLE_KEY];
+  }
+  function setInstanceHandle(node, instanceHandle) {
+    node[INSTANCE_HANDLE_KEY] = instanceHandle;
+  }
+  function getOwnerDocument(node) {
+    var _node$OWNER_DOCUMENT_;
+    return (_node$OWNER_DOCUMENT_ = node[OWNER_DOCUMENT_KEY]) != null ? _node$OWNER_DOCUMENT_ : null;
+  }
+  function setOwnerDocument(node, ownerDocument) {
+    node[OWNER_DOCUMENT_KEY] = ownerDocument;
+  }
+  function getPublicInstanceFromInstanceHandle(instanceHandle) {
+    if ((0, _$$_REQUIRE(_dependencyMap[1], "./ReactNativeDocumentInstanceHandle").isReactNativeDocumentInstanceHandle)(instanceHandle)) {
+      return (0, _$$_REQUIRE(_dependencyMap[1], "./ReactNativeDocumentInstanceHandle").getPublicInstanceFromReactNativeDocumentInstanceHandle)(instanceHandle);
+    }
+    if ((0, _$$_REQUIRE(_dependencyMap[2], "./ReactNativeDocumentElementInstanceHandle").isReactNativeDocumentElementInstanceHandle)(instanceHandle)) {
+      return (0, _$$_REQUIRE(_dependencyMap[2], "./ReactNativeDocumentElementInstanceHandle").getPublicInstanceFromReactNativeDocumentElementInstanceHandle)(instanceHandle);
+    }
+    var mixedPublicInstance = getRendererProxy().getPublicInstanceFromInternalInstanceHandle(instanceHandle);
+    return mixedPublicInstance;
+  }
+  function getNativeNodeReference(node) {
+    var instanceHandle = getInstanceHandle(node);
+    if ((0, _$$_REQUIRE(_dependencyMap[1], "./ReactNativeDocumentInstanceHandle").isReactNativeDocumentInstanceHandle)(instanceHandle)) {
+      return (0, _$$_REQUIRE(_dependencyMap[1], "./ReactNativeDocumentInstanceHandle").getNativeNodeReferenceFromReactNativeDocumentInstanceHandle)(instanceHandle);
+    }
+    if ((0, _$$_REQUIRE(_dependencyMap[2], "./ReactNativeDocumentElementInstanceHandle").isReactNativeDocumentElementInstanceHandle)(instanceHandle)) {
+      return (0, _$$_REQUIRE(_dependencyMap[2], "./ReactNativeDocumentElementInstanceHandle").getNativeElementReferenceFromReactNativeDocumentElementInstanceHandle)(instanceHandle);
+    }
+    return getRendererProxy().getNodeFromInternalInstanceHandle(instanceHandle);
+  }
+  function getNativeElementReference(node) {
+    var instanceHandle = getInstanceHandle(node);
+    if ((0, _$$_REQUIRE(_dependencyMap[2], "./ReactNativeDocumentElementInstanceHandle").isReactNativeDocumentElementInstanceHandle)(instanceHandle)) {
+      return (0, _$$_REQUIRE(_dependencyMap[2], "./ReactNativeDocumentElementInstanceHandle").getNativeElementReferenceFromReactNativeDocumentElementInstanceHandle)(instanceHandle);
+    }
+    return getRendererProxy().getNodeFromInternalInstanceHandle(instanceHandle);
+  }
+  function getNativeTextReference(node) {
+    var instanceHandle = getInstanceHandle(node);
+    return getRendererProxy().getNodeFromInternalInstanceHandle(instanceHandle);
+  }
+},123,[106,124,125],"../../node_modules/react-native/src/private/webapis/dom/nodes/internals/NodeInternals.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.createReactNativeDocumentInstanceHandle = createReactNativeDocumentInstanceHandle;
+  exports.getNativeNodeReferenceFromReactNativeDocumentInstanceHandle = getNativeNodeReferenceFromReactNativeDocumentInstanceHandle;
+  exports.getPublicInstanceFromReactNativeDocumentInstanceHandle = getPublicInstanceFromReactNativeDocumentInstanceHandle;
+  exports.isReactNativeDocumentInstanceHandle = isReactNativeDocumentInstanceHandle;
+  var RendererProxy = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../../../Libraries/ReactNative/RendererProxy"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function createReactNativeDocumentInstanceHandle(rootTag) {
+    return rootTag;
+  }
+  function getNativeNodeReferenceFromReactNativeDocumentInstanceHandle(instanceHandle) {
+    return instanceHandle;
+  }
+  function getPublicInstanceFromReactNativeDocumentInstanceHandle(instanceHandle) {
+    return RendererProxy.getPublicInstanceFromRootTag(Number(instanceHandle));
+  }
+  function isReactNativeDocumentInstanceHandle(instanceHandle) {
+    return typeof instanceHandle === 'number' && instanceHandle % 10 === 1;
+  }
+},124,[106],"../../node_modules/react-native/src/private/webapis/dom/nodes/internals/ReactNativeDocumentInstanceHandle.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.createReactNativeDocumentElementInstanceHandle = createReactNativeDocumentElementInstanceHandle;
+  exports.getNativeElementReferenceFromReactNativeDocumentElementInstanceHandle = getNativeElementReferenceFromReactNativeDocumentElementInstanceHandle;
+  exports.getPublicInstanceFromReactNativeDocumentElementInstanceHandle = getPublicInstanceFromReactNativeDocumentElementInstanceHandle;
+  exports.isReactNativeDocumentElementInstanceHandle = isReactNativeDocumentElementInstanceHandle;
+  exports.setNativeElementReferenceForReactNativeDocumentElementInstanceHandle = setNativeElementReferenceForReactNativeDocumentElementInstanceHandle;
+  exports.setPublicInstanceForReactNativeDocumentElementInstanceHandle = setPublicInstanceForReactNativeDocumentElementInstanceHandle;
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var ReactNativeDocumentElementInstanceHandleImpl = /*#__PURE__*/(0, _createClass2.default)(function ReactNativeDocumentElementInstanceHandleImpl() {
+    (0, _classCallCheck2.default)(this, ReactNativeDocumentElementInstanceHandleImpl);
+  });
+  function createReactNativeDocumentElementInstanceHandle() {
+    return new ReactNativeDocumentElementInstanceHandleImpl();
+  }
+  function getNativeElementReferenceFromReactNativeDocumentElementInstanceHandle(instanceHandle) {
+    return instanceHandle.nativeElementReference;
+  }
+  function setNativeElementReferenceForReactNativeDocumentElementInstanceHandle(instanceHandle, nativeElementReference) {
+    instanceHandle.nativeElementReference = nativeElementReference;
+  }
+  function getPublicInstanceFromReactNativeDocumentElementInstanceHandle(instanceHandle) {
+    return instanceHandle.publicInstance;
+  }
+  function setPublicInstanceForReactNativeDocumentElementInstanceHandle(instanceHandle, publicInstance) {
+    instanceHandle.publicInstance = publicInstance;
+  }
+  function isReactNativeDocumentElementInstanceHandle(instanceHandle) {
+    return instanceHandle instanceof ReactNativeDocumentElementInstanceHandleImpl;
+  }
+},125,[1,12,11],"../../node_modules/react-native/src/private/webapis/dom/nodes/internals/ReactNativeDocumentElementInstanceHandle.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  exports.getBoundingClientRect = _getBoundingClientRect;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var _DOMRect = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../../geometry/DOMRect"));
+  var _ReadOnlyNode2 = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "./ReadOnlyNode"));
+  var _NativeDOM = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./specs/NativeDOM"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var ReadOnlyElement = exports.default = /*#__PURE__*/function (_ReadOnlyNode) {
+    function ReadOnlyElement() {
+      (0, _classCallCheck2.default)(this, ReadOnlyElement);
+      return _callSuper(this, ReadOnlyElement, arguments);
+    }
+    (0, _inherits2.default)(ReadOnlyElement, _ReadOnlyNode);
+    return (0, _createClass2.default)(ReadOnlyElement, [{
+      key: "childElementCount",
+      get: function get() {
+        return getChildElements(this).length;
+      }
+    }, {
+      key: "children",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[9], "../oldstylecollections/HTMLCollection").createHTMLCollection)(getChildElements(this));
+      }
+    }, {
+      key: "clientHeight",
+      get: function get() {
+        var node = (0, _$$_REQUIRE(_dependencyMap[10], "./internals/NodeInternals").getNativeElementReference)(this);
+        if (node != null) {
+          var innerSize = _NativeDOM.default.getInnerSize(node);
+          return innerSize[1];
+        }
+        return 0;
+      }
+    }, {
+      key: "clientLeft",
+      get: function get() {
+        var node = (0, _$$_REQUIRE(_dependencyMap[10], "./internals/NodeInternals").getNativeElementReference)(this);
+        if (node != null) {
+          var borderSize = _NativeDOM.default.getBorderWidth(node);
+          return borderSize[3];
+        }
+        return 0;
+      }
+    }, {
+      key: "clientTop",
+      get: function get() {
+        var node = (0, _$$_REQUIRE(_dependencyMap[10], "./internals/NodeInternals").getNativeElementReference)(this);
+        if (node != null) {
+          var borderSize = _NativeDOM.default.getBorderWidth(node);
+          return borderSize[0];
+        }
+        return 0;
+      }
+    }, {
+      key: "clientWidth",
+      get: function get() {
+        var node = (0, _$$_REQUIRE(_dependencyMap[10], "./internals/NodeInternals").getNativeElementReference)(this);
+        if (node != null) {
+          var innerSize = _NativeDOM.default.getInnerSize(node);
+          return innerSize[0];
+        }
+        return 0;
+      }
+    }, {
+      key: "firstElementChild",
+      get: function get() {
+        var childElements = getChildElements(this);
+        if (childElements.length === 0) {
+          return null;
+        }
+        return childElements[0];
+      }
+    }, {
+      key: "id",
+      get: function get() {
+        var _instanceHandle$state, _ref, _props$id;
+        var instanceHandle = (0, _$$_REQUIRE(_dependencyMap[10], "./internals/NodeInternals").getInstanceHandle)(this);
+        var props = instanceHandle == null || (_instanceHandle$state = instanceHandle.stateNode) == null || (_instanceHandle$state = _instanceHandle$state.canonical) == null ? void 0 : _instanceHandle$state.currentProps;
+        return (_ref = (_props$id = props == null ? void 0 : props.id) != null ? _props$id : props == null ? void 0 : props.nativeID) != null ? _ref : '';
+      }
+    }, {
+      key: "lastElementChild",
+      get: function get() {
+        var childElements = getChildElements(this);
+        if (childElements.length === 0) {
+          return null;
+        }
+        return childElements[childElements.length - 1];
+      }
+    }, {
+      key: "nextElementSibling",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[11], "./internals/Traversal").getElementSibling)(this, 'next');
+      }
+    }, {
+      key: "nodeName",
+      get: function get() {
+        return this.tagName;
+      }
+    }, {
+      key: "nodeType",
+      get: function get() {
+        return _ReadOnlyNode2.default.ELEMENT_NODE;
+      }
+    }, {
+      key: "nodeValue",
+      get: function get() {
+        return null;
+      },
+      set: function set(value) {}
+    }, {
+      key: "previousElementSibling",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[11], "./internals/Traversal").getElementSibling)(this, 'previous');
+      }
+    }, {
+      key: "scrollHeight",
+      get: function get() {
+        var node = (0, _$$_REQUIRE(_dependencyMap[10], "./internals/NodeInternals").getNativeElementReference)(this);
+        if (node != null) {
+          var scrollSize = _NativeDOM.default.getScrollSize(node);
+          return scrollSize[1];
+        }
+        return 0;
+      }
+    }, {
+      key: "scrollLeft",
+      get: function get() {
+        var node = (0, _$$_REQUIRE(_dependencyMap[10], "./internals/NodeInternals").getNativeElementReference)(this);
+        if (node != null) {
+          var scrollPosition = _NativeDOM.default.getScrollPosition(node);
+          return scrollPosition[0];
+        }
+        return 0;
+      }
+    }, {
+      key: "scrollTop",
+      get: function get() {
+        var node = (0, _$$_REQUIRE(_dependencyMap[10], "./internals/NodeInternals").getNativeElementReference)(this);
+        if (node != null) {
+          var scrollPosition = _NativeDOM.default.getScrollPosition(node);
+          return scrollPosition[1];
+        }
+        return 0;
+      }
+    }, {
+      key: "scrollWidth",
+      get: function get() {
+        var node = (0, _$$_REQUIRE(_dependencyMap[10], "./internals/NodeInternals").getNativeElementReference)(this);
+        if (node != null) {
+          var scrollSize = _NativeDOM.default.getScrollSize(node);
+          return scrollSize[0];
+        }
+        return 0;
+      }
+    }, {
+      key: "tagName",
+      get: function get() {
+        var node = (0, _$$_REQUIRE(_dependencyMap[10], "./internals/NodeInternals").getNativeElementReference)(this);
+        if (node != null) {
+          return _NativeDOM.default.getTagName(node);
+        }
+        return '';
+      }
+    }, {
+      key: "textContent",
+      get: function get() {
+        var node = (0, _$$_REQUIRE(_dependencyMap[10], "./internals/NodeInternals").getNativeElementReference)(this);
+        if (node != null) {
+          return _NativeDOM.default.getTextContent(node);
+        }
+        return '';
+      }
+    }, {
+      key: "getBoundingClientRect",
+      value: function getBoundingClientRect() {
+        return _getBoundingClientRect(this, {
+          includeTransform: true
+        });
+      }
+    }, {
+      key: "hasPointerCapture",
+      value: function hasPointerCapture(pointerId) {
+        var node = (0, _$$_REQUIRE(_dependencyMap[10], "./internals/NodeInternals").getNativeElementReference)(this);
+        if (node != null) {
+          return _NativeDOM.default.hasPointerCapture(node, pointerId);
+        }
+        return false;
+      }
+    }, {
+      key: "setPointerCapture",
+      value: function setPointerCapture(pointerId) {
+        var node = (0, _$$_REQUIRE(_dependencyMap[10], "./internals/NodeInternals").getNativeElementReference)(this);
+        if (node != null) {
+          _NativeDOM.default.setPointerCapture(node, pointerId);
+        }
+      }
+    }, {
+      key: "releasePointerCapture",
+      value: function releasePointerCapture(pointerId) {
+        var node = (0, _$$_REQUIRE(_dependencyMap[10], "./internals/NodeInternals").getNativeElementReference)(this);
+        if (node != null) {
+          _NativeDOM.default.releasePointerCapture(node, pointerId);
+        }
+      }
+    }]);
+  }(_ReadOnlyNode2.default);
+  function getChildElements(node) {
+    return (0, _ReadOnlyNode2.getChildNodes)(node).filter(function (childNode) {
+      return childNode instanceof ReadOnlyElement;
+    });
+  }
+  function _getBoundingClientRect(element, _ref2) {
+    var includeTransform = _ref2.includeTransform;
+    var node = (0, _$$_REQUIRE(_dependencyMap[10], "./internals/NodeInternals").getNativeElementReference)(element);
+    if (node != null) {
+      var rect = _NativeDOM.default.getBoundingClientRect(node, includeTransform);
+      return new _DOMRect.default(rect[0], rect[1], rect[2], rect[3]);
+    }
+    return new _DOMRect.default(0, 0, 0, 0);
+  }
+},126,[1,11,12,18,20,23,115,121,122,119,123,127],"../../node_modules/react-native/src/private/webapis/dom/nodes/ReadOnlyElement.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.getElementSibling = getElementSibling;
+  var ReadOnlyElementClass;
+  function getElementSibling(node, direction) {
+    var _childNodes$position;
+    var parent = node.parentNode;
+    if (parent == null) {
+      return null;
+    }
+    var childNodes = (0, _$$_REQUIRE(_dependencyMap[0], "../ReadOnlyNode").getChildNodes)(parent);
+    var startPosition = childNodes.indexOf(node);
+    if (startPosition === -1) {
+      return null;
+    }
+    var increment = direction === 'next' ? 1 : -1;
+    var position = startPosition + increment;
+    if (ReadOnlyElementClass == null) {
+      ReadOnlyElementClass = _$$_REQUIRE(_dependencyMap[1], "../ReadOnlyElement").default;
+    }
+    while (childNodes[position] != null && !(childNodes[position] instanceof ReadOnlyElementClass)) {
+      position = position + increment;
+    }
+    return (_childNodes$position = childNodes[position]) != null ? _childNodes$position : null;
+  }
+},127,[121,126],"../../node_modules/react-native/src/private/webapis/dom/nodes/internals/Traversal.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.createReactNativeDocument = createReactNativeDocument;
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var _ReactNativeElement = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./ReactNativeElement"));
+  var _ReadOnlyNode2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./ReadOnlyNode"));
+  var _NativeDOM = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./specs/NativeDOM"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var ReactNativeDocument = exports.default = /*#__PURE__*/function (_ReadOnlyNode) {
+    function ReactNativeDocument(rootTag, instanceHandle) {
+      var _this;
+      (0, _classCallCheck2.default)(this, ReactNativeDocument);
+      _this = _callSuper(this, ReactNativeDocument, [instanceHandle, null]);
+      _this._documentElement = createDocumentElement(rootTag, _this);
+      return _this;
+    }
+    (0, _inherits2.default)(ReactNativeDocument, _ReadOnlyNode);
+    return (0, _createClass2.default)(ReactNativeDocument, [{
+      key: "childElementCount",
+      get: function get() {
+        return 1;
+      }
+    }, {
+      key: "children",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[9], "../oldstylecollections/HTMLCollection").createHTMLCollection)([this.documentElement]);
+      }
+    }, {
+      key: "documentElement",
+      get: function get() {
+        return this._documentElement;
+      }
+    }, {
+      key: "firstElementChild",
+      get: function get() {
+        return this.documentElement;
+      }
+    }, {
+      key: "lastElementChild",
+      get: function get() {
+        return this.documentElement;
+      }
+    }, {
+      key: "nodeName",
+      get: function get() {
+        return '#document';
+      }
+    }, {
+      key: "nodeType",
+      get: function get() {
+        return _ReadOnlyNode2.default.DOCUMENT_NODE;
+      }
+    }, {
+      key: "nodeValue",
+      get: function get() {
+        return null;
+      }
+    }, {
+      key: "textContent",
+      get: function get() {
+        return null;
+      }
+    }]);
+  }(_ReadOnlyNode2.default);
+  function createDocumentElement(rootTag, ownerDocument) {
+    var instanceHandle = (0, _$$_REQUIRE(_dependencyMap[10], "./internals/ReactNativeDocumentElementInstanceHandle").createReactNativeDocumentElementInstanceHandle)();
+    var rootTagIsNumber = rootTag;
+    var viewConfig = null;
+    var documentElement = new _ReactNativeElement.default(rootTagIsNumber, viewConfig, instanceHandle, ownerDocument);
+    var rootShadowNode = _NativeDOM.default.linkRootNode(rootTag, instanceHandle);
+    (0, _$$_REQUIRE(_dependencyMap[10], "./internals/ReactNativeDocumentElementInstanceHandle").setNativeElementReferenceForReactNativeDocumentElementInstanceHandle)(instanceHandle, rootShadowNode);
+    (0, _$$_REQUIRE(_dependencyMap[10], "./internals/ReactNativeDocumentElementInstanceHandle").setPublicInstanceForReactNativeDocumentElementInstanceHandle)(instanceHandle, documentElement);
+    return documentElement;
+  }
+  function createReactNativeDocument(rootTag) {
+    var instanceHandle = (0, _$$_REQUIRE(_dependencyMap[11], "./internals/ReactNativeDocumentInstanceHandle").createReactNativeDocumentInstanceHandle)(rootTag);
+    var document = new ReactNativeDocument(rootTag, instanceHandle);
+    return document;
+  }
+},128,[1,11,12,18,20,23,129,121,122,119,125,124],"../../node_modules/react-native/src/private/webapis/dom/nodes/ReactNativeDocument.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var _TextInputState = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../../../../../Libraries/Components/TextInput/TextInputState"));
+  var _warnForStyleProps = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../../../../../Libraries/ReactNative/ReactFabricPublicInstance/warnForStyleProps"));
+  var _ReadOnlyElement2 = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[8], "./ReadOnlyElement"));
+  var _NativeDOM = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./specs/NativeDOM"));
+  var _nullthrows = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "nullthrows"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var noop = function noop() {};
+  var ReactNativeElement = /*#__PURE__*/function (_ReadOnlyElement) {
+    function ReactNativeElement(tag, viewConfig, instanceHandle, ownerDocument) {
+      var _this;
+      (0, _classCallCheck2.default)(this, ReactNativeElement);
+      _this = _callSuper(this, ReactNativeElement, [instanceHandle, ownerDocument]);
+      _this.__nativeTag = tag;
+      _this.__internalInstanceHandle = instanceHandle;
+      _this.__viewConfig = viewConfig;
+      return _this;
+    }
+    (0, _inherits2.default)(ReactNativeElement, _ReadOnlyElement);
+    return (0, _createClass2.default)(ReactNativeElement, [{
+      key: "offsetHeight",
+      get: function get() {
+        return Math.round((0, _ReadOnlyElement2.getBoundingClientRect)(this, {
+          includeTransform: false
+        }).height);
+      }
+    }, {
+      key: "offsetLeft",
+      get: function get() {
+        var node = (0, _$$_REQUIRE(_dependencyMap[11], "./internals/NodeInternals").getNativeElementReference)(this);
+        if (node != null) {
+          var offset = _NativeDOM.default.getOffset(node);
+          return Math.round(offset[2]);
+        }
+        return 0;
+      }
+    }, {
+      key: "offsetParent",
+      get: function get() {
+        var node = (0, _$$_REQUIRE(_dependencyMap[11], "./internals/NodeInternals").getNativeElementReference)(this);
+        if (node != null) {
+          var offset = _NativeDOM.default.getOffset(node);
+          if (offset[0] != null) {
+            var offsetParentInstanceHandle = offset[0];
+            var offsetParent = (0, _$$_REQUIRE(_dependencyMap[11], "./internals/NodeInternals").getPublicInstanceFromInstanceHandle)(offsetParentInstanceHandle);
+            var offsetParentElement = offsetParent;
+            return offsetParentElement;
+          }
+        }
+        return null;
+      }
+    }, {
+      key: "offsetTop",
+      get: function get() {
+        var node = (0, _$$_REQUIRE(_dependencyMap[11], "./internals/NodeInternals").getNativeElementReference)(this);
+        if (node != null) {
+          var offset = _NativeDOM.default.getOffset(node);
+          return Math.round(offset[1]);
+        }
+        return 0;
+      }
+    }, {
+      key: "offsetWidth",
+      get: function get() {
+        return Math.round((0, _ReadOnlyElement2.getBoundingClientRect)(this, {
+          includeTransform: false
+        }).width);
+      }
+    }, {
+      key: "blur",
+      value: function blur() {
+        _TextInputState.default.blurTextInput(this);
+      }
+    }, {
+      key: "focus",
+      value: function focus() {
+        _TextInputState.default.focusTextInput(this);
+      }
+    }, {
+      key: "measure",
+      value: function measure(callback) {
+        var node = (0, _$$_REQUIRE(_dependencyMap[11], "./internals/NodeInternals").getNativeElementReference)(this);
+        if (node != null) {
+          var shadowNode = node;
+          (0, _nullthrows.default)((0, _$$_REQUIRE(_dependencyMap[12], "../../../../../Libraries/ReactNative/FabricUIManager").getFabricUIManager)()).measure(shadowNode, callback);
+        }
+      }
+    }, {
+      key: "measureInWindow",
+      value: function measureInWindow(callback) {
+        var node = (0, _$$_REQUIRE(_dependencyMap[11], "./internals/NodeInternals").getNativeElementReference)(this);
+        if (node != null) {
+          var shadowNode = node;
+          (0, _nullthrows.default)((0, _$$_REQUIRE(_dependencyMap[12], "../../../../../Libraries/ReactNative/FabricUIManager").getFabricUIManager)()).measureInWindow(shadowNode, callback);
+        }
+      }
+    }, {
+      key: "measureLayout",
+      value: function measureLayout(relativeToNativeNode, onSuccess, onFail) {
+        if (!(relativeToNativeNode instanceof ReactNativeElement)) {
+          if (__DEV__) {
+            console.error('Warning: ref.measureLayout must be called with a ref to a native component.');
+          }
+          return;
+        }
+        var toStateNode = (0, _$$_REQUIRE(_dependencyMap[11], "./internals/NodeInternals").getNativeElementReference)(this);
+        var fromStateNode = (0, _$$_REQUIRE(_dependencyMap[11], "./internals/NodeInternals").getNativeElementReference)(relativeToNativeNode);
+        if (toStateNode != null && fromStateNode != null) {
+          var toStateShadowNode = toStateNode;
+          var fromStateShadowNode = fromStateNode;
+          (0, _nullthrows.default)((0, _$$_REQUIRE(_dependencyMap[12], "../../../../../Libraries/ReactNative/FabricUIManager").getFabricUIManager)()).measureLayout(toStateShadowNode, fromStateShadowNode, onFail != null ? onFail : noop, onSuccess != null ? onSuccess : noop);
+        }
+      }
+    }, {
+      key: "setNativeProps",
+      value: function setNativeProps(nativeProps) {
+        if (__DEV__) {
+          (0, _warnForStyleProps.default)(nativeProps, this.__viewConfig.validAttributes);
+        }
+        var updatePayload = (0, _$$_REQUIRE(_dependencyMap[13], "../../../../../Libraries/ReactNative/ReactFabricPublicInstance/ReactNativeAttributePayload").create)(nativeProps, this.__viewConfig.validAttributes);
+        var node = (0, _$$_REQUIRE(_dependencyMap[11], "./internals/NodeInternals").getNativeElementReference)(this);
+        if (node != null && updatePayload != null) {
+          var shadowNode = node;
+          (0, _nullthrows.default)((0, _$$_REQUIRE(_dependencyMap[12], "../../../../../Libraries/ReactNative/FabricUIManager").getFabricUIManager)()).setNativeProps(shadowNode, updatePayload);
+        }
+      }
+    }]);
+  }(_ReadOnlyElement2.default);
+  function replaceConstructorWithoutSuper(ReactNativeElementClass) {
+    function ReactNativeElement(tag, viewConfig, internalInstanceHandle, ownerDocument) {
+      (0, _$$_REQUIRE(_dependencyMap[11], "./internals/NodeInternals").setOwnerDocument)(this, ownerDocument);
+      (0, _$$_REQUIRE(_dependencyMap[11], "./internals/NodeInternals").setInstanceHandle)(this, internalInstanceHandle);
+      this.__nativeTag = tag;
+      this.__internalInstanceHandle = internalInstanceHandle;
+      this.__viewConfig = viewConfig;
+    }
+    ReactNativeElement.prototype = ReactNativeElementClass.prototype;
+    return ReactNativeElement;
+  }
+  var _default = exports.default = replaceConstructorWithoutSuper(ReactNativeElement);
+},129,[1,11,12,18,20,23,130,134,126,122,80,123,82,135],"../../node_modules/react-native/src/private/webapis/dom/nodes/ReactNativeElement.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var currentlyFocusedInputRef = null;
+  var inputs = new Set();
+  function currentlyFocusedInput() {
+    return currentlyFocusedInputRef;
+  }
+  function currentlyFocusedField() {
+    if (__DEV__) {
+      console.error('currentlyFocusedField is deprecated and will be removed in a future release. Use currentlyFocusedInput');
+    }
+    return _$$_REQUIRE(_dependencyMap[0], "../../ReactNative/RendererProxy").findNodeHandle(currentlyFocusedInputRef);
+  }
+  function focusInput(textField) {
+    if (currentlyFocusedInputRef !== textField && textField != null) {
+      currentlyFocusedInputRef = textField;
+    }
+  }
+  function blurInput(textField) {
+    if (currentlyFocusedInputRef === textField && textField != null) {
+      currentlyFocusedInputRef = null;
+    }
+  }
+  function focusField(textFieldID) {
+    if (__DEV__) {
+      console.error('focusField no longer works. Use focusInput');
+    }
+    return;
+  }
+  function blurField(textFieldID) {
+    if (__DEV__) {
+      console.error('blurField no longer works. Use blurInput');
+    }
+    return;
+  }
+  function focusTextInput(textField) {
+    if (typeof textField === 'number') {
+      if (__DEV__) {
+        console.error('focusTextInput must be called with a host component. Passing a react tag is deprecated.');
+      }
+      return;
+    }
+    if (textField != null) {
+      var _textField$currentPro;
+      var fieldCanBeFocused = currentlyFocusedInputRef !== textField && ((_textField$currentPro = textField.currentProps) == null ? void 0 : _textField$currentPro.editable) !== false;
+      if (!fieldCanBeFocused) {
+        return;
+      }
+      focusInput(textField);
+      if ("ios" === 'ios') {
+        _$$_REQUIRE(_dependencyMap[1], "../../Components/TextInput/RCTSingelineTextInputNativeComponent").Commands.focus(textField);
+      } else if ("ios" === 'android') {
+        _$$_REQUIRE(_dependencyMap[2], "../../Components/TextInput/AndroidTextInputNativeComponent").Commands.focus(textField);
+      }
+    }
+  }
+  function blurTextInput(textField) {
+    if (typeof textField === 'number') {
+      if (__DEV__) {
+        console.error('blurTextInput must be called with a host component. Passing a react tag is deprecated.');
+      }
+      return;
+    }
+    if (currentlyFocusedInputRef === textField && textField != null) {
+      blurInput(textField);
+      if ("ios" === 'ios') {
+        _$$_REQUIRE(_dependencyMap[1], "../../Components/TextInput/RCTSingelineTextInputNativeComponent").Commands.blur(textField);
+      } else if ("ios" === 'android') {
+        _$$_REQUIRE(_dependencyMap[2], "../../Components/TextInput/AndroidTextInputNativeComponent").Commands.blur(textField);
+      }
+    }
+  }
+  function registerInput(textField) {
+    if (typeof textField === 'number') {
+      if (__DEV__) {
+        console.error('registerInput must be called with a host component. Passing a react tag is deprecated.');
+      }
+      return;
+    }
+    inputs.add(textField);
+  }
+  function unregisterInput(textField) {
+    if (typeof textField === 'number') {
+      if (__DEV__) {
+        console.error('unregisterInput must be called with a host component. Passing a react tag is deprecated.');
+      }
+      return;
+    }
+    inputs.delete(textField);
+  }
+  function isTextInput(textField) {
+    if (typeof textField === 'number') {
+      if (__DEV__) {
+        console.error('isTextInput must be called with a host component. Passing a react tag is deprecated.');
+      }
+      return false;
+    }
+    return inputs.has(textField);
+  }
+  var TextInputState = {
+    currentlyFocusedInput: currentlyFocusedInput,
+    focusInput: focusInput,
+    blurInput: blurInput,
+    currentlyFocusedField: currentlyFocusedField,
+    focusField: focusField,
+    blurField: blurField,
+    focusTextInput: focusTextInput,
+    blurTextInput: blurTextInput,
+    registerInput: registerInput,
+    unregisterInput: unregisterInput,
+    isTextInput: isTextInput
+  };
+  var _default = exports.default = TextInputState;
+},130,[106,131,133],"../../node_modules/react-native/Libraries/Components/TextInput/TextInputState.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = exports.__INTERNAL_VIEW_CONFIG = exports.Commands = void 0;
+  var NativeComponentRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../NativeComponent/NativeComponentRegistry"));
+  var _codegenNativeCommands = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../Utilities/codegenNativeCommands"));
+  var _RCTTextInputViewConfig = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./RCTTextInputViewConfig"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var Commands = exports.Commands = (0, _codegenNativeCommands.default)({
+    supportedCommands: ['focus', 'blur', 'setTextAndSelection']
+  });
+  var __INTERNAL_VIEW_CONFIG = exports.__INTERNAL_VIEW_CONFIG = Object.assign({
+    uiViewClassName: 'RCTSinglelineTextInputView'
+  }, _RCTTextInputViewConfig.default);
+  var SinglelineTextInputNativeComponent = NativeComponentRegistry.get('RCTSinglelineTextInputView', function () {
+    return __INTERNAL_VIEW_CONFIG;
+  });
+  var _default = exports.default = SinglelineTextInputNativeComponent;
+},131,[1,77,105,132],"../../node_modules/react-native/Libraries/Components/TextInput/RCTSingelineTextInputNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var RCTTextInputViewConfig = {
+    bubblingEventTypes: {
+      topBlur: {
+        phasedRegistrationNames: {
+          bubbled: 'onBlur',
+          captured: 'onBlurCapture'
+        }
+      },
+      topChange: {
+        phasedRegistrationNames: {
+          bubbled: 'onChange',
+          captured: 'onChangeCapture'
+        }
+      },
+      topEndEditing: {
+        phasedRegistrationNames: {
+          bubbled: 'onEndEditing',
+          captured: 'onEndEditingCapture'
+        }
+      },
+      topFocus: {
+        phasedRegistrationNames: {
+          bubbled: 'onFocus',
+          captured: 'onFocusCapture'
+        }
+      },
+      topKeyPress: {
+        phasedRegistrationNames: {
+          bubbled: 'onKeyPress',
+          captured: 'onKeyPressCapture'
+        }
+      },
+      topSubmitEditing: {
+        phasedRegistrationNames: {
+          bubbled: 'onSubmitEditing',
+          captured: 'onSubmitEditingCapture'
+        }
+      },
+      topTouchCancel: {
+        phasedRegistrationNames: {
+          bubbled: 'onTouchCancel',
+          captured: 'onTouchCancelCapture'
+        }
+      },
+      topTouchEnd: {
+        phasedRegistrationNames: {
+          bubbled: 'onTouchEnd',
+          captured: 'onTouchEndCapture'
+        }
+      },
+      topTouchMove: {
+        phasedRegistrationNames: {
+          bubbled: 'onTouchMove',
+          captured: 'onTouchMoveCapture'
+        }
+      }
+    },
+    directEventTypes: {
+      topScroll: {
+        registrationName: 'onScroll'
+      },
+      topSelectionChange: {
+        registrationName: 'onSelectionChange'
+      },
+      topContentSizeChange: {
+        registrationName: 'onContentSizeChange'
+      },
+      topChangeSync: {
+        registrationName: 'onChangeSync'
+      },
+      topKeyPressSync: {
+        registrationName: 'onKeyPressSync'
+      }
+    },
+    validAttributes: Object.assign({
+      acceptDragAndDropTypes: true,
+      dynamicTypeRamp: true,
+      fontSize: true,
+      fontWeight: true,
+      fontVariant: true,
+      textShadowOffset: {
+        diff: _$$_REQUIRE(_dependencyMap[0], "../../Utilities/differ/sizesDiffer").default
+      },
+      allowFontScaling: true,
+      fontStyle: true,
+      textTransform: true,
+      textAlign: true,
+      fontFamily: true,
+      lineHeight: true,
+      isHighlighted: true,
+      writingDirection: true,
+      textDecorationLine: true,
+      textShadowRadius: true,
+      letterSpacing: true,
+      textDecorationStyle: true,
+      textDecorationColor: {
+        process: _$$_REQUIRE(_dependencyMap[1], "../../StyleSheet/processColor").default
+      },
+      color: {
+        process: _$$_REQUIRE(_dependencyMap[1], "../../StyleSheet/processColor").default
+      },
+      maxFontSizeMultiplier: true,
+      textShadowColor: {
+        process: _$$_REQUIRE(_dependencyMap[1], "../../StyleSheet/processColor").default
+      },
+      editable: true,
+      inputAccessoryViewID: true,
+      inputAccessoryViewButtonLabel: true,
+      caretHidden: true,
+      enablesReturnKeyAutomatically: true,
+      placeholderTextColor: {
+        process: _$$_REQUIRE(_dependencyMap[1], "../../StyleSheet/processColor").default
+      },
+      clearButtonMode: true,
+      keyboardType: true,
+      selection: true,
+      returnKeyType: true,
+      submitBehavior: true,
+      mostRecentEventCount: true,
+      scrollEnabled: true,
+      selectionColor: {
+        process: _$$_REQUIRE(_dependencyMap[1], "../../StyleSheet/processColor").default
+      },
+      contextMenuHidden: true,
+      secureTextEntry: true,
+      placeholder: true,
+      autoCorrect: true,
+      multiline: true,
+      numberOfLines: true,
+      textContentType: true,
+      maxLength: true,
+      autoCapitalize: true,
+      keyboardAppearance: true,
+      passwordRules: true,
+      spellCheck: true,
+      selectTextOnFocus: true,
+      text: true,
+      clearTextOnFocus: true,
+      showSoftInputOnFocus: true,
+      autoFocus: true,
+      lineBreakStrategyIOS: true,
+      lineBreakModeIOS: true,
+      smartInsertDelete: true
+    }, (0, _$$_REQUIRE(_dependencyMap[2], "../../NativeComponent/ViewConfigIgnore").ConditionallyIgnoredEventHandlers)({
+      onChange: true,
+      onSelectionChange: true,
+      onContentSizeChange: true,
+      onScroll: true,
+      onChangeSync: true,
+      onKeyPressSync: true
+    }), {
+      disableKeyboardShortcuts: true
+    })
+  };
+  var _default = exports.default = RCTTextInputViewConfig;
+},132,[67,57,104],"../../node_modules/react-native/Libraries/Components/TextInput/RCTTextInputViewConfig.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = exports.__INTERNAL_VIEW_CONFIG = exports.Commands = void 0;
+  var NativeComponentRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../NativeComponent/NativeComponentRegistry"));
+  var _codegenNativeCommands = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../Utilities/codegenNativeCommands"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var Commands = exports.Commands = (0, _codegenNativeCommands.default)({
+    supportedCommands: ['focus', 'blur', 'setTextAndSelection']
+  });
+  var __INTERNAL_VIEW_CONFIG = exports.__INTERNAL_VIEW_CONFIG = {
+    uiViewClassName: 'AndroidTextInput',
+    bubblingEventTypes: {
+      topBlur: {
+        phasedRegistrationNames: {
+          bubbled: 'onBlur',
+          captured: 'onBlurCapture'
+        }
+      },
+      topEndEditing: {
+        phasedRegistrationNames: {
+          bubbled: 'onEndEditing',
+          captured: 'onEndEditingCapture'
+        }
+      },
+      topFocus: {
+        phasedRegistrationNames: {
+          bubbled: 'onFocus',
+          captured: 'onFocusCapture'
+        }
+      },
+      topKeyPress: {
+        phasedRegistrationNames: {
+          bubbled: 'onKeyPress',
+          captured: 'onKeyPressCapture'
+        }
+      },
+      topSubmitEditing: {
+        phasedRegistrationNames: {
+          bubbled: 'onSubmitEditing',
+          captured: 'onSubmitEditingCapture'
+        }
+      }
+    },
+    directEventTypes: {
+      topScroll: {
+        registrationName: 'onScroll'
+      }
+    },
+    validAttributes: {
+      acceptDragAndDropTypes: true,
+      maxFontSizeMultiplier: true,
+      adjustsFontSizeToFit: true,
+      minimumFontScale: true,
+      autoFocus: true,
+      placeholder: true,
+      inlineImagePadding: true,
+      contextMenuHidden: true,
+      textShadowColor: {
+        process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor").default
+      },
+      maxLength: true,
+      selectTextOnFocus: true,
+      textShadowRadius: true,
+      underlineColorAndroid: {
+        process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor").default
+      },
+      textDecorationLine: true,
+      submitBehavior: true,
+      textAlignVertical: true,
+      fontStyle: true,
+      textShadowOffset: true,
+      selectionColor: {
+        process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor").default
+      },
+      selectionHandleColor: {
+        process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor").default
+      },
+      placeholderTextColor: {
+        process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor").default
+      },
+      importantForAutofill: true,
+      lineHeight: true,
+      textTransform: true,
+      returnKeyType: true,
+      keyboardType: true,
+      multiline: true,
+      color: {
+        process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor").default
+      },
+      autoComplete: true,
+      numberOfLines: true,
+      letterSpacing: true,
+      returnKeyLabel: true,
+      fontSize: true,
+      onKeyPress: true,
+      cursorColor: {
+        process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor").default
+      },
+      text: true,
+      showSoftInputOnFocus: true,
+      textAlign: true,
+      autoCapitalize: true,
+      autoCorrect: true,
+      caretHidden: true,
+      secureTextEntry: true,
+      textBreakStrategy: true,
+      onScroll: true,
+      onContentSizeChange: true,
+      disableFullscreenUI: true,
+      includeFontPadding: true,
+      fontWeight: true,
+      fontFamily: true,
+      allowFontScaling: true,
+      onSelectionChange: true,
+      mostRecentEventCount: true,
+      inlineImageLeft: true,
+      editable: true,
+      fontVariant: true,
+      borderBottomRightRadius: true,
+      borderBottomColor: {
+        process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor").default
+      },
+      borderRadius: true,
+      borderRightColor: {
+        process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor").default
+      },
+      borderColor: {
+        process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor").default
+      },
+      borderTopRightRadius: true,
+      borderStyle: true,
+      borderBottomLeftRadius: true,
+      borderLeftColor: {
+        process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor").default
+      },
+      borderTopLeftRadius: true,
+      borderTopColor: {
+        process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor").default
+      }
+    }
+  };
+  var AndroidTextInputNativeComponent = NativeComponentRegistry.get('AndroidTextInput', function () {
+    return __INTERNAL_VIEW_CONFIG;
+  });
+  var _default = exports.default = AndroidTextInputNativeComponent;
+},133,[1,77,105,57],"../../node_modules/react-native/Libraries/Components/TextInput/AndroidTextInputNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = warnForStyleProps;
+  function warnForStyleProps(props, validAttributes) {
+    if (__DEV__) {
+      for (var key in validAttributes.style) {
+        if (!(validAttributes[key] || props[key] === undefined)) {
+          console.error('You are setting the style `{ %s' + ': ... }` as a prop. You ' + 'should nest it in a style object. ' + 'E.g. `{ style: { %s' + ': ... } }`', key, key);
+        }
+      }
+    }
+  }
+},134,[],"../../node_modules/react-native/Libraries/ReactNative/ReactFabricPublicInstance/warnForStyleProps.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.create = create;
+  exports.diff = diff;
+  var _flattenStyle = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../StyleSheet/flattenStyle"));
+  var _deepDiffer = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../Utilities/differ/deepDiffer"));
+  var emptyObject = {};
+  var removedKeys = null;
+  var removedKeyCount = 0;
+  var deepDifferOptions = {
+    unsafelyIgnoreFunctions: true
+  };
+  function defaultDiffer(prevProp, nextProp) {
+    if (typeof nextProp !== 'object' || nextProp === null) {
+      return true;
+    } else {
+      return (0, _deepDiffer.default)(prevProp, nextProp, deepDifferOptions);
+    }
+  }
+  function restoreDeletedValuesInNestedArray(updatePayload, node, validAttributes) {
+    if (Array.isArray(node)) {
+      var i = node.length;
+      while (i-- && removedKeyCount > 0) {
+        restoreDeletedValuesInNestedArray(updatePayload, node[i], validAttributes);
+      }
+    } else if (node && removedKeyCount > 0) {
+      var obj = node;
+      for (var propKey in removedKeys) {
+        if (!removedKeys[propKey]) {
+          continue;
+        }
+        var nextProp = obj[propKey];
+        if (nextProp === undefined) {
+          continue;
+        }
+        var attributeConfig = validAttributes[propKey];
+        if (!attributeConfig) {
+          continue;
+        }
+        if (typeof nextProp === 'function') {
+          nextProp = true;
+        }
+        if (typeof nextProp === 'undefined') {
+          nextProp = null;
+        }
+        if (typeof attributeConfig !== 'object') {
+          updatePayload[propKey] = nextProp;
+        } else if (typeof attributeConfig.diff === 'function' || typeof attributeConfig.process === 'function') {
+          var nextValue = typeof attributeConfig.process === 'function' ? attributeConfig.process(nextProp) : nextProp;
+          updatePayload[propKey] = nextValue;
+        }
+        removedKeys[propKey] = false;
+        removedKeyCount--;
+      }
+    }
+  }
+  function diffNestedArrayProperty(updatePayload, prevArray, nextArray, validAttributes) {
+    var minLength = prevArray.length < nextArray.length ? prevArray.length : nextArray.length;
+    var i;
+    for (i = 0; i < minLength; i++) {
+      updatePayload = diffNestedProperty(updatePayload, prevArray[i], nextArray[i], validAttributes);
+    }
+    for (; i < prevArray.length; i++) {
+      updatePayload = clearNestedProperty(updatePayload, prevArray[i], validAttributes);
+    }
+    for (; i < nextArray.length; i++) {
+      updatePayload = addNestedProperty(updatePayload, nextArray[i], validAttributes);
+    }
+    return updatePayload;
+  }
+  function diffNestedProperty(updatePayload, prevProp, nextProp, validAttributes) {
+    if (!updatePayload && prevProp === nextProp) {
+      return updatePayload;
+    }
+    if (!prevProp || !nextProp) {
+      if (nextProp) {
+        return addNestedProperty(updatePayload, nextProp, validAttributes);
+      }
+      if (prevProp) {
+        return clearNestedProperty(updatePayload, prevProp, validAttributes);
+      }
+      return updatePayload;
+    }
+    if (!Array.isArray(prevProp) && !Array.isArray(nextProp)) {
+      return diffProperties(updatePayload, prevProp, nextProp, validAttributes);
+    }
+    if (Array.isArray(prevProp) && Array.isArray(nextProp)) {
+      return diffNestedArrayProperty(updatePayload, prevProp, nextProp, validAttributes);
+    }
+    if (Array.isArray(prevProp)) {
+      return diffProperties(updatePayload, (0, _flattenStyle.default)(prevProp), nextProp, validAttributes);
+    }
+    return diffProperties(updatePayload, prevProp, (0, _flattenStyle.default)(nextProp), validAttributes);
+  }
+  function addNestedProperty(updatePayload, nextProp, validAttributes) {
+    if (!nextProp) {
+      return updatePayload;
+    }
+    if (!Array.isArray(nextProp)) {
+      return addProperties(updatePayload, nextProp, validAttributes);
+    }
+    for (var i = 0; i < nextProp.length; i++) {
+      updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
+    }
+    return updatePayload;
+  }
+  function clearNestedProperty(updatePayload, prevProp, validAttributes) {
+    if (!prevProp) {
+      return updatePayload;
+    }
+    if (!Array.isArray(prevProp)) {
+      return clearProperties(updatePayload, prevProp, validAttributes);
+    }
+    for (var i = 0; i < prevProp.length; i++) {
+      updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
+    }
+    return updatePayload;
+  }
+  function diffProperties(updatePayload, prevProps, nextProps, validAttributes) {
+    var attributeConfig;
+    var nextProp;
+    var prevProp;
+    for (var propKey in nextProps) {
+      attributeConfig = validAttributes[propKey];
+      if (!attributeConfig) {
+        continue;
+      }
+      prevProp = prevProps[propKey];
+      nextProp = nextProps[propKey];
+      if (typeof nextProp === 'function') {
+        nextProp = true;
+        if (typeof prevProp === 'function') {
+          prevProp = true;
+        }
+      }
+      if (typeof nextProp === 'undefined') {
+        nextProp = null;
+        if (typeof prevProp === 'undefined') {
+          prevProp = null;
+        }
+      }
+      if (removedKeys) {
+        removedKeys[propKey] = false;
+      }
+      if (updatePayload && updatePayload[propKey] !== undefined) {
+        if (typeof attributeConfig !== 'object') {
+          updatePayload[propKey] = nextProp;
+        } else if (typeof attributeConfig.diff === 'function' || typeof attributeConfig.process === 'function') {
+          var nextValue = typeof attributeConfig.process === 'function' ? attributeConfig.process(nextProp) : nextProp;
+          updatePayload[propKey] = nextValue;
+        }
+        continue;
+      }
+      if (prevProp === nextProp) {
+        continue;
+      }
+      if (typeof attributeConfig !== 'object') {
+        if (defaultDiffer(prevProp, nextProp)) {
+          (updatePayload || (updatePayload = {}))[propKey] = nextProp;
+        }
+      } else if (typeof attributeConfig.diff === 'function' || typeof attributeConfig.process === 'function') {
+        var shouldUpdate = prevProp === undefined || (typeof attributeConfig.diff === 'function' ? attributeConfig.diff(prevProp, nextProp) : defaultDiffer(prevProp, nextProp));
+        if (shouldUpdate) {
+          var _nextValue = typeof attributeConfig.process === 'function' ? attributeConfig.process(nextProp) : nextProp;
+          (updatePayload || (updatePayload = {}))[propKey] = _nextValue;
+        }
+      } else {
+        removedKeys = null;
+        removedKeyCount = 0;
+        updatePayload = diffNestedProperty(updatePayload, prevProp, nextProp, attributeConfig);
+        if (removedKeyCount > 0 && updatePayload) {
+          restoreDeletedValuesInNestedArray(updatePayload, nextProp, attributeConfig);
+          removedKeys = null;
+        }
+      }
+    }
+    for (var _propKey in prevProps) {
+      if (nextProps[_propKey] !== undefined) {
+        continue;
+      }
+      attributeConfig = validAttributes[_propKey];
+      if (!attributeConfig) {
+        continue;
+      }
+      if (updatePayload && updatePayload[_propKey] !== undefined) {
+        continue;
+      }
+      prevProp = prevProps[_propKey];
+      if (prevProp === undefined) {
+        continue;
+      }
+      if (typeof attributeConfig !== 'object' || typeof attributeConfig.diff === 'function' || typeof attributeConfig.process === 'function') {
+        (updatePayload || (updatePayload = {}))[_propKey] = null;
+        if (!removedKeys) {
+          removedKeys = {};
+        }
+        if (!removedKeys[_propKey]) {
+          removedKeys[_propKey] = true;
+          removedKeyCount++;
+        }
+      } else {
+        updatePayload = clearNestedProperty(updatePayload, prevProp, attributeConfig);
+      }
+    }
+    return updatePayload;
+  }
+  function addProperties(updatePayload, props, validAttributes) {
+    return diffProperties(updatePayload, emptyObject, props, validAttributes);
+  }
+  function clearProperties(updatePayload, prevProps, validAttributes) {
+    return diffProperties(updatePayload, prevProps, emptyObject, validAttributes);
+  }
+  function create(props, validAttributes) {
+    return addProperties(null, props, validAttributes);
+  }
+  function diff(prevProps, nextProps, validAttributes) {
+    return diffProperties(null, prevProps, nextProps, validAttributes);
+  }
+},135,[1,9,136],"../../node_modules/react-native/Libraries/ReactNative/ReactFabricPublicInstance/ReactNativeAttributePayload.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var logListeners;
+  function unstable_setLogListeners(listeners) {
+    logListeners = listeners;
+  }
+  function deepDiffer(one, two) {
+    var maxDepthOrOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
+    var maybeOptions = arguments.length > 3 ? arguments[3] : undefined;
+    var options = typeof maxDepthOrOptions === 'number' ? maybeOptions : maxDepthOrOptions;
+    var maxDepth = typeof maxDepthOrOptions === 'number' ? maxDepthOrOptions : -1;
+    if (maxDepth === 0) {
+      return true;
+    }
+    if (one === two) {
+      return false;
+    }
+    if (typeof one === 'function' && typeof two === 'function') {
+      var unsafelyIgnoreFunctions = options == null ? void 0 : options.unsafelyIgnoreFunctions;
+      if (unsafelyIgnoreFunctions == null) {
+        if (logListeners && logListeners.onDifferentFunctionsIgnored && (!options || !('unsafelyIgnoreFunctions' in options))) {
+          logListeners.onDifferentFunctionsIgnored(one.name, two.name);
+        }
+        unsafelyIgnoreFunctions = true;
+      }
+      return !unsafelyIgnoreFunctions;
+    }
+    if (typeof one !== 'object' || one === null) {
+      return one !== two;
+    }
+    if (typeof two !== 'object' || two === null) {
+      return true;
+    }
+    if (one.constructor !== two.constructor) {
+      return true;
+    }
+    if (Array.isArray(one)) {
+      var len = one.length;
+      if (two.length !== len) {
+        return true;
+      }
+      for (var ii = 0; ii < len; ii++) {
+        if (deepDiffer(one[ii], two[ii], maxDepth - 1, options)) {
+          return true;
+        }
+      }
+    } else {
+      for (var key in one) {
+        if (deepDiffer(one[key], two[key], maxDepth - 1, options)) {
+          return true;
+        }
+      }
+      for (var twoKey in two) {
+        if (one[twoKey] === undefined && two[twoKey] !== undefined) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  deepDiffer.unstable_setLogListeners = unstable_setLogListeners;
+  var _default = exports.default = deepDiffer;
+},136,[],"../../node_modules/react-native/Libraries/Utilities/differ/deepDiffer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var _ReadOnlyNode2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./ReadOnlyNode"));
+  var _NativeDOM = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./specs/NativeDOM"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var ReadOnlyCharacterData = exports.default = /*#__PURE__*/function (_ReadOnlyNode) {
+    function ReadOnlyCharacterData() {
+      (0, _classCallCheck2.default)(this, ReadOnlyCharacterData);
+      return _callSuper(this, ReadOnlyCharacterData, arguments);
+    }
+    (0, _inherits2.default)(ReadOnlyCharacterData, _ReadOnlyNode);
+    return (0, _createClass2.default)(ReadOnlyCharacterData, [{
+      key: "nextElementSibling",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[8], "./internals/Traversal").getElementSibling)(this, 'next');
+      }
+    }, {
+      key: "previousElementSibling",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[8], "./internals/Traversal").getElementSibling)(this, 'previous');
+      }
+    }, {
+      key: "data",
+      get: function get() {
+        var node = (0, _$$_REQUIRE(_dependencyMap[9], "./internals/NodeInternals").getNativeTextReference)(this);
+        if (node != null) {
+          return _NativeDOM.default.getTextContent(node);
+        }
+        return '';
+      }
+    }, {
+      key: "length",
+      get: function get() {
+        return this.data.length;
+      }
+    }, {
+      key: "textContent",
+      get: function get() {
+        return this.data;
+      }
+    }, {
+      key: "nodeValue",
+      get: function get() {
+        return this.data;
+      }
+    }, {
+      key: "substringData",
+      value: function substringData(offset, count) {
+        var data = this.data;
+        if (offset < 0) {
+          throw new TypeError(`Failed to execute 'substringData' on 'CharacterData': The offset ${offset} is negative.`);
+        }
+        if (offset > data.length) {
+          throw new TypeError(`Failed to execute 'substringData' on 'CharacterData': The offset ${offset} is greater than the node's length (${data.length}).`);
+        }
+        var adjustedCount = count < 0 || count > data.length ? data.length : count;
+        return data.slice(offset, offset + adjustedCount);
+      }
+    }]);
+  }(_ReadOnlyNode2.default);
+},137,[1,11,12,18,20,23,121,122,127,123],"../../node_modules/react-native/src/private/webapis/dom/nodes/ReadOnlyCharacterData.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var _ReadOnlyCharacterData = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./ReadOnlyCharacterData"));
+  var _ReadOnlyNode = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./ReadOnlyNode"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var ReadOnlyText = exports.default = /*#__PURE__*/function (_ReadOnlyCharacterDat) {
+    function ReadOnlyText() {
+      (0, _classCallCheck2.default)(this, ReadOnlyText);
+      return _callSuper(this, ReadOnlyText, arguments);
+    }
+    (0, _inherits2.default)(ReadOnlyText, _ReadOnlyCharacterDat);
+    return (0, _createClass2.default)(ReadOnlyText, [{
+      key: "nodeName",
+      get: function get() {
+        return '#text';
+      }
+    }, {
+      key: "nodeType",
+      get: function get() {
+        return _ReadOnlyNode.default.TEXT_NODE;
+      }
+    }]);
+  }(_ReadOnlyCharacterData.default);
+},138,[1,11,12,18,20,23,137,121],"../../node_modules/react-native/src/private/webapis/dom/nodes/ReadOnlyText.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  var _Performance = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../src/private/webapis/performance/Performance"));
+  var _NativePerformance = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../src/private/webapis/performance/specs/NativePerformance"));
+  if (_NativePerformance.default) {
+    global.performance = new _Performance.default();
+  } else {
+    if (!global.performance) {
+      global.performance = {
+        mark: function mark() {},
+        measure: function measure() {},
+        now: function now() {
+          var performanceNow = global.nativePerformanceNow || Date.now;
+          return performanceNow();
+        }
+      };
+    }
+  }
+},139,[1,140,144],"../../node_modules/react-native/Libraries/Core/setUpPerformance.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _readOnlyError2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/readOnlyError"));
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/slicedToArray"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass"));
+  var _MemoryInfo = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./MemoryInfo"));
+  var _ReactNativeStartupTiming = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./ReactNativeStartupTiming"));
+  var _NativePerformance = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./specs/NativePerformance"));
+  var _ref, _NativePerformance$no;
+  var getCurrentTimeStamp = (_ref = (_NativePerformance$no = _NativePerformance.default == null ? void 0 : _NativePerformance.default.now) != null ? _NativePerformance$no : global.nativePerformanceNow) != null ? _ref : function () {
+    return Date.now();
+  };
+  var ENTRY_TYPES_AVAILABLE_FROM_TIMELINE = ['mark', 'measure'];
+  var Performance = exports.default = /*#__PURE__*/function () {
+    function Performance() {
+      (0, _classCallCheck2.default)(this, Performance);
+      this.eventCounts = new (_$$_REQUIRE(_dependencyMap[8], "./EventTiming").EventCounts)();
+      this.now = getCurrentTimeStamp;
+    }
+    return (0, _createClass2.default)(Performance, [{
+      key: "memory",
+      get: function get() {
+        if (_NativePerformance.default != null && _NativePerformance.default.getSimpleMemoryInfo) {
+          var memoryInfo = _NativePerformance.default.getSimpleMemoryInfo();
+          if (memoryInfo.hasOwnProperty('hermes_heapSize')) {
+            var totalJSHeapSize = memoryInfo.hermes_heapSize,
+              usedJSHeapSize = memoryInfo.hermes_allocatedBytes;
+            return new _MemoryInfo.default({
+              jsHeapSizeLimit: null,
+              totalJSHeapSize: totalJSHeapSize,
+              usedJSHeapSize: usedJSHeapSize
+            });
+          } else {
+            return new _MemoryInfo.default();
+          }
+        }
+        return new _MemoryInfo.default();
+      }
+    }, {
+      key: "rnStartupTiming",
+      get: function get() {
+        if (_NativePerformance.default != null && _NativePerformance.default.getReactNativeStartupTiming) {
+          var _NativePerformance$ge = _NativePerformance.default.getReactNativeStartupTiming(),
+            startTime = _NativePerformance$ge.startTime,
+            endTime = _NativePerformance$ge.endTime,
+            initializeRuntimeStart = _NativePerformance$ge.initializeRuntimeStart,
+            initializeRuntimeEnd = _NativePerformance$ge.initializeRuntimeEnd,
+            executeJavaScriptBundleEntryPointStart = _NativePerformance$ge.executeJavaScriptBundleEntryPointStart,
+            executeJavaScriptBundleEntryPointEnd = _NativePerformance$ge.executeJavaScriptBundleEntryPointEnd;
+          return new _ReactNativeStartupTiming.default({
+            startTime: startTime,
+            endTime: endTime,
+            initializeRuntimeStart: initializeRuntimeStart,
+            initializeRuntimeEnd: initializeRuntimeEnd,
+            executeJavaScriptBundleEntryPointStart: executeJavaScriptBundleEntryPointStart,
+            executeJavaScriptBundleEntryPointEnd: executeJavaScriptBundleEntryPointEnd
+          });
+        }
+        return new _ReactNativeStartupTiming.default();
+      }
+    }, {
+      key: "mark",
+      value: function mark(markName, markOptions) {
+        var computedStartTime;
+        if (_NativePerformance.default != null && _NativePerformance.default.markWithResult) {
+          computedStartTime = _NativePerformance.default.markWithResult(markName, markOptions == null ? void 0 : markOptions.startTime);
+        } else {
+          (0, _$$_REQUIRE(_dependencyMap[9], "./internals/Utilities").warnNoNativePerformance)();
+          computedStartTime = performance.now();
+        }
+        return new (_$$_REQUIRE(_dependencyMap[10], "./UserTiming").PerformanceMark)(markName, {
+          startTime: computedStartTime,
+          detail: markOptions == null ? void 0 : markOptions.detail
+        });
+      }
+    }, {
+      key: "clearMarks",
+      value: function clearMarks(markName) {
+        if (!(_NativePerformance.default != null && _NativePerformance.default.clearMarks)) {
+          (0, _$$_REQUIRE(_dependencyMap[9], "./internals/Utilities").warnNoNativePerformance)();
+          return;
+        }
+        _NativePerformance.default.clearMarks(markName);
+      }
+    }, {
+      key: "measure",
+      value: function measure(measureName, startMarkOrOptions, endMark) {
+        var _options;
+        var options;
+        var startMarkName,
+          endMarkName = endMark,
+          duration,
+          startTime = 0,
+          endTime = 0;
+        if (typeof startMarkOrOptions === 'string') {
+          startMarkName = startMarkOrOptions;
+          options = {};
+        } else if (startMarkOrOptions !== undefined) {
+          var _options$duration;
+          options = startMarkOrOptions;
+          if (endMark !== undefined) {
+            throw new TypeError("Performance.measure: Can't have both options and endMark");
+          }
+          if (options.start === undefined && options.end === undefined) {
+            throw new TypeError('Performance.measure: Must have at least one of start/end specified in options');
+          }
+          if (options.start !== undefined && options.end !== undefined && options.duration !== undefined) {
+            throw new TypeError("Performance.measure: Can't have both start/end and duration explicitly in options");
+          }
+          if (typeof options.start === 'number') {
+            startTime = options.start;
+          } else {
+            startMarkName = options.start;
+          }
+          if (typeof options.end === 'number') {
+            endTime = options.end;
+          } else {
+            endMarkName = options.end;
+          }
+          duration = (_options$duration = options.duration) != null ? _options$duration : duration;
+        }
+        var computedStartTime = startTime;
+        var computedDuration = duration;
+        if (_NativePerformance.default != null && _NativePerformance.default.measureWithResult) {
+          var _NativePerformance$me = _NativePerformance.default.measureWithResult(measureName, startTime, endTime, duration, startMarkName, endMarkName);
+          var _NativePerformance$me2 = (0, _slicedToArray2.default)(_NativePerformance$me, 2);
+          computedStartTime = _NativePerformance$me2[0];
+          computedDuration = _NativePerformance$me2[1];
+        } else {
+          (0, _$$_REQUIRE(_dependencyMap[9], "./internals/Utilities").warnNoNativePerformance)();
+        }
+        var measure = new (_$$_REQUIRE(_dependencyMap[10], "./UserTiming").PerformanceMeasure)(measureName, {
+          startTime: computedStartTime,
+          duration: computedDuration != null ? computedDuration : 0,
+          detail: (_options = options) == null ? void 0 : _options.detail
+        });
+        return measure;
+      }
+    }, {
+      key: "clearMeasures",
+      value: function clearMeasures(measureName) {
+        if (!(_NativePerformance.default != null && _NativePerformance.default.clearMeasures)) {
+          (0, _$$_REQUIRE(_dependencyMap[9], "./internals/Utilities").warnNoNativePerformance)();
+          return;
+        }
+        _NativePerformance.default == null || _NativePerformance.default.clearMeasures(measureName);
+      }
+    }, {
+      key: "getEntries",
+      value: function getEntries() {
+        if (!(_NativePerformance.default != null && _NativePerformance.default.getEntries)) {
+          (0, _$$_REQUIRE(_dependencyMap[9], "./internals/Utilities").warnNoNativePerformance)();
+          return [];
+        }
+        return _NativePerformance.default.getEntries().map(_$$_REQUIRE(_dependencyMap[11], "./internals/RawPerformanceEntry").rawToPerformanceEntry);
+      }
+    }, {
+      key: "getEntriesByType",
+      value: function getEntriesByType(entryType) {
+        if (entryType != null && !ENTRY_TYPES_AVAILABLE_FROM_TIMELINE.includes(entryType)) {
+          console.warn('Deprecated API for given entry type.');
+          return [];
+        }
+        if (!(_NativePerformance.default != null && _NativePerformance.default.getEntriesByType)) {
+          (0, _$$_REQUIRE(_dependencyMap[9], "./internals/Utilities").warnNoNativePerformance)();
+          return [];
+        }
+        return _NativePerformance.default.getEntriesByType((0, _$$_REQUIRE(_dependencyMap[11], "./internals/RawPerformanceEntry").performanceEntryTypeToRaw)(entryType)).map(_$$_REQUIRE(_dependencyMap[11], "./internals/RawPerformanceEntry").rawToPerformanceEntry);
+      }
+    }, {
+      key: "getEntriesByName",
+      value: function getEntriesByName(entryName, entryType) {
+        if (entryType != null && !ENTRY_TYPES_AVAILABLE_FROM_TIMELINE.includes(entryType)) {
+          console.warn('Deprecated API for given entry type.');
+          return [];
+        }
+        if (!(_NativePerformance.default != null && _NativePerformance.default.getEntriesByName)) {
+          (0, _$$_REQUIRE(_dependencyMap[9], "./internals/Utilities").warnNoNativePerformance)();
+          return [];
+        }
+        return _NativePerformance.default.getEntriesByName(entryName, entryType != null ? (0, _$$_REQUIRE(_dependencyMap[11], "./internals/RawPerformanceEntry").performanceEntryTypeToRaw)(entryType) : undefined).map(_$$_REQUIRE(_dependencyMap[11], "./internals/RawPerformanceEntry").rawToPerformanceEntry);
+      }
+    }]);
+  }();
+},140,[1,141,34,11,12,142,143,144,145,147,148,149],"../../node_modules/react-native/src/private/webapis/performance/Performance.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _readOnlyError(r) {
+    throw new TypeError('"' + r + '" is read-only');
+  }
+  module.exports = _readOnlyError, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},141,[],"../../node_modules/@babel/runtime/helpers/readOnlyError.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _classPrivateFieldLooseBase2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classPrivateFieldLooseBase"));
+  var _classPrivateFieldLooseKey2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classPrivateFieldLooseKey"));
+  var _jsHeapSizeLimit = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("jsHeapSizeLimit");
+  var _totalJSHeapSize = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("totalJSHeapSize");
+  var _usedJSHeapSize = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("usedJSHeapSize");
+  var MemoryInfo = exports.default = /*#__PURE__*/function () {
+    function MemoryInfo(memoryInfo) {
+      (0, _classCallCheck2.default)(this, MemoryInfo);
+      Object.defineProperty(this, _jsHeapSizeLimit, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(this, _totalJSHeapSize, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(this, _usedJSHeapSize, {
+        writable: true,
+        value: void 0
+      });
+      if (memoryInfo != null) {
+        (0, _classPrivateFieldLooseBase2.default)(this, _jsHeapSizeLimit)[_jsHeapSizeLimit] = memoryInfo.jsHeapSizeLimit;
+        (0, _classPrivateFieldLooseBase2.default)(this, _totalJSHeapSize)[_totalJSHeapSize] = memoryInfo.totalJSHeapSize;
+        (0, _classPrivateFieldLooseBase2.default)(this, _usedJSHeapSize)[_usedJSHeapSize] = memoryInfo.usedJSHeapSize;
+      }
+    }
+    return (0, _createClass2.default)(MemoryInfo, [{
+      key: "jsHeapSizeLimit",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _jsHeapSizeLimit)[_jsHeapSizeLimit];
+      }
+    }, {
+      key: "totalJSHeapSize",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _totalJSHeapSize)[_totalJSHeapSize];
+      }
+    }, {
+      key: "usedJSHeapSize",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _usedJSHeapSize)[_usedJSHeapSize];
+      }
+    }]);
+  }();
+},142,[1,11,12,26,27],"../../node_modules/react-native/src/private/webapis/performance/MemoryInfo.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _classPrivateFieldLooseBase2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classPrivateFieldLooseBase"));
+  var _classPrivateFieldLooseKey2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classPrivateFieldLooseKey"));
+  var _startTime = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("startTime");
+  var _endTime = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("endTime");
+  var _initializeRuntimeStart = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("initializeRuntimeStart");
+  var _initializeRuntimeEnd = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("initializeRuntimeEnd");
+  var _executeJavaScriptBundleEntryPointStart = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("executeJavaScriptBundleEntryPointStart");
+  var _executeJavaScriptBundleEntryPointEnd = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("executeJavaScriptBundleEntryPointEnd");
+  var ReactNativeStartupTiming = exports.default = /*#__PURE__*/function () {
+    function ReactNativeStartupTiming(startUpTiming) {
+      (0, _classCallCheck2.default)(this, ReactNativeStartupTiming);
+      Object.defineProperty(this, _startTime, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(this, _endTime, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(this, _initializeRuntimeStart, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(this, _initializeRuntimeEnd, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(this, _executeJavaScriptBundleEntryPointStart, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(this, _executeJavaScriptBundleEntryPointEnd, {
+        writable: true,
+        value: void 0
+      });
+      if (startUpTiming != null) {
+        (0, _classPrivateFieldLooseBase2.default)(this, _startTime)[_startTime] = startUpTiming.startTime;
+        (0, _classPrivateFieldLooseBase2.default)(this, _endTime)[_endTime] = startUpTiming.endTime;
+        (0, _classPrivateFieldLooseBase2.default)(this, _initializeRuntimeStart)[_initializeRuntimeStart] = startUpTiming.initializeRuntimeStart;
+        (0, _classPrivateFieldLooseBase2.default)(this, _initializeRuntimeEnd)[_initializeRuntimeEnd] = startUpTiming.initializeRuntimeEnd;
+        (0, _classPrivateFieldLooseBase2.default)(this, _executeJavaScriptBundleEntryPointStart)[_executeJavaScriptBundleEntryPointStart] = startUpTiming.executeJavaScriptBundleEntryPointStart;
+        (0, _classPrivateFieldLooseBase2.default)(this, _executeJavaScriptBundleEntryPointEnd)[_executeJavaScriptBundleEntryPointEnd] = startUpTiming.executeJavaScriptBundleEntryPointEnd;
+      }
+    }
+    return (0, _createClass2.default)(ReactNativeStartupTiming, [{
+      key: "startTime",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _startTime)[_startTime];
+      }
+    }, {
+      key: "endTime",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _endTime)[_endTime];
+      }
+    }, {
+      key: "initializeRuntimeStart",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _initializeRuntimeStart)[_initializeRuntimeStart];
+      }
+    }, {
+      key: "initializeRuntimeEnd",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _initializeRuntimeEnd)[_initializeRuntimeEnd];
+      }
+    }, {
+      key: "executeJavaScriptBundleEntryPointStart",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _executeJavaScriptBundleEntryPointStart)[_executeJavaScriptBundleEntryPointStart];
+      }
+    }, {
+      key: "executeJavaScriptBundleEntryPointEnd",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _executeJavaScriptBundleEntryPointEnd)[_executeJavaScriptBundleEntryPointEnd];
+      }
+    }]);
+  }();
+},143,[1,11,12,26,27],"../../node_modules/react-native/src/private/webapis/performance/ReactNativeStartupTiming.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.get('NativePerformanceCxx');
+},144,[31],"../../node_modules/react-native/src/private/webapis/performance/specs/NativePerformance.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.PerformanceEventTiming = exports.EventCounts = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _classPrivateFieldLooseBase2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/classPrivateFieldLooseBase"));
+  var _classPrivateFieldLooseKey2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/classPrivateFieldLooseKey"));
+  var _NativePerformance = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./specs/NativePerformance"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  var _processingStart = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("processingStart");
+  var _processingEnd = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("processingEnd");
+  var _interactionId = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("interactionId");
+  var PerformanceEventTiming = exports.PerformanceEventTiming = /*#__PURE__*/function (_PerformanceEntry) {
+    function PerformanceEventTiming(init) {
+      var _init$startTime, _init$duration, _init$processingStart, _init$processingEnd, _init$interactionId;
+      var _this;
+      (0, _classCallCheck2.default)(this, PerformanceEventTiming);
+      _this = _callSuper(this, PerformanceEventTiming, [{
+        name: init.name,
+        entryType: 'event',
+        startTime: (_init$startTime = init.startTime) != null ? _init$startTime : 0,
+        duration: (_init$duration = init.duration) != null ? _init$duration : 0
+      }]);
+      Object.defineProperty(_this, _processingStart, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(_this, _processingEnd, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(_this, _interactionId, {
+        writable: true,
+        value: void 0
+      });
+      (0, _classPrivateFieldLooseBase2.default)(_this, _processingStart)[_processingStart] = (_init$processingStart = init.processingStart) != null ? _init$processingStart : 0;
+      (0, _classPrivateFieldLooseBase2.default)(_this, _processingEnd)[_processingEnd] = (_init$processingEnd = init.processingEnd) != null ? _init$processingEnd : 0;
+      (0, _classPrivateFieldLooseBase2.default)(_this, _interactionId)[_interactionId] = (_init$interactionId = init.interactionId) != null ? _init$interactionId : 0;
+      return _this;
+    }
+    (0, _inherits2.default)(PerformanceEventTiming, _PerformanceEntry);
+    return (0, _createClass2.default)(PerformanceEventTiming, [{
+      key: "processingStart",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _processingStart)[_processingStart];
+      }
+    }, {
+      key: "processingEnd",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _processingEnd)[_processingEnd];
+      }
+    }, {
+      key: "interactionId",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _interactionId)[_interactionId];
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON() {
+        return Object.assign({}, _superPropGet(PerformanceEventTiming, "toJSON", this, 3)([]), {
+          processingStart: (0, _classPrivateFieldLooseBase2.default)(this, _processingStart)[_processingStart],
+          processingEnd: (0, _classPrivateFieldLooseBase2.default)(this, _processingEnd)[_processingEnd],
+          interactionId: (0, _classPrivateFieldLooseBase2.default)(this, _interactionId)[_interactionId]
+        });
+      }
+    }]);
+  }(_$$_REQUIRE(_dependencyMap[10], "./PerformanceEntry").PerformanceEntry);
+  var cachedEventCounts;
+  function getCachedEventCounts() {
+    var _NativePerformance$ge;
+    if (cachedEventCounts) {
+      return cachedEventCounts;
+    }
+    if (!_NativePerformance.default || !(_NativePerformance.default != null && _NativePerformance.default.getEventCounts)) {
+      (0, _$$_REQUIRE(_dependencyMap[11], "./internals/Utilities").warnNoNativePerformance)();
+      cachedEventCounts = new Map();
+      return cachedEventCounts;
+    }
+    var eventCounts = new Map((_NativePerformance$ge = _NativePerformance.default.getEventCounts == null ? void 0 : _NativePerformance.default.getEventCounts()) != null ? _NativePerformance$ge : []);
+    cachedEventCounts = eventCounts;
+    global.queueMicrotask(function () {
+      cachedEventCounts = null;
+    });
+    return eventCounts;
+  }
+  var EventCounts = exports.EventCounts = /*#__PURE__*/function () {
+    function EventCounts() {
+      (0, _classCallCheck2.default)(this, EventCounts);
+    }
+    return (0, _createClass2.default)(EventCounts, [{
+      key: "size",
+      get: function get() {
+        return getCachedEventCounts().size;
+      }
+    }, {
+      key: "entries",
+      value: function entries() {
+        return getCachedEventCounts().entries();
+      }
+    }, {
+      key: "forEach",
+      value: function forEach(callback) {
+        return getCachedEventCounts().forEach(callback);
+      }
+    }, {
+      key: "get",
+      value: function get(key) {
+        return getCachedEventCounts().get(key);
+      }
+    }, {
+      key: "has",
+      value: function has(key) {
+        return getCachedEventCounts().has(key);
+      }
+    }, {
+      key: "keys",
+      value: function keys() {
+        return getCachedEventCounts().keys();
+      }
+    }, {
+      key: "values",
+      value: function values() {
+        return getCachedEventCounts().values();
+      }
+    }]);
+  }();
+},145,[1,11,12,18,20,21,23,26,27,144,146,147],"../../node_modules/react-native/src/private/webapis/performance/EventTiming.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.PerformanceEntry = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _classPrivateFieldLooseBase2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classPrivateFieldLooseBase"));
+  var _classPrivateFieldLooseKey2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classPrivateFieldLooseKey"));
+  var _name = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("name");
+  var _entryType = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("entryType");
+  var _startTime = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("startTime");
+  var _duration = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("duration");
+  var PerformanceEntry = exports.PerformanceEntry = /*#__PURE__*/function () {
+    function PerformanceEntry(init) {
+      (0, _classCallCheck2.default)(this, PerformanceEntry);
+      Object.defineProperty(this, _name, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(this, _entryType, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(this, _startTime, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(this, _duration, {
+        writable: true,
+        value: void 0
+      });
+      (0, _classPrivateFieldLooseBase2.default)(this, _name)[_name] = init.name;
+      (0, _classPrivateFieldLooseBase2.default)(this, _entryType)[_entryType] = init.entryType;
+      (0, _classPrivateFieldLooseBase2.default)(this, _startTime)[_startTime] = init.startTime;
+      (0, _classPrivateFieldLooseBase2.default)(this, _duration)[_duration] = init.duration;
+    }
+    return (0, _createClass2.default)(PerformanceEntry, [{
+      key: "name",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _name)[_name];
+      }
+    }, {
+      key: "entryType",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _entryType)[_entryType];
+      }
+    }, {
+      key: "startTime",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _startTime)[_startTime];
+      }
+    }, {
+      key: "duration",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _duration)[_duration];
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON() {
+        return {
+          name: (0, _classPrivateFieldLooseBase2.default)(this, _name)[_name],
+          entryType: (0, _classPrivateFieldLooseBase2.default)(this, _entryType)[_entryType],
+          startTime: (0, _classPrivateFieldLooseBase2.default)(this, _startTime)[_startTime],
+          duration: (0, _classPrivateFieldLooseBase2.default)(this, _duration)[_duration]
+        };
+      }
+    }]);
+  }();
+},146,[1,11,12,26,27],"../../node_modules/react-native/src/private/webapis/performance/PerformanceEntry.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.warnNoNativePerformance = warnNoNativePerformance;
+  var _warnOnce = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../../../../Libraries/Utilities/warnOnce"));
+  function warnNoNativePerformance() {
+    (0, _warnOnce.default)('missing-native-performance', 'Missing native implementation of Performance');
+  }
+},147,[1,46],"../../node_modules/react-native/src/private/webapis/performance/internals/Utilities.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.PerformanceMeasure = exports.PerformanceMark = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var _classPrivateFieldLooseBase2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/classPrivateFieldLooseBase"));
+  var _classPrivateFieldLooseKey2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/classPrivateFieldLooseKey"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var _detail = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("detail");
+  var PerformanceMark = exports.PerformanceMark = /*#__PURE__*/function (_PerformanceEntry) {
+    function PerformanceMark(markName, markOptions) {
+      var _markOptions$startTim;
+      var _this;
+      (0, _classCallCheck2.default)(this, PerformanceMark);
+      _this = _callSuper(this, PerformanceMark, [{
+        name: markName,
+        entryType: 'mark',
+        startTime: (_markOptions$startTim = markOptions == null ? void 0 : markOptions.startTime) != null ? _markOptions$startTim : performance.now(),
+        duration: 0
+      }]);
+      Object.defineProperty(_this, _detail, {
+        writable: true,
+        value: void 0
+      });
+      if (markOptions) {
+        (0, _classPrivateFieldLooseBase2.default)(_this, _detail)[_detail] = markOptions.detail;
+      }
+      return _this;
+    }
+    (0, _inherits2.default)(PerformanceMark, _PerformanceEntry);
+    return (0, _createClass2.default)(PerformanceMark, [{
+      key: "detail",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _detail)[_detail];
+      }
+    }]);
+  }(_$$_REQUIRE(_dependencyMap[8], "./PerformanceEntry").PerformanceEntry);
+  var _detail2 = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("detail");
+  var PerformanceMeasure = exports.PerformanceMeasure = /*#__PURE__*/function (_PerformanceEntry2) {
+    function PerformanceMeasure(measureName, measureOptions) {
+      var _this2;
+      (0, _classCallCheck2.default)(this, PerformanceMeasure);
+      _this2 = _callSuper(this, PerformanceMeasure, [{
+        name: measureName,
+        entryType: 'measure',
+        startTime: measureOptions.startTime,
+        duration: measureOptions.duration
+      }]);
+      Object.defineProperty(_this2, _detail2, {
+        writable: true,
+        value: void 0
+      });
+      if (measureOptions) {
+        (0, _classPrivateFieldLooseBase2.default)(_this2, _detail2)[_detail2] = measureOptions.detail;
+      }
+      return _this2;
+    }
+    (0, _inherits2.default)(PerformanceMeasure, _PerformanceEntry2);
+    return (0, _createClass2.default)(PerformanceMeasure, [{
+      key: "detail",
+      get: function get() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _detail2)[_detail2];
+      }
+    }]);
+  }(_$$_REQUIRE(_dependencyMap[8], "./PerformanceEntry").PerformanceEntry);
+},148,[1,11,12,18,20,23,26,27,146],"../../node_modules/react-native/src/private/webapis/performance/UserTiming.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.RawPerformanceEntryTypeValues = void 0;
+  exports.performanceEntryTypeToRaw = performanceEntryTypeToRaw;
+  exports.rawToPerformanceEntry = rawToPerformanceEntry;
+  exports.rawToPerformanceEntryType = rawToPerformanceEntryType;
+  var RawPerformanceEntryTypeValues = exports.RawPerformanceEntryTypeValues = {
+    MARK: 1,
+    MEASURE: 2,
+    EVENT: 3,
+    LONGTASK: 4,
+    RESOURCE: 5
+  };
+  function rawToPerformanceEntry(entry) {
+    if (entry.entryType === RawPerformanceEntryTypeValues.EVENT) {
+      return new (_$$_REQUIRE(_dependencyMap[0], "../EventTiming").PerformanceEventTiming)({
+        name: entry.name,
+        startTime: entry.startTime,
+        duration: entry.duration,
+        processingStart: entry.processingStart,
+        processingEnd: entry.processingEnd,
+        interactionId: entry.interactionId
+      });
+    } else if (entry.entryType === RawPerformanceEntryTypeValues.LONGTASK) {
+      return new (_$$_REQUIRE(_dependencyMap[1], "../LongTasks").PerformanceLongTaskTiming)({
+        name: entry.name,
+        entryType: rawToPerformanceEntryType(entry.entryType),
+        startTime: entry.startTime,
+        duration: entry.duration
+      });
+    } else if (entry.entryType === RawPerformanceEntryTypeValues.MARK) {
+      return new (_$$_REQUIRE(_dependencyMap[2], "../UserTiming").PerformanceMark)(entry.name, {
+        startTime: entry.startTime
+      });
+    } else if (entry.entryType === RawPerformanceEntryTypeValues.MEASURE) {
+      return new (_$$_REQUIRE(_dependencyMap[2], "../UserTiming").PerformanceMeasure)(entry.name, {
+        startTime: entry.startTime,
+        duration: entry.duration
+      });
+    } else {
+      return new (_$$_REQUIRE(_dependencyMap[3], "../PerformanceEntry").PerformanceEntry)({
+        name: entry.name,
+        entryType: rawToPerformanceEntryType(entry.entryType),
+        startTime: entry.startTime,
+        duration: entry.duration
+      });
+    }
+  }
+  function rawToPerformanceEntryType(type) {
+    switch (type) {
+      case RawPerformanceEntryTypeValues.MARK:
+        return 'mark';
+      case RawPerformanceEntryTypeValues.MEASURE:
+        return 'measure';
+      case RawPerformanceEntryTypeValues.EVENT:
+        return 'event';
+      case RawPerformanceEntryTypeValues.LONGTASK:
+        return 'longtask';
+      default:
+        throw new TypeError(`rawToPerformanceEntryType: unexpected performance entry type received: ${type}`);
+    }
+  }
+  function performanceEntryTypeToRaw(type) {
+    switch (type) {
+      case 'mark':
+        return RawPerformanceEntryTypeValues.MARK;
+      case 'measure':
+        return RawPerformanceEntryTypeValues.MEASURE;
+      case 'event':
+        return RawPerformanceEntryTypeValues.EVENT;
+      case 'longtask':
+        return RawPerformanceEntryTypeValues.LONGTASK;
+      case 'resource':
+        return RawPerformanceEntryTypeValues.RESOURCE;
+      default:
+        type;
+        throw new TypeError(`performanceEntryTypeToRaw: unexpected performance entry type received: ${type}`);
+    }
+  }
+},149,[145,150,148,146],"../../node_modules/react-native/src/private/webapis/performance/internals/RawPerformanceEntry.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.TaskAttributionTiming = exports.PerformanceLongTaskTiming = void 0;
+  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/get"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var TaskAttributionTiming = exports.TaskAttributionTiming = /*#__PURE__*/function (_PerformanceEntry) {
+    function TaskAttributionTiming() {
+      (0, _classCallCheck2.default)(this, TaskAttributionTiming);
+      return _callSuper(this, TaskAttributionTiming, arguments);
+    }
+    (0, _inherits2.default)(TaskAttributionTiming, _PerformanceEntry);
+    return (0, _createClass2.default)(TaskAttributionTiming);
+  }(_$$_REQUIRE(_dependencyMap[7], "./PerformanceEntry").PerformanceEntry);
+  var EMPTY_ATTRIBUTION = Object.preventExtensions([]);
+  var PerformanceLongTaskTiming = exports.PerformanceLongTaskTiming = /*#__PURE__*/function (_PerformanceEntry2) {
+    function PerformanceLongTaskTiming() {
+      (0, _classCallCheck2.default)(this, PerformanceLongTaskTiming);
+      return _callSuper(this, PerformanceLongTaskTiming, arguments);
+    }
+    (0, _inherits2.default)(PerformanceLongTaskTiming, _PerformanceEntry2);
+    return (0, _createClass2.default)(PerformanceLongTaskTiming, [{
+      key: "attribution",
+      get: function get() {
+        return EMPTY_ATTRIBUTION;
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON() {
+        return Object.assign({}, _superPropGet(PerformanceLongTaskTiming, "toJSON", this, 3)([]), {
+          attribution: this.attribution
+        });
+      }
+    }]);
+  }(_$$_REQUIRE(_dependencyMap[7], "./PerformanceEntry").PerformanceEntry);
+},150,[1,21,12,11,18,20,23,146],"../../node_modules/react-native/src/private/webapis/performance/LongTasks.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _global;
+  if ((_global = global) != null && (_global = _global.HermesInternal) != null && _global.hasPromise != null && _global.hasPromise()) {
+    var HermesPromise = global.Promise;
+    if (__DEV__) {
+      var _global$HermesInterna;
+      if (typeof HermesPromise !== 'function') {
+        console.error('HermesPromise does not exist');
+      }
+      (_global$HermesInterna = global.HermesInternal) == null || _global$HermesInterna.enablePromiseRejectionTracker == null ? void 0 : _global$HermesInterna.enablePromiseRejectionTracker(_$$_REQUIRE(_dependencyMap[0], "../promiseRejectionTrackingOptions").default);
+    }
+  } else {
+    _$$_REQUIRE(_dependencyMap[1], "../Utilities/PolyfillFunctions").polyfillGlobal('Promise', function () {
+      return _$$_REQUIRE(_dependencyMap[2], "../Promise").default;
+    });
+  }
+},151,[152,114,189],"../../node_modules/react-native/Libraries/Core/polyfillPromise.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _LogBox = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./LogBox/LogBox"));
+  var rejectionTrackingOptions = {
+    allRejections: true,
+    onUnhandled: function onUnhandled(id) {
+      var rejection = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var message;
+      var stack;
+      var stringValue = Object.prototype.toString.call(rejection);
+      if (stringValue === '[object Error]') {
+        message = Error.prototype.toString.call(rejection);
+        var error = rejection;
+        stack = error.stack;
+      } else {
+        try {
+          message = _$$_REQUIRE(_dependencyMap[2], "pretty-format").format(rejection);
+        } catch (_unused) {
+          message = typeof rejection === 'string' ? rejection : JSON.stringify(rejection);
+        }
+        if (rejection != null && rejection.stack && typeof rejection.stack === 'string') {
+          stack = rejection.stack;
+        }
+      }
+      var warning = `Possible unhandled promise rejection (id: ${id}):\n${message != null ? message : ''}`;
+      if (__DEV__) {
+        _LogBox.default.addLog({
+          level: 'warn',
+          message: {
+            content: warning,
+            substitutions: []
+          },
+          componentStack: [],
+          componentStackType: null,
+          stack: stack,
+          category: 'possible_unhandled_promise_rejection'
+        });
+      } else {
+        console.warn(warning);
+      }
+    },
+    onHandled: function onHandled(id) {
+      var warning = `Promise rejection handled (id: ${id})\n` + 'This means you can ignore any previous messages of the form ' + `"Possible unhandled promise rejection (id: ${id}):"`;
+      console.warn(warning);
+    }
+  };
+  var _default = exports.default = rejectionTrackingOptions;
+},152,[1,153,184],"../../node_modules/react-native/Libraries/promiseRejectionTrackingOptions.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../Utilities/Platform"));
+  var _RCTLog = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../Utilities/RCTLog"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[3], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var LogBox;
+  if (__DEV__) {
+    var LogBoxData = _$$_REQUIRE(_dependencyMap[4], "./Data/LogBoxData");
+    var _require = _$$_REQUIRE(_dependencyMap[5], "./Data/parseLogBoxLog"),
+      parseLogBoxLog = _require.parseLogBoxLog,
+      parseInterpolation = _require.parseInterpolation;
+    var originalConsoleError;
+    var originalConsoleWarn;
+    var consoleErrorImpl;
+    var consoleWarnImpl;
+    var isLogBoxInstalled = false;
+    LogBox = {
+      install: function install() {
+        if (isLogBoxInstalled) {
+          return;
+        }
+        isLogBoxInstalled = true;
+        if (global.RN$registerExceptionListener != null) {
+          global.RN$registerExceptionListener(function (error) {
+            if (global.RN$isRuntimeReady != null && global.RN$isRuntimeReady() || !error.isFatal) {
+              error.preventDefault();
+              addException(error);
+            }
+          });
+        }
+        _$$_REQUIRE(_dependencyMap[6], "../NativeModules/specs/NativeLogBox");
+        var isFirstInstall = originalConsoleError == null;
+        if (isFirstInstall) {
+          originalConsoleError = console.error.bind(console);
+          originalConsoleWarn = console.warn.bind(console);
+          console.error = function () {
+            consoleErrorImpl.apply(void 0, arguments);
+          };
+          console.warn = function () {
+            consoleWarnImpl.apply(void 0, arguments);
+          };
+        }
+        consoleErrorImpl = registerError;
+        consoleWarnImpl = registerWarning;
+        if (_Platform.default.isTesting) {
+          LogBoxData.setDisabled(true);
+        }
+        _RCTLog.default.setWarningHandler(function () {
+          registerWarning.apply(void 0, arguments);
+        });
+      },
+      uninstall: function uninstall() {
+        if (!isLogBoxInstalled) {
+          return;
+        }
+        isLogBoxInstalled = false;
+        consoleErrorImpl = originalConsoleError;
+        consoleWarnImpl = originalConsoleWarn;
+      },
+      isInstalled: function isInstalled() {
+        return isLogBoxInstalled;
+      },
+      ignoreLogs: function ignoreLogs(patterns) {
+        LogBoxData.addIgnorePatterns(patterns);
+      },
+      ignoreAllLogs: function ignoreAllLogs(value) {
+        LogBoxData.setDisabled(value == null ? true : value);
+      },
+      clearAllLogs: function clearAllLogs() {
+        LogBoxData.clear();
+      },
+      addLog: function addLog(log) {
+        if (isLogBoxInstalled) {
+          LogBoxData.addLog(log);
+        }
+      },
+      addException: addException
+    };
+    function addException(error) {
+      if (isLogBoxInstalled) {
+        LogBoxData.addException(error);
+      }
+    }
+    var isRCTLogAdviceWarning = function isRCTLogAdviceWarning() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return typeof args[0] === 'string' && args[0].startsWith('(ADVICE)');
+    };
+    var isWarningModuleWarning = function isWarningModuleWarning() {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      return typeof args[0] === 'string' && args[0].startsWith('Warning: ');
+    };
+    var registerWarning = function registerWarning() {
+      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        args[_key3] = arguments[_key3];
+      }
+      if (LogBoxData.isLogBoxErrorMessage(String(args[0]))) {
+        originalConsoleError.apply(void 0, args);
+        return;
+      } else {
+        originalConsoleWarn.apply(void 0, args);
+      }
+      try {
+        if (!isRCTLogAdviceWarning.apply(void 0, args)) {
+          var _parseLogBoxLog = parseLogBoxLog(args),
+            category = _parseLogBoxLog.category,
+            message = _parseLogBoxLog.message,
+            componentStack = _parseLogBoxLog.componentStack,
+            componentStackType = _parseLogBoxLog.componentStackType;
+          if (!LogBoxData.isMessageIgnored(message.content)) {
+            LogBoxData.addLog({
+              level: 'warn',
+              category: category,
+              message: message,
+              componentStack: componentStack,
+              componentStackType: componentStackType
+            });
+          }
+        }
+      } catch (err) {
+        LogBoxData.reportLogBoxError(err);
+      }
+    };
+    var registerError = function registerError() {
+      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+        args[_key4] = arguments[_key4];
+      }
+      if (LogBoxData.isLogBoxErrorMessage(args[0])) {
+        originalConsoleError.apply(void 0, args);
+        return;
+      }
+      try {
+        var stack;
+        if (!(0, _$$_REQUIRE(_dependencyMap[7], "./Data/parseLogBoxLog").hasComponentStack)(args) && React.captureOwnerStack != null) {
+          stack = React.captureOwnerStack();
+          if (!(0, _$$_REQUIRE(_dependencyMap[7], "./Data/parseLogBoxLog").hasComponentStack)(args)) {
+            if (stack != null && stack !== '') {
+              args[0] = args[0] += '%s';
+              args.push(stack);
+            }
+          }
+        }
+        if (!isWarningModuleWarning.apply(void 0, args) && !(0, _$$_REQUIRE(_dependencyMap[7], "./Data/parseLogBoxLog").hasComponentStack)(args)) {
+          originalConsoleError.apply(void 0, args);
+          return;
+        }
+        var format = args[0].replace('Warning: ', '');
+        var filterResult = LogBoxData.checkWarningFilter(format);
+        var level = 'error';
+        if (filterResult.monitorEvent !== 'warning_unhandled') {
+          if (filterResult.suppressCompletely) {
+            return;
+          }
+          if (filterResult.suppressDialog_LEGACY === true) {
+            level = 'warn';
+          } else if (filterResult.forceDialogImmediately === true) {
+            level = 'fatal';
+          }
+        }
+        args[0] = `Warning: ${filterResult.finalFormat}`;
+        var _parseLogBoxLog2 = parseLogBoxLog(args),
+          category = _parseLogBoxLog2.category,
+          message = _parseLogBoxLog2.message,
+          componentStack = _parseLogBoxLog2.componentStack,
+          componentStackType = _parseLogBoxLog2.componentStackType;
+        var interpolated = parseInterpolation(args);
+        originalConsoleError(interpolated.message.content);
+        if (!LogBoxData.isMessageIgnored(message.content)) {
+          LogBoxData.addLog({
+            level: level,
+            category: category,
+            message: message,
+            componentStack: componentStack,
+            componentStackType: componentStackType
+          });
+        }
+      } catch (err) {
+        LogBoxData.reportLogBoxError(err);
+      }
+    };
+  } else {
+    LogBox = {
+      install: function install() {},
+      uninstall: function uninstall() {},
+      isInstalled: function isInstalled() {
+        return false;
+      },
+      ignoreLogs: function ignoreLogs(patterns) {},
+      ignoreAllLogs: function ignoreAllLogs(value) {},
+      clearAllLogs: function clearAllLogs() {},
+      addLog: function addLog(log) {},
+      addException: function addException(error) {}
+    };
+  }
+  var _default = exports.default = LogBox;
+},153,[1,68,154,73,155,181,162,181],"../../node_modules/react-native/Libraries/LogBox/LogBox.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var levelsMap = {
+    log: 'log',
+    info: 'info',
+    warn: 'warn',
+    error: 'error',
+    fatal: 'error'
+  };
+  var warningHandler = null;
+  var RCTLog = {
+    logIfNoNativeHook: function logIfNoNativeHook(level) {
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+      if (typeof global.nativeLoggingHook === 'undefined') {
+        RCTLog.logToConsole.apply(RCTLog, [level].concat(args));
+      } else {
+        if (warningHandler && level === 'warn') {
+          warningHandler.apply(void 0, args);
+        }
+      }
+    },
+    logToConsole: function logToConsole(level) {
+      var _console;
+      var logFn = levelsMap[level];
+      _$$_REQUIRE(_dependencyMap[0], "invariant")(logFn, 'Level "' + level + '" not one of ' + Object.keys(levelsMap).toString());
+      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+        args[_key2 - 1] = arguments[_key2];
+      }
+      (_console = console)[logFn].apply(_console, args);
+    },
+    setWarningHandler: function setWarningHandler(handler) {
+      warningHandler = handler;
+    }
+  };
+  var _default = exports.default = RCTLog;
+},154,[32],"../../node_modules/react-native/Libraries/Utilities/RCTLog.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.addException = addException;
+  exports.addIgnorePatterns = addIgnorePatterns;
+  exports.addLog = addLog;
+  exports.checkWarningFilter = checkWarningFilter;
+  exports.clear = clear;
+  exports.clearErrors = clearErrors;
+  exports.clearWarnings = clearWarnings;
+  exports.dismiss = dismiss;
+  exports.getAppInfo = getAppInfo;
+  exports.getIgnorePatterns = getIgnorePatterns;
+  exports.isDisabled = isDisabled;
+  exports.isLogBoxErrorMessage = isLogBoxErrorMessage;
+  exports.isMessageIgnored = isMessageIgnored;
+  exports.observe = observe;
+  exports.reportLogBoxError = reportLogBoxError;
+  exports.retrySymbolicateLogNow = retrySymbolicateLogNow;
+  exports.setAppInfo = setAppInfo;
+  exports.setDisabled = setDisabled;
+  exports.setSelectedLog = setSelectedLog;
+  exports.setWarningFilter = setWarningFilter;
+  exports.symbolicateLogLazy = symbolicateLogLazy;
+  exports.symbolicateLogNow = symbolicateLogNow;
+  exports.withSubscription = withSubscription;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var _FuseboxSessionObserver = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../../../src/private/devsupport/rndevtools/FuseboxSessionObserver"));
+  var _parseErrorStack = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../../Core/Devtools/parseErrorStack"));
+  var _NativeDevSettings = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../../NativeModules/specs/NativeDevSettings"));
+  var _NativeLogBox = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "../../NativeModules/specs/NativeLogBox"));
+  var _LogBoxLog = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./LogBoxLog"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[11], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[12], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/LogBox/Data/LogBoxData.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var observers = new Set();
+  var ignorePatterns = new Set();
+  var appInfo = null;
+  var logs = new Set();
+  var updateTimeout = null;
+  var _isDisabled = false;
+  var _selectedIndex = -1;
+  var hasShownFuseboxWarningsMigrationMessage = false;
+  var hostTargetSessionObserverSubscription = null;
+  var warningFilter = function warningFilter(format) {
+    return {
+      finalFormat: format,
+      forceDialogImmediately: false,
+      suppressDialog_LEGACY: false,
+      suppressCompletely: false,
+      monitorEvent: 'warning_unhandled',
+      monitorListVersion: 0,
+      monitorSampleRate: 1
+    };
+  };
+  var LOGBOX_ERROR_MESSAGE = 'An error was thrown when attempting to render log messages via LogBox.';
+  function getNextState() {
+    return {
+      logs: logs,
+      isDisabled: _isDisabled,
+      selectedLogIndex: _selectedIndex
+    };
+  }
+  function reportLogBoxError(error, componentStack) {
+    var ExceptionsManager = _$$_REQUIRE(_dependencyMap[13], "../../Core/ExceptionsManager").default;
+    error.message = `${LOGBOX_ERROR_MESSAGE}\n\n${error.message}`;
+    if (componentStack != null) {
+      error.componentStack = componentStack;
+    }
+    ExceptionsManager.handleException(error, true);
+  }
+  function isLogBoxErrorMessage(message) {
+    return typeof message === 'string' && message.includes(LOGBOX_ERROR_MESSAGE);
+  }
+  function isMessageIgnored(message) {
+    for (var pattern of ignorePatterns) {
+      if (pattern instanceof RegExp && pattern.test(message) || typeof pattern === 'string' && message.includes(pattern)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function handleUpdate() {
+    if (updateTimeout == null) {
+      updateTimeout = setImmediate(function () {
+        updateTimeout = null;
+        var nextState = getNextState();
+        observers.forEach(function (_ref) {
+          var observer = _ref.observer;
+          return observer(nextState);
+        });
+      });
+    }
+  }
+  function appendNewLog(newLog) {
+    if (isMessageIgnored(newLog.message.content)) {
+      return;
+    }
+    var lastLog = Array.from(logs).pop();
+    if (lastLog && lastLog.category === newLog.category) {
+      lastLog.incrementCount();
+      handleUpdate();
+      return;
+    }
+    if (newLog.level === 'fatal') {
+      var OPTIMISTIC_WAIT_TIME = 1000;
+      var _addPendingLog = function addPendingLog() {
+        logs.add(newLog);
+        if (_selectedIndex < 0) {
+          setSelectedLog(logs.size - 1);
+        } else {
+          handleUpdate();
+        }
+        _addPendingLog = null;
+      };
+      var optimisticTimeout = setTimeout(function () {
+        if (_addPendingLog) {
+          _addPendingLog();
+        }
+      }, OPTIMISTIC_WAIT_TIME);
+      newLog.symbolicate(function (status) {
+        if (_addPendingLog && status !== 'PENDING') {
+          _addPendingLog();
+          clearTimeout(optimisticTimeout);
+        } else if (status !== 'PENDING') {
+          handleUpdate();
+        }
+      });
+    } else if (newLog.level === 'syntax') {
+      logs.add(newLog);
+      setSelectedLog(logs.size - 1);
+    } else {
+      logs.add(newLog);
+      handleUpdate();
+    }
+  }
+  function addLog(log) {
+    if (hostTargetSessionObserverSubscription == null) {
+      hostTargetSessionObserverSubscription = _FuseboxSessionObserver.default.subscribe(function (hasActiveSession) {
+        if (hasActiveSession) {
+          clearWarnings();
+        } else {
+          hasShownFuseboxWarningsMigrationMessage = false;
+        }
+      });
+    }
+    if (log.level === 'warn' && global.__FUSEBOX_HAS_FULL_CONSOLE_SUPPORT__) {
+      if (!_FuseboxSessionObserver.default.hasActiveSession()) {
+        showFuseboxWarningsMigrationMessageOnce();
+      }
+      return;
+    }
+    var errorForStackTrace = new Error();
+    setImmediate(function () {
+      try {
+        var _log$stack;
+        var stack = (0, _parseErrorStack.default)((_log$stack = log.stack) != null ? _log$stack : errorForStackTrace == null ? void 0 : errorForStackTrace.stack);
+        appendNewLog(new _LogBoxLog.default({
+          level: log.level,
+          message: log.message,
+          isComponentError: false,
+          stack: stack,
+          category: log.category,
+          componentStack: log.componentStack,
+          componentStackType: log.componentStackType || 'legacy'
+        }));
+      } catch (error) {
+        reportLogBoxError(error);
+      }
+    });
+  }
+  function addException(error) {
+    setImmediate(function () {
+      try {
+        appendNewLog(new _LogBoxLog.default((0, _$$_REQUIRE(_dependencyMap[14], "./parseLogBoxLog").parseLogBoxException)(error)));
+      } catch (loggingError) {
+        reportLogBoxError(loggingError);
+      }
+    });
+  }
+  function symbolicateLogNow(log) {
+    log.symbolicate(function () {
+      handleUpdate();
+    });
+  }
+  function retrySymbolicateLogNow(log) {
+    log.retrySymbolicate(function () {
+      handleUpdate();
+    });
+  }
+  function symbolicateLogLazy(log) {
+    log.symbolicate();
+  }
+  function clear() {
+    if (logs.size > 0) {
+      logs = new Set();
+      setSelectedLog(-1);
+    }
+  }
+  function setSelectedLog(proposedNewIndex) {
+    var oldIndex = _selectedIndex;
+    var newIndex = proposedNewIndex;
+    var logArray = Array.from(logs);
+    var index = logArray.length - 1;
+    while (index >= 0) {
+      if (logArray[index].level === 'syntax') {
+        newIndex = index;
+        break;
+      }
+      index -= 1;
+    }
+    _selectedIndex = newIndex;
+    handleUpdate();
+    if (_NativeLogBox.default) {
+      setTimeout(function () {
+        if (oldIndex < 0 && newIndex >= 0) {
+          _NativeLogBox.default.show();
+        } else if (oldIndex >= 0 && newIndex < 0) {
+          _NativeLogBox.default.hide();
+        }
+      }, 0);
+    }
+  }
+  function clearWarnings() {
+    var newLogs = Array.from(logs).filter(function (log) {
+      return log.level !== 'warn';
+    });
+    if (newLogs.length !== logs.size) {
+      logs = new Set(newLogs);
+      setSelectedLog(-1);
+      handleUpdate();
+    }
+  }
+  function clearErrors() {
+    var newLogs = Array.from(logs).filter(function (log) {
+      return log.level !== 'error' && log.level !== 'fatal';
+    });
+    if (newLogs.length !== logs.size) {
+      logs = new Set(newLogs);
+      setSelectedLog(-1);
+    }
+  }
+  function dismiss(log) {
+    if (logs.has(log)) {
+      logs.delete(log);
+      handleUpdate();
+    }
+  }
+  function setWarningFilter(filter) {
+    warningFilter = filter;
+  }
+  function setAppInfo(info) {
+    appInfo = info;
+  }
+  function getAppInfo() {
+    return appInfo != null ? appInfo() : null;
+  }
+  function checkWarningFilter(format) {
+    return warningFilter(format);
+  }
+  function getIgnorePatterns() {
+    return Array.from(ignorePatterns);
+  }
+  function addIgnorePatterns(patterns) {
+    var existingSize = ignorePatterns.size;
+    patterns.forEach(function (pattern) {
+      if (pattern instanceof RegExp) {
+        for (var existingPattern of ignorePatterns) {
+          if (existingPattern instanceof RegExp && existingPattern.toString() === pattern.toString()) {
+            return;
+          }
+        }
+        ignorePatterns.add(pattern);
+      }
+      ignorePatterns.add(pattern);
+    });
+    if (ignorePatterns.size === existingSize) {
+      return;
+    }
+    logs = new Set(Array.from(logs).filter(function (log) {
+      return !isMessageIgnored(log.message.content);
+    }));
+    handleUpdate();
+  }
+  function setDisabled(value) {
+    if (value === _isDisabled) {
+      return;
+    }
+    _isDisabled = value;
+    handleUpdate();
+  }
+  function isDisabled() {
+    return _isDisabled;
+  }
+  function observe(observer) {
+    var subscription = {
+      observer: observer
+    };
+    observers.add(subscription);
+    observer(getNextState());
+    return {
+      unsubscribe: function unsubscribe() {
+        observers.delete(subscription);
+      }
+    };
+  }
+  function withSubscription(WrappedComponent) {
+    var LogBoxStateSubscription = /*#__PURE__*/function (_React$Component) {
+      function LogBoxStateSubscription() {
+        var _this;
+        (0, _classCallCheck2.default)(this, LogBoxStateSubscription);
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        _this = _callSuper(this, LogBoxStateSubscription, [].concat(args));
+        _this.state = {
+          logs: new Set(),
+          isDisabled: false,
+          hasError: false,
+          selectedLogIndex: -1
+        };
+        return _this;
+      }
+      (0, _inherits2.default)(LogBoxStateSubscription, _React$Component);
+      return (0, _createClass2.default)(LogBoxStateSubscription, [{
+        key: "componentDidCatch",
+        value: function componentDidCatch(err, errorInfo) {
+          reportLogBoxError(err, errorInfo.componentStack);
+        }
+      }, {
+        key: "render",
+        value: function render() {
+          if (this.state.hasError) {
+            return null;
+          }
+          return /*#__PURE__*/(0, _jsxRuntime.jsx)(WrappedComponent, {
+            logs: Array.from(this.state.logs),
+            isDisabled: this.state.isDisabled,
+            selectedLogIndex: this.state.selectedLogIndex
+          });
+        }
+      }, {
+        key: "componentDidMount",
+        value: function componentDidMount() {
+          var _this2 = this;
+          this._subscription = observe(function (data) {
+            _this2.setState(data);
+          });
+        }
+      }, {
+        key: "componentWillUnmount",
+        value: function componentWillUnmount() {
+          if (this._subscription != null) {
+            this._subscription.unsubscribe();
+          }
+        }
+      }], [{
+        key: "getDerivedStateFromError",
+        value: function getDerivedStateFromError() {
+          return {
+            hasError: true
+          };
+        }
+      }]);
+    }(React.Component);
+    return LogBoxStateSubscription;
+  }
+  function showFuseboxWarningsMigrationMessageOnce() {
+    if (hasShownFuseboxWarningsMigrationMessage) {
+      return;
+    }
+    hasShownFuseboxWarningsMigrationMessage = true;
+    appendNewLog(new _LogBoxLog.default({
+      level: 'warn',
+      message: {
+        content: 'Open debugger to view warnings.',
+        substitutions: []
+      },
+      isComponentError: false,
+      stack: [],
+      category: 'fusebox-warnings-migration',
+      componentStack: [],
+      onNotificationPress: function onNotificationPress() {
+        if (_NativeDevSettings.default.openDebugger) {
+          _NativeDevSettings.default.openDebugger();
+        }
+      }
+    }));
+  }
+},155,[1,11,12,18,20,23,156,157,160,162,164,73,171,174,181],"../../node_modules/react-native/Libraries/LogBox/Data/LogBoxData.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _classPrivateFieldLooseBase2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classPrivateFieldLooseBase"));
+  var _classPrivateFieldLooseKey2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classPrivateFieldLooseKey"));
+  var _hasNativeSupport = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("hasNativeSupport");
+  var FuseboxSessionObserver = /*#__PURE__*/function () {
+    function FuseboxSessionObserver() {
+      (0, _classCallCheck2.default)(this, FuseboxSessionObserver);
+      Object.defineProperty(this, _hasNativeSupport, {
+        writable: true,
+        value: void 0
+      });
+      (0, _classPrivateFieldLooseBase2.default)(this, _hasNativeSupport)[_hasNativeSupport] = global.hasOwnProperty('__DEBUGGER_SESSION_OBSERVER__');
+    }
+    return (0, _createClass2.default)(FuseboxSessionObserver, [{
+      key: "hasActiveSession",
+      value: function hasActiveSession() {
+        if (!(0, _classPrivateFieldLooseBase2.default)(this, _hasNativeSupport)[_hasNativeSupport]) {
+          return false;
+        }
+        return global.__DEBUGGER_SESSION_OBSERVER__.hasActiveSession;
+      }
+    }, {
+      key: "subscribe",
+      value: function subscribe(callback) {
+        if (!(0, _classPrivateFieldLooseBase2.default)(this, _hasNativeSupport)[_hasNativeSupport]) {
+          return function () {};
+        }
+        global.__DEBUGGER_SESSION_OBSERVER__.subscribers.add(callback);
+        return function () {
+          global.__DEBUGGER_SESSION_OBSERVER__.subscribers.delete(callback);
+        };
+      }
+    }]);
+  }();
+  var observerInstance = new FuseboxSessionObserver();
+  var _default = exports.default = observerInstance;
+},156,[1,11,12,26,27],"../../node_modules/react-native/src/private/devsupport/rndevtools/FuseboxSessionObserver.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = parseErrorStack;
+  function convertHermesStack(stack) {
+    var frames = [];
+    for (var entry of stack.entries) {
+      if (entry.type !== 'FRAME') {
+        continue;
+      }
+      var location = entry.location,
+        functionName = entry.functionName;
+      if (location.type === 'NATIVE' || location.type === 'INTERNAL_BYTECODE') {
+        continue;
+      }
+      frames.push({
+        methodName: functionName,
+        file: location.sourceUrl,
+        lineNumber: location.line1Based,
+        column: location.type === 'SOURCE' ? location.column1Based - 1 : location.virtualOffset0Based
+      });
+    }
+    return frames;
+  }
+  function parseErrorStack(errorStack) {
+    if (errorStack == null) {
+      return [];
+    }
+    var stacktraceParser = _$$_REQUIRE(_dependencyMap[0], "stacktrace-parser");
+    var parsedStack = Array.isArray(errorStack) ? errorStack : global.HermesInternal ? convertHermesStack(_$$_REQUIRE(_dependencyMap[1], "./parseHermesStack").default(errorStack)) : stacktraceParser.parse(errorStack).map(function (frame) {
+      return Object.assign({}, frame, {
+        column: frame.column != null ? frame.column - 1 : null
+      });
+    });
+    return parsedStack;
+  }
+},157,[158,159],"../../node_modules/react-native/Libraries/Core/Devtools/parseErrorStack.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, '__esModule', {
+    value: true
+  });
+  var UNKNOWN_FUNCTION = '<unknown>';
+  /**
+   * This parses the different stack traces and puts them into one format
+   * This borrows heavily from TraceKit (https://github.com/csnover/TraceKit)
+   */
+
+  function parse(stackString) {
+    var lines = stackString.split('\n');
+    return lines.reduce(function (stack, line) {
+      var parseResult = parseChrome(line) || parseWinjs(line) || parseGecko(line) || parseNode(line) || parseJSC(line);
+      if (parseResult) {
+        stack.push(parseResult);
+      }
+      return stack;
+    }, []);
+  }
+  var chromeRe = /^\s*at (.*?) ?\(((?:file|https?|blob|chrome-extension|native|eval|webpack|rsc|<anonymous>|\/|[a-z]:\\|\\\\).*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i;
+  var chromeEvalRe = /\((\S*)(?::(\d+))(?::(\d+))\)/;
+  function parseChrome(line) {
+    var parts = chromeRe.exec(line);
+    if (!parts) {
+      return null;
+    }
+    var isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line
+
+    var isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line
+
+    var submatch = chromeEvalRe.exec(parts[2]);
+    if (isEval && submatch != null) {
+      // throw out eval line/column and use top-most line/column number
+      parts[2] = submatch[1]; // url
+
+      parts[3] = submatch[2]; // line
+
+      parts[4] = submatch[3]; // column
+    }
+    return {
+      file: !isNative ? parts[2] : null,
+      methodName: parts[1] || UNKNOWN_FUNCTION,
+      arguments: isNative ? [parts[2]] : [],
+      lineNumber: parts[3] ? +parts[3] : null,
+      column: parts[4] ? +parts[4] : null
+    };
+  }
+  var winjsRe = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:file|ms-appx|https?|webpack|rsc|blob):.*?):(\d+)(?::(\d+))?\)?\s*$/i;
+  function parseWinjs(line) {
+    var parts = winjsRe.exec(line);
+    if (!parts) {
+      return null;
+    }
+    return {
+      file: parts[2],
+      methodName: parts[1] || UNKNOWN_FUNCTION,
+      arguments: [],
+      lineNumber: +parts[3],
+      column: parts[4] ? +parts[4] : null
+    };
+  }
+  var geckoRe = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)((?:file|https?|blob|chrome|webpack|rsc|resource|\[native).*?|[^@]*bundle)(?::(\d+))?(?::(\d+))?\s*$/i;
+  var geckoEvalRe = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i;
+  function parseGecko(line) {
+    var parts = geckoRe.exec(line);
+    if (!parts) {
+      return null;
+    }
+    var isEval = parts[3] && parts[3].indexOf(' > eval') > -1;
+    var submatch = geckoEvalRe.exec(parts[3]);
+    if (isEval && submatch != null) {
+      // throw out eval line/column and use top-most line number
+      parts[3] = submatch[1];
+      parts[4] = submatch[2];
+      parts[5] = null; // no column when eval
+    }
+    return {
+      file: parts[3],
+      methodName: parts[1] || UNKNOWN_FUNCTION,
+      arguments: parts[2] ? parts[2].split(',') : [],
+      lineNumber: parts[4] ? +parts[4] : null,
+      column: parts[5] ? +parts[5] : null
+    };
+  }
+  var javaScriptCoreRe = /^\s*(?:([^@]*)(?:\((.*?)\))?@)?(\S.*?):(\d+)(?::(\d+))?\s*$/i;
+  function parseJSC(line) {
+    var parts = javaScriptCoreRe.exec(line);
+    if (!parts) {
+      return null;
+    }
+    return {
+      file: parts[3],
+      methodName: parts[1] || UNKNOWN_FUNCTION,
+      arguments: [],
+      lineNumber: +parts[4],
+      column: parts[5] ? +parts[5] : null
+    };
+  }
+  var nodeRe = /^\s*at (?:((?:\[object object\])?[^\\/]+(?: \[as \S+\])?) )?\(?(.*?):(\d+)(?::(\d+))?\)?\s*$/i;
+  function parseNode(line) {
+    var parts = nodeRe.exec(line);
+    if (!parts) {
+      return null;
+    }
+    return {
+      file: parts[2],
+      methodName: parts[1] || UNKNOWN_FUNCTION,
+      arguments: [],
+      lineNumber: +parts[3],
+      column: parts[4] ? +parts[4] : null
+    };
+  }
+  exports.parse = parse;
+},158,[],"../../node_modules/stacktrace-parser/dist/stack-trace-parser.cjs.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = parseHermesStack;
+  var RE_FRAME = /^ {4}at (.+?)(?: \((native)\)?| \((address at )?(.*?):(\d+):(\d+)\))$/;
+  var RE_SKIPPED = /^ {4}... skipping (\d+) frames$/;
+  var RE_COMPONENT_NO_STACK = /^ {4}at .*$/;
+  function isInternalBytecodeSourceUrl(sourceUrl) {
+    return sourceUrl === 'InternalBytecode.js';
+  }
+  function parseLine(line) {
+    var asFrame = line.match(RE_FRAME);
+    if (asFrame) {
+      return {
+        type: 'FRAME',
+        functionName: asFrame[1],
+        location: asFrame[2] === 'native' ? {
+          type: 'NATIVE'
+        } : asFrame[3] === 'address at ' ? isInternalBytecodeSourceUrl(asFrame[4]) ? {
+          type: 'INTERNAL_BYTECODE',
+          sourceUrl: asFrame[4],
+          line1Based: Number.parseInt(asFrame[5], 10),
+          virtualOffset0Based: Number.parseInt(asFrame[6], 10)
+        } : {
+          type: 'BYTECODE',
+          sourceUrl: asFrame[4],
+          line1Based: Number.parseInt(asFrame[5], 10),
+          virtualOffset0Based: Number.parseInt(asFrame[6], 10)
+        } : {
+          type: 'SOURCE',
+          sourceUrl: asFrame[4],
+          line1Based: Number.parseInt(asFrame[5], 10),
+          column1Based: Number.parseInt(asFrame[6], 10)
+        }
+      };
+    }
+    var asSkipped = line.match(RE_SKIPPED);
+    if (asSkipped) {
+      return {
+        type: 'SKIPPED',
+        count: Number.parseInt(asSkipped[1], 10)
+      };
+    }
+  }
+  function parseHermesStack(stack) {
+    var lines = stack.split(/\n/);
+    var entries = [];
+    var lastMessageLine = -1;
+    for (var i = 0; i < lines.length; ++i) {
+      var line = lines[i];
+      if (!line) {
+        continue;
+      }
+      var entry = parseLine(line);
+      if (entry) {
+        entries.push(entry);
+        continue;
+      }
+      if (RE_COMPONENT_NO_STACK.test(line)) {
+        continue;
+      }
+      lastMessageLine = i;
+      entries = [];
+    }
+    var message = lines.slice(0, lastMessageLine + 1).join('\n');
+    return {
+      message: message,
+      entries: entries
+    };
+  }
+},159,[],"../../node_modules/react-native/Libraries/Core/Devtools/parseHermesStack.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeDevSettings = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../src/private/specs_DEPRECATED/modules/NativeDevSettings"));
+  Object.keys(_NativeDevSettings).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeDevSettings[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeDevSettings[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeDevSettings.default;
+},160,[161],"../../node_modules/react-native/Libraries/NativeModules/specs/NativeDevSettings.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.getEnforcing('DevSettings');
+},161,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeDevSettings.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeLogBox = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../src/private/specs_DEPRECATED/modules/NativeLogBox"));
+  Object.keys(_NativeLogBox).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeLogBox[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeLogBox[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeLogBox.default;
+},162,[163],"../../node_modules/react-native/Libraries/NativeModules/specs/NativeLogBox.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.get('LogBox');
+},163,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeLogBox.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var LogBoxSymbolication = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[3], "./LogBoxSymbolication"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function convertComponentStateToStack(componentStack) {
+    return componentStack.map(function (frame) {
+      var _frame$location, _frame$location2;
+      return {
+        column: frame == null || (_frame$location = frame.location) == null ? void 0 : _frame$location.column,
+        file: frame.fileName,
+        lineNumber: frame == null || (_frame$location2 = frame.location) == null ? void 0 : _frame$location2.row,
+        methodName: frame.content,
+        collapse: false
+      };
+    });
+  }
+  function convertStackToComponentStack(stack) {
+    var componentStack = [];
+    for (var i = 0; i < stack.length; i++) {
+      var frame = stack[i];
+      if (frame.lineNumber != null && frame.column != null) {
+        componentStack.push({
+          fileName: (frame == null ? void 0 : frame.file) || '',
+          location: {
+            row: frame.lineNumber,
+            column: frame.column
+          },
+          content: frame.methodName,
+          collapse: false
+        });
+      }
+    }
+    return componentStack;
+  }
+  var LogBoxLog = /*#__PURE__*/function () {
+    function LogBoxLog(data) {
+      (0, _classCallCheck2.default)(this, LogBoxLog);
+      this.symbolicated = {
+        error: null,
+        stack: null,
+        status: 'NONE'
+      };
+      this.symbolicatedComponentStack = {
+        error: null,
+        componentStack: null,
+        status: 'NONE'
+      };
+      this.level = data.level;
+      this.type = data.type;
+      this.message = data.message;
+      this.stack = data.stack;
+      this.category = data.category;
+      this.componentStack = data.componentStack;
+      this.componentStackType = data.componentStackType || 'legacy';
+      this.codeFrame = data.codeFrame;
+      this.isComponentError = data.isComponentError;
+      this.extraData = data.extraData;
+      this.count = 1;
+      this.onNotificationPress = data.onNotificationPress;
+    }
+    return (0, _createClass2.default)(LogBoxLog, [{
+      key: "incrementCount",
+      value: function incrementCount() {
+        this.count += 1;
+      }
+    }, {
+      key: "getAvailableStack",
+      value: function getAvailableStack() {
+        return this.symbolicated.status === 'COMPLETE' ? this.symbolicated.stack : this.stack;
+      }
+    }, {
+      key: "getAvailableComponentStack",
+      value: function getAvailableComponentStack() {
+        if (this.componentStackType === 'legacy') {
+          return this.componentStack;
+        }
+        return this.symbolicatedComponentStack.status === 'COMPLETE' ? this.symbolicatedComponentStack.componentStack : this.componentStack;
+      }
+    }, {
+      key: "retrySymbolicate",
+      value: function retrySymbolicate(callback) {
+        var retry = false;
+        if (this.symbolicated.status !== 'COMPLETE') {
+          LogBoxSymbolication.deleteStack(this.stack);
+          retry = true;
+        }
+        if (this.symbolicatedComponentStack.status !== 'COMPLETE') {
+          LogBoxSymbolication.deleteStack(convertComponentStateToStack(this.componentStack));
+          retry = true;
+        }
+        if (retry) {
+          this.handleSymbolicate(callback);
+        }
+      }
+    }, {
+      key: "symbolicate",
+      value: function symbolicate(callback) {
+        if (this.symbolicated.status === 'NONE') {
+          this.handleSymbolicate(callback);
+        }
+      }
+    }, {
+      key: "handleSymbolicate",
+      value: function handleSymbolicate(callback) {
+        var _this = this;
+        if (this.symbolicated.status !== 'PENDING' && this.symbolicated.status !== 'COMPLETE') {
+          this.updateStatus(null, null, null, callback);
+          LogBoxSymbolication.symbolicate(this.stack, this.extraData).then(function (data) {
+            _this.updateStatus(null, data == null ? void 0 : data.stack, data == null ? void 0 : data.codeFrame, callback);
+          }, function (error) {
+            _this.updateStatus(error, null, null, callback);
+          });
+        }
+        if (this.componentStack != null && this.componentStackType === 'stack' && this.symbolicatedComponentStack.status !== 'PENDING' && this.symbolicatedComponentStack.status !== 'COMPLETE') {
+          this.updateComponentStackStatus(null, null, null, callback);
+          var componentStackFrames = convertComponentStateToStack(this.componentStack);
+          LogBoxSymbolication.symbolicate(componentStackFrames, []).then(function (data) {
+            _this.updateComponentStackStatus(null, convertStackToComponentStack(data.stack), data == null ? void 0 : data.codeFrame, callback);
+          }, function (error) {
+            _this.updateComponentStackStatus(error, null, null, callback);
+          });
+        }
+      }
+    }, {
+      key: "updateStatus",
+      value: function updateStatus(error, stack, codeFrame, callback) {
+        var lastStatus = this.symbolicated.status;
+        if (error != null) {
+          this.symbolicated = {
+            error: error,
+            stack: null,
+            status: 'FAILED'
+          };
+        } else if (stack != null) {
+          if (codeFrame) {
+            this.codeFrame = codeFrame;
+          }
+          this.symbolicated = {
+            error: null,
+            stack: stack,
+            status: 'COMPLETE'
+          };
+        } else {
+          this.symbolicated = {
+            error: null,
+            stack: null,
+            status: 'PENDING'
+          };
+        }
+        if (callback && lastStatus !== this.symbolicated.status) {
+          callback(this.symbolicated.status);
+        }
+      }
+    }, {
+      key: "updateComponentStackStatus",
+      value: function updateComponentStackStatus(error, componentStack, codeFrame, callback) {
+        var lastStatus = this.symbolicatedComponentStack.status;
+        if (error != null) {
+          this.symbolicatedComponentStack = {
+            error: error,
+            componentStack: null,
+            status: 'FAILED'
+          };
+        } else if (componentStack != null) {
+          if (codeFrame) {
+            this.componentCodeFrame = codeFrame;
+          }
+          this.symbolicatedComponentStack = {
+            error: null,
+            componentStack: componentStack,
+            status: 'COMPLETE'
+          };
+        } else {
+          this.symbolicatedComponentStack = {
+            error: null,
+            componentStack: null,
+            status: 'PENDING'
+          };
+        }
+        if (callback && lastStatus !== this.symbolicatedComponentStack.status) {
+          callback(this.symbolicatedComponentStack.status);
+        }
+      }
+    }]);
+  }();
+  var _default = exports.default = LogBoxLog;
+},164,[1,11,12,165],"../../node_modules/react-native/Libraries/LogBox/Data/LogBoxLog.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.deleteStack = deleteStack;
+  exports.symbolicate = symbolicate;
+  var _symbolicateStackTrace = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Core/Devtools/symbolicateStackTrace"));
+  var cache = new Map();
+  var sanitize = function sanitize(_ref) {
+    var maybeStack = _ref.stack,
+      codeFrame = _ref.codeFrame;
+    if (!Array.isArray(maybeStack)) {
+      throw new Error('Expected stack to be an array.');
+    }
+    var stack = [];
+    for (var maybeFrame of maybeStack) {
+      var collapse = false;
+      if ('collapse' in maybeFrame) {
+        if (typeof maybeFrame.collapse !== 'boolean') {
+          throw new Error('Expected stack frame `collapse` to be a boolean.');
+        }
+        collapse = maybeFrame.collapse;
+      }
+      stack.push({
+        column: maybeFrame.column,
+        file: maybeFrame.file,
+        lineNumber: maybeFrame.lineNumber,
+        methodName: maybeFrame.methodName,
+        collapse: collapse
+      });
+    }
+    return {
+      stack: stack,
+      codeFrame: codeFrame
+    };
+  };
+  function deleteStack(stack) {
+    cache.delete(stack);
+  }
+  function symbolicate(stack, extraData) {
+    var promise = cache.get(stack);
+    if (promise == null) {
+      promise = (0, _symbolicateStackTrace.default)(stack, extraData).then(sanitize);
+      cache.set(stack, promise);
+    }
+    return promise;
+  }
+},165,[1,166],"../../node_modules/react-native/Libraries/LogBox/Data/LogBoxSymbolication.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = symbolicateStackTrace;
+  var _asyncToGenerator2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/asyncToGenerator"));
+  function symbolicateStackTrace(_x, _x2) {
+    return _symbolicateStackTrace.apply(this, arguments);
+  }
+  function _symbolicateStackTrace() {
+    _symbolicateStackTrace = (0, _asyncToGenerator2.default)(function* (stack, extraData) {
+      var _global$fetch;
+      var devServer = _$$_REQUIRE(_dependencyMap[2], "./getDevServer").default();
+      if (!devServer.bundleLoadedFromServer) {
+        throw new Error('Bundle was not loaded from Metro.');
+      }
+      var fetch = (_global$fetch = global.fetch) != null ? _global$fetch : _$$_REQUIRE(_dependencyMap[3], "../../Network/fetch").fetch;
+      var response = yield fetch(devServer.url + 'symbolicate', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          stack: stack,
+          extraData: extraData
+        })
+      });
+      return yield response.json();
+    });
+    return _symbolicateStackTrace.apply(this, arguments);
+  }
+},166,[1,167,168,169],"../../node_modules/react-native/Libraries/Core/Devtools/symbolicateStackTrace.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function asyncGeneratorStep(n, t, e, r, o, a, c) {
+    try {
+      var i = n[a](c),
+        u = i.value;
+    } catch (n) {
+      return void e(n);
+    }
+    i.done ? t(u) : Promise.resolve(u).then(r, o);
+  }
+  function _asyncToGenerator(n) {
+    return function () {
+      var t = this,
+        e = arguments;
+      return new Promise(function (r, o) {
+        var a = n.apply(t, e);
+        function _next(n) {
+          asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+        }
+        function _throw(n) {
+          asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+        }
+        _next(void 0);
+      });
+    };
+  }
+  module.exports = _asyncToGenerator, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},167,[],"../../node_modules/@babel/runtime/helpers/asyncToGenerator.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = getDevServer;
+  var _NativeSourceCode = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../NativeModules/specs/NativeSourceCode"));
+  var _cachedDevServerURL;
+  var _cachedFullBundleURL;
+  var FALLBACK = 'http://localhost:8081/';
+  function getDevServer() {
+    if (_cachedDevServerURL === undefined) {
+      var scriptUrl = _NativeSourceCode.default.getConstants().scriptURL;
+      var match = scriptUrl.match(/^https?:\/\/.*?\//);
+      _cachedDevServerURL = match ? match[0] : null;
+      _cachedFullBundleURL = match ? scriptUrl : null;
+    }
+    return {
+      url: _cachedDevServerURL != null ? _cachedDevServerURL : FALLBACK,
+      fullBundleUrl: _cachedFullBundleURL,
+      bundleLoadedFromServer: _cachedDevServerURL !== null
+    };
+  }
+},168,[1,93],"../../node_modules/react-native/Libraries/Core/Devtools/getDevServer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.fetch = exports.Response = exports.Request = exports.Headers = void 0;
+  _$$_REQUIRE(_dependencyMap[0], "whatwg-fetch");
+  var fetch = exports.fetch = global.fetch;
+  var Headers = exports.Headers = global.Headers;
+  var Request = exports.Request = global.Request;
+  var Response = exports.Response = global.Response;
+},169,[170],"../../node_modules/react-native/Libraries/Network/fetch.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  (function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'], factory) : factory(global.WHATWGFetch = {});
+  })(this, function (exports) {
+    'use strict';
+
+    /* eslint-disable no-prototype-builtins */
+    var g = typeof globalThis !== 'undefined' && globalThis || typeof self !== 'undefined' && self ||
+    // eslint-disable-next-line no-undef
+    typeof global !== 'undefined' && global || {};
+    var support = {
+      searchParams: 'URLSearchParams' in g,
+      iterable: 'Symbol' in g && 'iterator' in Symbol,
+      blob: 'FileReader' in g && 'Blob' in g && function () {
+        try {
+          new Blob();
+          return true;
+        } catch (e) {
+          return false;
+        }
+      }(),
+      formData: 'FormData' in g,
+      arrayBuffer: 'ArrayBuffer' in g
+    };
+    function isDataView(obj) {
+      return obj && DataView.prototype.isPrototypeOf(obj);
+    }
+    if (support.arrayBuffer) {
+      var viewClasses = ['[object Int8Array]', '[object Uint8Array]', '[object Uint8ClampedArray]', '[object Int16Array]', '[object Uint16Array]', '[object Int32Array]', '[object Uint32Array]', '[object Float32Array]', '[object Float64Array]'];
+      var isArrayBufferView = ArrayBuffer.isView || function (obj) {
+        return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1;
+      };
+    }
+    function normalizeName(name) {
+      if (typeof name !== 'string') {
+        name = String(name);
+      }
+      if (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === '') {
+        throw new TypeError('Invalid character in header field name: "' + name + '"');
+      }
+      return name.toLowerCase();
+    }
+    function normalizeValue(value) {
+      if (typeof value !== 'string') {
+        value = String(value);
+      }
+      return value;
+    }
+
+    // Build a destructive iterator for the value list
+    function iteratorFor(items) {
+      var iterator = {
+        next: function next() {
+          var value = items.shift();
+          return {
+            done: value === undefined,
+            value: value
+          };
+        }
+      };
+      if (support.iterable) {
+        iterator[Symbol.iterator] = function () {
+          return iterator;
+        };
+      }
+      return iterator;
+    }
+    function Headers(headers) {
+      this.map = {};
+      if (headers instanceof Headers) {
+        headers.forEach(function (value, name) {
+          this.append(name, value);
+        }, this);
+      } else if (Array.isArray(headers)) {
+        headers.forEach(function (header) {
+          if (header.length != 2) {
+            throw new TypeError('Headers constructor: expected name/value pair to be length 2, found' + header.length);
+          }
+          this.append(header[0], header[1]);
+        }, this);
+      } else if (headers) {
+        Object.getOwnPropertyNames(headers).forEach(function (name) {
+          this.append(name, headers[name]);
+        }, this);
+      }
+    }
+    Headers.prototype.append = function (name, value) {
+      name = normalizeName(name);
+      value = normalizeValue(value);
+      var oldValue = this.map[name];
+      this.map[name] = oldValue ? oldValue + ', ' + value : value;
+    };
+    Headers.prototype['delete'] = function (name) {
+      delete this.map[normalizeName(name)];
+    };
+    Headers.prototype.get = function (name) {
+      name = normalizeName(name);
+      return this.has(name) ? this.map[name] : null;
+    };
+    Headers.prototype.has = function (name) {
+      return this.map.hasOwnProperty(normalizeName(name));
+    };
+    Headers.prototype.set = function (name, value) {
+      this.map[normalizeName(name)] = normalizeValue(value);
+    };
+    Headers.prototype.forEach = function (callback, thisArg) {
+      for (var name in this.map) {
+        if (this.map.hasOwnProperty(name)) {
+          callback.call(thisArg, this.map[name], name, this);
+        }
+      }
+    };
+    Headers.prototype.keys = function () {
+      var items = [];
+      this.forEach(function (value, name) {
+        items.push(name);
+      });
+      return iteratorFor(items);
+    };
+    Headers.prototype.values = function () {
+      var items = [];
+      this.forEach(function (value) {
+        items.push(value);
+      });
+      return iteratorFor(items);
+    };
+    Headers.prototype.entries = function () {
+      var items = [];
+      this.forEach(function (value, name) {
+        items.push([name, value]);
+      });
+      return iteratorFor(items);
+    };
+    if (support.iterable) {
+      Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
+    }
+    function consumed(body) {
+      if (body._noBody) return;
+      if (body.bodyUsed) {
+        return Promise.reject(new TypeError('Already read'));
+      }
+      body.bodyUsed = true;
+    }
+    function fileReaderReady(reader) {
+      return new Promise(function (resolve, reject) {
+        reader.onload = function () {
+          resolve(reader.result);
+        };
+        reader.onerror = function () {
+          reject(reader.error);
+        };
+      });
+    }
+    function readBlobAsArrayBuffer(blob) {
+      var reader = new FileReader();
+      var promise = fileReaderReady(reader);
+      reader.readAsArrayBuffer(blob);
+      return promise;
+    }
+    function readBlobAsText(blob) {
+      var reader = new FileReader();
+      var promise = fileReaderReady(reader);
+      var match = /charset=([A-Za-z0-9_-]+)/.exec(blob.type);
+      var encoding = match ? match[1] : 'utf-8';
+      reader.readAsText(blob, encoding);
+      return promise;
+    }
+    function readArrayBufferAsText(buf) {
+      var view = new Uint8Array(buf);
+      var chars = new Array(view.length);
+      for (var i = 0; i < view.length; i++) {
+        chars[i] = String.fromCharCode(view[i]);
+      }
+      return chars.join('');
+    }
+    function bufferClone(buf) {
+      if (buf.slice) {
+        return buf.slice(0);
+      } else {
+        var view = new Uint8Array(buf.byteLength);
+        view.set(new Uint8Array(buf));
+        return view.buffer;
+      }
+    }
+    function Body() {
+      this.bodyUsed = false;
+      this._initBody = function (body) {
+        /*
+          fetch-mock wraps the Response object in an ES6 Proxy to
+          provide useful test harness features such as flush. However, on
+          ES5 browsers without fetch or Proxy support pollyfills must be used;
+          the proxy-pollyfill is unable to proxy an attribute unless it exists
+          on the object before the Proxy is created. This change ensures
+          Response.bodyUsed exists on the instance, while maintaining the
+          semantic of setting Request.bodyUsed in the constructor before
+          _initBody is called.
+        */
+        // eslint-disable-next-line no-self-assign
+        this.bodyUsed = this.bodyUsed;
+        this._bodyInit = body;
+        if (!body) {
+          this._noBody = true;
+          this._bodyText = '';
+        } else if (typeof body === 'string') {
+          this._bodyText = body;
+        } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
+          this._bodyBlob = body;
+        } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
+          this._bodyFormData = body;
+        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+          this._bodyText = body.toString();
+        } else if (support.arrayBuffer && support.blob && isDataView(body)) {
+          this._bodyArrayBuffer = bufferClone(body.buffer);
+          // IE 10-11 can't handle a DataView body.
+          this._bodyInit = new Blob([this._bodyArrayBuffer]);
+        } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
+          this._bodyArrayBuffer = bufferClone(body);
+        } else {
+          this._bodyText = body = Object.prototype.toString.call(body);
+        }
+        if (!this.headers.get('content-type')) {
+          if (typeof body === 'string') {
+            this.headers.set('content-type', 'text/plain;charset=UTF-8');
+          } else if (this._bodyBlob && this._bodyBlob.type) {
+            this.headers.set('content-type', this._bodyBlob.type);
+          } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+            this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
+          }
+        }
+      };
+      if (support.blob) {
+        this.blob = function () {
+          var rejected = consumed(this);
+          if (rejected) {
+            return rejected;
+          }
+          if (this._bodyBlob) {
+            return Promise.resolve(this._bodyBlob);
+          } else if (this._bodyArrayBuffer) {
+            return Promise.resolve(new Blob([this._bodyArrayBuffer]));
+          } else if (this._bodyFormData) {
+            throw new Error('could not read FormData body as blob');
+          } else {
+            return Promise.resolve(new Blob([this._bodyText]));
+          }
+        };
+      }
+      this.arrayBuffer = function () {
+        if (this._bodyArrayBuffer) {
+          var isConsumed = consumed(this);
+          if (isConsumed) {
+            return isConsumed;
+          } else if (ArrayBuffer.isView(this._bodyArrayBuffer)) {
+            return Promise.resolve(this._bodyArrayBuffer.buffer.slice(this._bodyArrayBuffer.byteOffset, this._bodyArrayBuffer.byteOffset + this._bodyArrayBuffer.byteLength));
+          } else {
+            return Promise.resolve(this._bodyArrayBuffer);
+          }
+        } else if (support.blob) {
+          return this.blob().then(readBlobAsArrayBuffer);
+        } else {
+          throw new Error('could not read as ArrayBuffer');
+        }
+      };
+      this.text = function () {
+        var rejected = consumed(this);
+        if (rejected) {
+          return rejected;
+        }
+        if (this._bodyBlob) {
+          return readBlobAsText(this._bodyBlob);
+        } else if (this._bodyArrayBuffer) {
+          return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer));
+        } else if (this._bodyFormData) {
+          throw new Error('could not read FormData body as text');
+        } else {
+          return Promise.resolve(this._bodyText);
+        }
+      };
+      if (support.formData) {
+        this.formData = function () {
+          return this.text().then(decode);
+        };
+      }
+      this.json = function () {
+        return this.text().then(JSON.parse);
+      };
+      return this;
+    }
+
+    // HTTP methods whose capitalization should be normalized
+    var methods = ['CONNECT', 'DELETE', 'GET', 'HEAD', 'OPTIONS', 'PATCH', 'POST', 'PUT', 'TRACE'];
+    function normalizeMethod(method) {
+      var upcased = method.toUpperCase();
+      return methods.indexOf(upcased) > -1 ? upcased : method;
+    }
+    function Request(input, options) {
+      if (!(this instanceof Request)) {
+        throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.');
+      }
+      options = options || {};
+      var body = options.body;
+      if (input instanceof Request) {
+        if (input.bodyUsed) {
+          throw new TypeError('Already read');
+        }
+        this.url = input.url;
+        this.credentials = input.credentials;
+        if (!options.headers) {
+          this.headers = new Headers(input.headers);
+        }
+        this.method = input.method;
+        this.mode = input.mode;
+        this.signal = input.signal;
+        if (!body && input._bodyInit != null) {
+          body = input._bodyInit;
+          input.bodyUsed = true;
+        }
+      } else {
+        this.url = String(input);
+      }
+      this.credentials = options.credentials || this.credentials || 'same-origin';
+      if (options.headers || !this.headers) {
+        this.headers = new Headers(options.headers);
+      }
+      this.method = normalizeMethod(options.method || this.method || 'GET');
+      this.mode = options.mode || this.mode || null;
+      this.signal = options.signal || this.signal || function () {
+        if ('AbortController' in g) {
+          var ctrl = new AbortController();
+          return ctrl.signal;
+        }
+      }();
+      this.referrer = null;
+      if ((this.method === 'GET' || this.method === 'HEAD') && body) {
+        throw new TypeError('Body not allowed for GET or HEAD requests');
+      }
+      this._initBody(body);
+      if (this.method === 'GET' || this.method === 'HEAD') {
+        if (options.cache === 'no-store' || options.cache === 'no-cache') {
+          // Search for a '_' parameter in the query string
+          var reParamSearch = /([?&])_=[^&]*/;
+          if (reParamSearch.test(this.url)) {
+            // If it already exists then set the value with the current time
+            this.url = this.url.replace(reParamSearch, '$1_=' + new Date().getTime());
+          } else {
+            // Otherwise add a new '_' parameter to the end with the current time
+            var reQueryString = /\?/;
+            this.url += (reQueryString.test(this.url) ? '&' : '?') + '_=' + new Date().getTime();
+          }
+        }
+      }
+    }
+    Request.prototype.clone = function () {
+      return new Request(this, {
+        body: this._bodyInit
+      });
+    };
+    function decode(body) {
+      var form = new FormData();
+      body.trim().split('&').forEach(function (bytes) {
+        if (bytes) {
+          var split = bytes.split('=');
+          var name = split.shift().replace(/\+/g, ' ');
+          var value = split.join('=').replace(/\+/g, ' ');
+          form.append(decodeURIComponent(name), decodeURIComponent(value));
+        }
+      });
+      return form;
+    }
+    function parseHeaders(rawHeaders) {
+      var headers = new Headers();
+      // Replace instances of \r\n and \n followed by at least one space or horizontal tab with a space
+      // https://tools.ietf.org/html/rfc7230#section-3.2
+      var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, ' ');
+      // Avoiding split via regex to work around a common IE11 bug with the core-js 3.6.0 regex polyfill
+      // https://github.com/github/fetch/issues/748
+      // https://github.com/zloirock/core-js/issues/751
+      preProcessedHeaders.split('\r').map(function (header) {
+        return header.indexOf('\n') === 0 ? header.substr(1, header.length) : header;
+      }).forEach(function (line) {
+        var parts = line.split(':');
+        var key = parts.shift().trim();
+        if (key) {
+          var value = parts.join(':').trim();
+          try {
+            headers.append(key, value);
+          } catch (error) {
+            console.warn('Response ' + error.message);
+          }
+        }
+      });
+      return headers;
+    }
+    Body.call(Request.prototype);
+    function Response(bodyInit, options) {
+      if (!(this instanceof Response)) {
+        throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.');
+      }
+      if (!options) {
+        options = {};
+      }
+      this.type = 'default';
+      this.status = options.status === undefined ? 200 : options.status;
+      if (this.status < 200 || this.status > 599) {
+        throw new RangeError("Failed to construct 'Response': The status provided (0) is outside the range [200, 599].");
+      }
+      this.ok = this.status >= 200 && this.status < 300;
+      this.statusText = options.statusText === undefined ? '' : '' + options.statusText;
+      this.headers = new Headers(options.headers);
+      this.url = options.url || '';
+      this._initBody(bodyInit);
+    }
+    Body.call(Response.prototype);
+    Response.prototype.clone = function () {
+      return new Response(this._bodyInit, {
+        status: this.status,
+        statusText: this.statusText,
+        headers: new Headers(this.headers),
+        url: this.url
+      });
+    };
+    Response.error = function () {
+      var response = new Response(null, {
+        status: 200,
+        statusText: ''
+      });
+      response.ok = false;
+      response.status = 0;
+      response.type = 'error';
+      return response;
+    };
+    var redirectStatuses = [301, 302, 303, 307, 308];
+    Response.redirect = function (url, status) {
+      if (redirectStatuses.indexOf(status) === -1) {
+        throw new RangeError('Invalid status code');
+      }
+      return new Response(null, {
+        status: status,
+        headers: {
+          location: url
+        }
+      });
+    };
+    exports.DOMException = g.DOMException;
+    try {
+      new exports.DOMException();
+    } catch (err) {
+      exports.DOMException = function (message, name) {
+        this.message = message;
+        this.name = name;
+        var error = Error(message);
+        this.stack = error.stack;
+      };
+      exports.DOMException.prototype = Object.create(Error.prototype);
+      exports.DOMException.prototype.constructor = exports.DOMException;
+    }
+    function fetch(input, init) {
+      return new Promise(function (resolve, reject) {
+        var request = new Request(input, init);
+        if (request.signal && request.signal.aborted) {
+          return reject(new exports.DOMException('Aborted', 'AbortError'));
+        }
+        var xhr = new XMLHttpRequest();
+        function abortXhr() {
+          xhr.abort();
+        }
+        xhr.onload = function () {
+          var options = {
+            statusText: xhr.statusText,
+            headers: parseHeaders(xhr.getAllResponseHeaders() || '')
+          };
+          // This check if specifically for when a user fetches a file locally from the file system
+          // Only if the status is out of a normal range
+          if (request.url.indexOf('file://') === 0 && (xhr.status < 200 || xhr.status > 599)) {
+            options.status = 200;
+          } else {
+            options.status = xhr.status;
+          }
+          options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL');
+          var body = 'response' in xhr ? xhr.response : xhr.responseText;
+          setTimeout(function () {
+            resolve(new Response(body, options));
+          }, 0);
+        };
+        xhr.onerror = function () {
+          setTimeout(function () {
+            reject(new TypeError('Network request failed'));
+          }, 0);
+        };
+        xhr.ontimeout = function () {
+          setTimeout(function () {
+            reject(new TypeError('Network request timed out'));
+          }, 0);
+        };
+        xhr.onabort = function () {
+          setTimeout(function () {
+            reject(new exports.DOMException('Aborted', 'AbortError'));
+          }, 0);
+        };
+        function fixUrl(url) {
+          try {
+            return url === '' && g.location.href ? g.location.href : url;
+          } catch (e) {
+            return url;
+          }
+        }
+        xhr.open(request.method, fixUrl(request.url), true);
+        if (request.credentials === 'include') {
+          xhr.withCredentials = true;
+        } else if (request.credentials === 'omit') {
+          xhr.withCredentials = false;
+        }
+        if ('responseType' in xhr) {
+          if (support.blob) {
+            xhr.responseType = 'blob';
+          } else if (support.arrayBuffer) {
+            xhr.responseType = 'arraybuffer';
+          }
+        }
+        if (init && typeof init.headers === 'object' && !(init.headers instanceof Headers || g.Headers && init.headers instanceof g.Headers)) {
+          var names = [];
+          Object.getOwnPropertyNames(init.headers).forEach(function (name) {
+            names.push(normalizeName(name));
+            xhr.setRequestHeader(name, normalizeValue(init.headers[name]));
+          });
+          request.headers.forEach(function (value, name) {
+            if (names.indexOf(name) === -1) {
+              xhr.setRequestHeader(name, value);
+            }
+          });
+        } else {
+          request.headers.forEach(function (value, name) {
+            xhr.setRequestHeader(name, value);
+          });
+        }
+        if (request.signal) {
+          request.signal.addEventListener('abort', abortXhr);
+          xhr.onreadystatechange = function () {
+            // DONE (success or failure)
+            if (xhr.readyState === 4) {
+              request.signal.removeEventListener('abort', abortXhr);
+            }
+          };
+        }
+        xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);
+      });
+    }
+    fetch.polyfill = true;
+    if (!g.fetch) {
+      g.fetch = fetch;
+      g.Headers = Headers;
+      g.Request = Request;
+      g.Response = Response;
+    }
+    exports.Headers = Headers;
+    exports.Request = Request;
+    exports.Response = Response;
+    exports.fetch = fetch;
+    Object.defineProperty(exports, '__esModule', {
+      value: true
+    });
+  });
+},170,[],"../../node_modules/whatwg-fetch/dist/fetch.umd.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  if (process.env.NODE_ENV === 'production') {
+    module.exports = _$$_REQUIRE(_dependencyMap[0], "./cjs/react-jsx-runtime.production.js");
+  } else {
+    module.exports = _$$_REQUIRE(_dependencyMap[1], "./cjs/react-jsx-runtime.development.js");
+  }
+},171,[172,173],"../../node_modules/react/jsx-runtime.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  /**
+   * @license React
+   * react-jsx-runtime.production.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_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
+    REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
+  function jsxProd(type, config, maybeKey) {
+    var key = null;
+    void 0 !== maybeKey && (key = "" + maybeKey);
+    void 0 !== config.key && (key = "" + config.key);
+    if ("key" in config) {
+      maybeKey = {};
+      for (var propName in config) "key" !== propName && (maybeKey[propName] = config[propName]);
+    } else maybeKey = config;
+    config = maybeKey.ref;
+    return {
+      $$typeof: REACT_ELEMENT_TYPE,
+      type: type,
+      key: key,
+      ref: void 0 !== config ? config : null,
+      props: maybeKey
+    };
+  }
+  exports.Fragment = REACT_FRAGMENT_TYPE;
+  exports.jsx = jsxProd;
+  exports.jsxs = jsxProd;
+},172,[],"../../node_modules/react/cjs/react-jsx-runtime.production.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  /**
+   * @license React
+   * react-jsx-runtime.development.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";
+
+  "production" !== process.env.NODE_ENV && function () {
+    function getComponentNameFromType(type) {
+      if (null == type) return null;
+      if ("function" === typeof type) return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+      if ("string" === typeof type) return type;
+      switch (type) {
+        case REACT_FRAGMENT_TYPE:
+          return "Fragment";
+        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_ACTIVITY_TYPE:
+          return "Activity";
+      }
+      if ("object" === typeof type) switch ("number" === typeof type.tag && console.error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), type.$$typeof) {
+        case REACT_PORTAL_TYPE:
+          return "Portal";
+        case REACT_CONTEXT_TYPE:
+          return (type.displayName || "Context") + ".Provider";
+        case REACT_CONSUMER_TYPE:
+          return (type._context.displayName || "Context") + ".Consumer";
+        case REACT_FORWARD_REF_TYPE:
+          var innerType = type.render;
+          type = type.displayName;
+          type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
+          return type;
+        case REACT_MEMO_TYPE:
+          return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
+        case REACT_LAZY_TYPE:
+          innerType = type._payload;
+          type = type._init;
+          try {
+            return getComponentNameFromType(type(innerType));
+          } catch (x) {}
+      }
+      return null;
+    }
+    function testStringCoercion(value) {
+      return "" + value;
+    }
+    function checkKeyStringCoercion(value) {
+      try {
+        testStringCoercion(value);
+        var JSCompiler_inline_result = !1;
+      } catch (e) {
+        JSCompiler_inline_result = !0;
+      }
+      if (JSCompiler_inline_result) {
+        JSCompiler_inline_result = console;
+        var JSCompiler_temp_const = JSCompiler_inline_result.error;
+        var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+        JSCompiler_temp_const.call(JSCompiler_inline_result, "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", JSCompiler_inline_result$jscomp$0);
+        return testStringCoercion(value);
+      }
+    }
+    function getTaskName(type) {
+      if (type === REACT_FRAGMENT_TYPE) return "<>";
+      if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE) return "<...>";
+      try {
+        var name = getComponentNameFromType(type);
+        return name ? "<" + name + ">" : "<...>";
+      } catch (x) {
+        return "<...>";
+      }
+    }
+    function getOwner() {
+      var dispatcher = ReactSharedInternals.A;
+      return null === dispatcher ? null : dispatcher.getOwner();
+    }
+    function UnknownOwner() {
+      return Error("react-stack-top-frame");
+    }
+    function hasValidKey(config) {
+      if (hasOwnProperty.call(config, "key")) {
+        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+        if (getter && getter.isReactWarning) return !1;
+      }
+      return void 0 !== config.key;
+    }
+    function defineKeyPropWarningGetter(props, displayName) {
+      function warnAboutAccessingKey() {
+        specialPropKeyWarningShown || (specialPropKeyWarningShown = !0, console.error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)", displayName));
+      }
+      warnAboutAccessingKey.isReactWarning = !0;
+      Object.defineProperty(props, "key", {
+        get: warnAboutAccessingKey,
+        configurable: !0
+      });
+    }
+    function elementRefGetterWithDeprecationWarning() {
+      var componentName = getComponentNameFromType(this.type);
+      didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = !0, console.error("Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."));
+      componentName = this.props.ref;
+      return void 0 !== componentName ? componentName : null;
+    }
+    function ReactElement(type, key, self, source, owner, props, debugStack, debugTask) {
+      self = props.ref;
+      type = {
+        $$typeof: REACT_ELEMENT_TYPE,
+        type: type,
+        key: key,
+        props: props,
+        _owner: owner
+      };
+      null !== (void 0 !== self ? self : null) ? Object.defineProperty(type, "ref", {
+        enumerable: !1,
+        get: elementRefGetterWithDeprecationWarning
+      }) : Object.defineProperty(type, "ref", {
+        enumerable: !1,
+        value: null
+      });
+      type._store = {};
+      Object.defineProperty(type._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: 0
+      });
+      Object.defineProperty(type, "_debugInfo", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: null
+      });
+      Object.defineProperty(type, "_debugStack", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: debugStack
+      });
+      Object.defineProperty(type, "_debugTask", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: debugTask
+      });
+      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+      return type;
+    }
+    function jsxDEVImpl(type, config, maybeKey, isStaticChildren, source, self, debugStack, debugTask) {
+      var children = config.children;
+      if (void 0 !== children) if (isStaticChildren) {
+        if (isArrayImpl(children)) {
+          for (isStaticChildren = 0; isStaticChildren < children.length; isStaticChildren++) validateChildKeys(children[isStaticChildren]);
+          Object.freeze && Object.freeze(children);
+        } else console.error("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+      } else validateChildKeys(children);
+      if (hasOwnProperty.call(config, "key")) {
+        children = getComponentNameFromType(type);
+        var keys = Object.keys(config).filter(function (k) {
+          return "key" !== k;
+        });
+        isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
+        didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error('A props object containing a "key" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />', isStaticChildren, children, keys, children), didWarnAboutKeySpread[children + isStaticChildren] = !0);
+      }
+      children = null;
+      void 0 !== maybeKey && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey);
+      hasValidKey(config) && (checkKeyStringCoercion(config.key), children = "" + config.key);
+      if ("key" in config) {
+        maybeKey = {};
+        for (var propName in config) "key" !== propName && (maybeKey[propName] = config[propName]);
+      } else maybeKey = config;
+      children && defineKeyPropWarningGetter(maybeKey, "function" === typeof type ? type.displayName || type.name || "Unknown" : type);
+      return ReactElement(type, children, self, source, getOwner(), maybeKey, debugStack, debugTask);
+    }
+    function validateChildKeys(node) {
+      "object" === typeof node && null !== node && node.$$typeof === REACT_ELEMENT_TYPE && node._store && (node._store.validated = 1);
+    }
+    var React = _$$_REQUIRE(_dependencyMap[0], "react"),
+      REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
+      REACT_PORTAL_TYPE = Symbol.for("react.portal"),
+      REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
+      REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
+      REACT_PROFILER_TYPE = Symbol.for("react.profiler");
+    Symbol.for("react.provider");
+    var REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
+      REACT_CONTEXT_TYPE = Symbol.for("react.context"),
+      REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
+      REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
+      REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
+      REACT_MEMO_TYPE = Symbol.for("react.memo"),
+      REACT_LAZY_TYPE = Symbol.for("react.lazy"),
+      REACT_ACTIVITY_TYPE = Symbol.for("react.activity"),
+      REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"),
+      ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,
+      hasOwnProperty = Object.prototype.hasOwnProperty,
+      isArrayImpl = Array.isArray,
+      createTask = console.createTask ? console.createTask : function () {
+        return null;
+      };
+    React = {
+      "react-stack-bottom-frame": function reactStackBottomFrame(callStackForError) {
+        return callStackForError();
+      }
+    };
+    var specialPropKeyWarningShown;
+    var didWarnAboutElementRef = {};
+    var unknownOwnerDebugStack = React["react-stack-bottom-frame"].bind(React, UnknownOwner)();
+    var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+    var didWarnAboutKeySpread = {};
+    exports.Fragment = REACT_FRAGMENT_TYPE;
+    exports.jsx = function (type, config, maybeKey, source, self) {
+      var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+      return jsxDEVImpl(type, config, maybeKey, !1, source, self, trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack, trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
+    };
+    exports.jsxs = function (type, config, maybeKey, source, self) {
+      var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+      return jsxDEVImpl(type, config, maybeKey, !0, source, self, trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack, trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
+    };
+  }();
+},173,[73],"../../node_modules/react/cjs/react-jsx-runtime.development.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = exports.SyntheticError = void 0;
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var _wrapNativeSuper2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/wrapNativeSuper"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var SyntheticError = exports.SyntheticError = /*#__PURE__*/function (_Error) {
+    function SyntheticError() {
+      var _this;
+      (0, _classCallCheck2.default)(this, SyntheticError);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _callSuper(this, SyntheticError, [].concat(args));
+      _this.name = '';
+      return _this;
+    }
+    (0, _inherits2.default)(SyntheticError, _Error);
+    return (0, _createClass2.default)(SyntheticError);
+  }(/*#__PURE__*/(0, _wrapNativeSuper2.default)(Error));
+  var userExceptionDecorator;
+  var inUserExceptionDecorator = false;
+  var decoratedExtraDataKey = 'RN$ErrorExtraDataKey';
+  function unstable_setExceptionDecorator(exceptionDecorator) {
+    userExceptionDecorator = exceptionDecorator;
+  }
+  function preprocessException(data) {
+    if (userExceptionDecorator && !inUserExceptionDecorator) {
+      inUserExceptionDecorator = true;
+      try {
+        return userExceptionDecorator(data);
+      } catch (_unused) {} finally {
+        inUserExceptionDecorator = false;
+      }
+    }
+    return data;
+  }
+  var exceptionID = 0;
+  function reportException(e, isFatal, reportToConsole) {
+    var parseErrorStack = _$$_REQUIRE(_dependencyMap[7], "./Devtools/parseErrorStack").default;
+    var stack = parseErrorStack(e == null ? void 0 : e.stack);
+    var currentExceptionID = ++exceptionID;
+    var originalMessage = e.message || '';
+    var message = originalMessage;
+    if (e.componentStack != null) {
+      message += `\n\nThis error is located at:${e.componentStack}`;
+    }
+    var namePrefix = e.name == null || e.name === '' ? '' : `${e.name}: `;
+    if (!message.startsWith(namePrefix)) {
+      message = namePrefix + message;
+    }
+    message = e.jsEngine == null ? message : `${message}, js engine: ${e.jsEngine}`;
+    var extraData = Object.assign({}, e[decoratedExtraDataKey], {
+      jsEngine: e.jsEngine,
+      rawStack: e.stack
+    });
+    if (e.cause != null && typeof e.cause === 'object') {
+      extraData.stackSymbols = e.cause.stackSymbols;
+      extraData.stackReturnAddresses = e.cause.stackReturnAddresses;
+      extraData.stackElements = e.cause.stackElements;
+    }
+    var data = preprocessException({
+      message: message,
+      originalMessage: message === originalMessage ? null : originalMessage,
+      name: e.name == null || e.name === '' ? null : e.name,
+      componentStack: typeof e.componentStack === 'string' ? e.componentStack : null,
+      stack: stack,
+      id: currentExceptionID,
+      isFatal: isFatal,
+      extraData: extraData
+    });
+    if (reportToConsole) {
+      console.error(data.message);
+    }
+    if (__DEV__) {
+      var LogBox = _$$_REQUIRE(_dependencyMap[8], "../LogBox/LogBox").default;
+      LogBox.addException(Object.assign({}, data, {
+        isComponentError: !!e.isComponentError
+      }));
+    } else if (isFatal || e.type !== 'warn') {
+      var NativeExceptionsManager = _$$_REQUIRE(_dependencyMap[9], "./NativeExceptionsManager").default;
+      if (NativeExceptionsManager) {
+        if (isFatal) {
+          if (global.RN$hasHandledFatalException != null && global.RN$hasHandledFatalException()) {
+            return;
+          }
+          global.RN$notifyOfFatalException == null || global.RN$notifyOfFatalException();
+        }
+        NativeExceptionsManager.reportException(data);
+      }
+    }
+  }
+  var inExceptionHandler = false;
+  function handleException(e, isFatal) {
+    var reportToConsole = true;
+    if (!global.RN$handleException || !global.RN$handleException(e, isFatal, reportToConsole)) {
+      var error;
+      if (e instanceof Error) {
+        error = e;
+      } else {
+        error = new SyntheticError(e);
+      }
+      try {
+        inExceptionHandler = true;
+        reportException(error, isFatal, reportToConsole);
+      } finally {
+        inExceptionHandler = false;
+      }
+    }
+  }
+  function reactConsoleErrorHandler() {
+    var _console;
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    (_console = console)._errorOriginal.apply(_console, args);
+    if (!console.reportErrorsAsExceptions) {
+      return;
+    }
+    if (inExceptionHandler || global.RN$inExceptionHandler != null && global.RN$inExceptionHandler()) {
+      return;
+    }
+    var error;
+    var firstArg = args[0];
+    if (firstArg != null && firstArg.stack) {
+      error = firstArg;
+    } else {
+      var stringifySafe = _$$_REQUIRE(_dependencyMap[10], "../Utilities/stringifySafe").default;
+      if (typeof firstArg === 'string' && firstArg.startsWith('Warning: ')) {
+        return;
+      }
+      var message = args.map(function (arg) {
+        return typeof arg === 'string' ? arg : stringifySafe(arg);
+      }).join(' ');
+      error = new SyntheticError(message);
+      error.name = 'console.error';
+    }
+    var isFatal = false;
+    var reportToConsole = false;
+    if (!global.RN$handleException || !global.RN$handleException(error, isFatal, reportToConsole)) {
+      reportException(error, isFatal, reportToConsole);
+    }
+  }
+  function installConsoleErrorReporter() {
+    if (console._errorOriginal) {
+      return;
+    }
+    console._errorOriginal = console.error.bind(console);
+    console.error = reactConsoleErrorHandler;
+    if (console.reportErrorsAsExceptions === undefined) {
+      console.reportErrorsAsExceptions = true;
+    }
+  }
+  var ExceptionsManager = {
+    decoratedExtraDataKey: decoratedExtraDataKey,
+    handleException: handleException,
+    installConsoleErrorReporter: installConsoleErrorReporter,
+    SyntheticError: SyntheticError,
+    unstable_setExceptionDecorator: unstable_setExceptionDecorator
+  };
+  var _default = exports.default = ExceptionsManager;
+},174,[1,12,11,18,20,23,175,157,153,179,47],"../../node_modules/react-native/Libraries/Core/ExceptionsManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _wrapNativeSuper(t) {
+    var r = "function" == typeof Map ? new Map() : void 0;
+    return module.exports = _wrapNativeSuper = function _wrapNativeSuper(t) {
+      if (null === t || !_$$_REQUIRE(_dependencyMap[0], "./isNativeFunction.js")(t)) return t;
+      if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function");
+      if (void 0 !== r) {
+        if (r.has(t)) return r.get(t);
+        r.set(t, Wrapper);
+      }
+      function Wrapper() {
+        return _$$_REQUIRE(_dependencyMap[1], "./construct.js")(t, arguments, _$$_REQUIRE(_dependencyMap[2], "./getPrototypeOf.js")(this).constructor);
+      }
+      return Wrapper.prototype = Object.create(t.prototype, {
+        constructor: {
+          value: Wrapper,
+          enumerable: !1,
+          writable: !0,
+          configurable: !0
+        }
+      }), _$$_REQUIRE(_dependencyMap[3], "./setPrototypeOf.js")(Wrapper, t);
+    }, module.exports.__esModule = true, module.exports["default"] = module.exports, _wrapNativeSuper(t);
+  }
+  module.exports = _wrapNativeSuper, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},175,[176,177,20,24],"../../node_modules/@babel/runtime/helpers/wrapNativeSuper.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _isNativeFunction(t) {
+    try {
+      return -1 !== Function.toString.call(t).indexOf("[native code]");
+    } catch (n) {
+      return "function" == typeof t;
+    }
+  }
+  module.exports = _isNativeFunction, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},176,[],"../../node_modules/@babel/runtime/helpers/isNativeFunction.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _construct(t, e, r) {
+    if (_$$_REQUIRE(_dependencyMap[0], "./isNativeReflectConstruct.js")()) return Reflect.construct.apply(null, arguments);
+    var o = [null];
+    o.push.apply(o, e);
+    var p = new (t.bind.apply(t, o))();
+    return r && _$$_REQUIRE(_dependencyMap[1], "./setPrototypeOf.js")(p, r.prototype), p;
+  }
+  module.exports = _construct, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},177,[178,24],"../../node_modules/@babel/runtime/helpers/construct.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _isNativeReflectConstruct() {
+    try {
+      var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+    } catch (t) {}
+    return (module.exports = _isNativeReflectConstruct = function _isNativeReflectConstruct() {
+      return !!t;
+    }, module.exports.__esModule = true, module.exports["default"] = module.exports)();
+  }
+  module.exports = _isNativeReflectConstruct, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},178,[],"../../node_modules/@babel/runtime/helpers/isNativeReflectConstruct.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeExceptionsManager = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativeExceptionsManager"));
+  Object.keys(_NativeExceptionsManager).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeExceptionsManager[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeExceptionsManager[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeExceptionsManager.default;
+},179,[180],"../../node_modules/react-native/Libraries/Core/NativeExceptionsManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var NativeModule = TurboModuleRegistry.getEnforcing('ExceptionsManager');
+  var ExceptionsManager = {
+    reportFatalException: function reportFatalException(message, stack, exceptionId) {
+      NativeModule.reportFatalException(message, stack, exceptionId);
+    },
+    reportSoftException: function reportSoftException(message, stack, exceptionId) {
+      NativeModule.reportSoftException(message, stack, exceptionId);
+    },
+    dismissRedbox: function dismissRedbox() {
+      if ("ios" !== 'ios' && NativeModule.dismissRedbox) {
+        NativeModule.dismissRedbox();
+      }
+    },
+    reportException: function reportException(data) {
+      if (NativeModule.reportException) {
+        NativeModule.reportException(data);
+        return;
+      }
+      if (data.isFatal) {
+        ExceptionsManager.reportFatalException(data.message, data.stack, data.id);
+      } else {
+        ExceptionsManager.reportSoftException(data.message, data.stack, data.id);
+      }
+    }
+  };
+  var _default = exports.default = ExceptionsManager;
+},180,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeExceptionsManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.hasComponentStack = hasComponentStack;
+  exports.parseComponentStack = parseComponentStack;
+  exports.parseInterpolation = parseInterpolation;
+  exports.parseLogBoxException = parseLogBoxException;
+  exports.parseLogBoxLog = parseLogBoxLog;
+  exports.withoutANSIColorStyles = withoutANSIColorStyles;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _toConsumableArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/toConsumableArray"));
+  var _parseErrorStack = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../Core/Devtools/parseErrorStack"));
+  var _UTFSequence = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../../UTFSequence"));
+  var _stringifySafe = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../../Utilities/stringifySafe"));
+  var _ansiRegex = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "ansi-regex"));
+  var ANSI_REGEX = (0, _ansiRegex.default)().source;
+  var RE_TRANSFORM_ERROR = /^TransformError /;
+  var RE_COMPONENT_STACK_LINE = /\n {4}(in|at) /;
+  var RE_COMPONENT_STACK_LINE_GLOBAL = /\n {4}(in|at) /g;
+  var RE_COMPONENT_STACK_LINE_OLD = / {4}in/;
+  var RE_COMPONENT_STACK_LINE_NEW = / {4}at/;
+  var RE_COMPONENT_STACK_LINE_STACK_FRAME = /@.*\n/;
+  var RE_BABEL_TRANSFORM_ERROR_FORMAT = /^(?:TransformError )?(?:SyntaxError: |ReferenceError: )(.*): (.*) \((\d+):(\d+)\)\n\n([\s\S]+)/;
+  var RE_COMPONENT_STACK_WITH_SOURCE = /(.*) \(at (.*\.(?:js|jsx|ts|tsx)):([\d]+)\)/;
+  var RE_COMPONENT_STACK_NO_SOURCE = /(.*) \(created by .*\)/;
+  var RE_BABEL_CODE_FRAME_ERROR_FORMAT = /^(?:TransformError )?(?:(?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*):? (?:(?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*?)(\/(?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*): ((?:[\0-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF])+?)\n([ >]{2}[\t-\r 0-9\xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]+ \|(?:[\0-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF])+|\x1B(?:[\0-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF])+)/;
+  var RE_METRO_ERROR_FORMAT = /^(?:InternalError Metro has encountered an error:) ((?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*): ((?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*) \(([0-9]+):([0-9]+)\)\n\n((?:[\0-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF])+)/;
+  var RE_BABEL_CODE_FRAME_MARKER_PATTERN = new RegExp(['^', `(?:${ANSI_REGEX})*`, '>', `(?:${ANSI_REGEX})*`, ' +', '[0-9]+', ' \\|'].join(''), 'm');
+  function hasComponentStack(args) {
+    for (var arg of args) {
+      if (typeof arg === 'string' && isComponentStack(arg)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  var SUBSTITUTION = _UTFSequence.default.BOM + '%s';
+  function parseInterpolation(args) {
+    var categoryParts = [];
+    var contentParts = [];
+    var substitutionOffsets = [];
+    var remaining = (0, _toConsumableArray2.default)(args);
+    if (typeof remaining[0] === 'string') {
+      var formatString = String(remaining.shift());
+      var formatStringParts = formatString.split('%s');
+      var substitutionCount = formatStringParts.length - 1;
+      var substitutions = remaining.splice(0, substitutionCount);
+      var categoryString = '';
+      var contentString = '';
+      var substitutionIndex = 0;
+      for (var formatStringPart of formatStringParts) {
+        categoryString += formatStringPart;
+        contentString += formatStringPart;
+        if (substitutionIndex < substitutionCount) {
+          if (substitutionIndex < substitutions.length) {
+            var substitution = typeof substitutions[substitutionIndex] === 'string' ? substitutions[substitutionIndex] : (0, _stringifySafe.default)(substitutions[substitutionIndex]);
+            substitutionOffsets.push({
+              length: substitution.length,
+              offset: contentString.length
+            });
+            categoryString += SUBSTITUTION;
+            contentString += substitution;
+          } else {
+            substitutionOffsets.push({
+              length: 2,
+              offset: contentString.length
+            });
+            categoryString += '%s';
+            contentString += '%s';
+          }
+          substitutionIndex++;
+        }
+      }
+      categoryParts.push(categoryString);
+      contentParts.push(contentString);
+    }
+    var remainingArgs = remaining.map(function (arg) {
+      return typeof arg === 'string' ? arg : (0, _stringifySafe.default)(arg);
+    });
+    categoryParts.push.apply(categoryParts, (0, _toConsumableArray2.default)(remainingArgs));
+    contentParts.push.apply(contentParts, (0, _toConsumableArray2.default)(remainingArgs));
+    return {
+      category: categoryParts.join(' '),
+      message: {
+        content: contentParts.join(' '),
+        substitutions: substitutionOffsets
+      }
+    };
+  }
+  function isComponentStack(consoleArgument) {
+    var isOldComponentStackFormat = RE_COMPONENT_STACK_LINE_OLD.test(consoleArgument);
+    var isNewComponentStackFormat = RE_COMPONENT_STACK_LINE_NEW.test(consoleArgument);
+    var isNewJSCComponentStackFormat = RE_COMPONENT_STACK_LINE_STACK_FRAME.test(consoleArgument);
+    return isOldComponentStackFormat || isNewComponentStackFormat || isNewJSCComponentStackFormat;
+  }
+  function parseComponentStack(message) {
+    var stack = (0, _parseErrorStack.default)(message);
+    if (stack && stack.length > 0) {
+      return {
+        type: 'stack',
+        stack: stack.map(function (frame) {
+          return {
+            content: frame.methodName,
+            collapse: frame.collapse || false,
+            fileName: frame.file == null ? 'unknown' : frame.file,
+            location: {
+              column: frame.column == null ? -1 : frame.column,
+              row: frame.lineNumber == null ? -1 : frame.lineNumber
+            }
+          };
+        })
+      };
+    }
+    var legacyStack = message.split(RE_COMPONENT_STACK_LINE_GLOBAL).map(function (s) {
+      if (!s) {
+        return null;
+      }
+      var match = s.match(RE_COMPONENT_STACK_WITH_SOURCE);
+      if (match) {
+        var _match$slice = match.slice(1),
+          _match$slice2 = (0, _slicedToArray2.default)(_match$slice, 3),
+          content = _match$slice2[0],
+          fileName = _match$slice2[1],
+          row = _match$slice2[2];
+        return {
+          content: content,
+          fileName: fileName,
+          location: {
+            column: -1,
+            row: parseInt(row, 10)
+          }
+        };
+      }
+      var matchWithoutSource = s.match(RE_COMPONENT_STACK_NO_SOURCE);
+      if (matchWithoutSource) {
+        return {
+          content: matchWithoutSource[1],
+          fileName: '',
+          location: null
+        };
+      }
+      return null;
+    }).filter(Boolean);
+    return {
+      type: 'legacy',
+      stack: legacyStack
+    };
+  }
+  function parseLogBoxException(error) {
+    var message = error.originalMessage != null ? error.originalMessage : 'Unknown';
+    var metroInternalError = message.match(RE_METRO_ERROR_FORMAT);
+    if (metroInternalError) {
+      var _metroInternalError$s = metroInternalError.slice(1),
+        _metroInternalError$s2 = (0, _slicedToArray2.default)(_metroInternalError$s, 5),
+        content = _metroInternalError$s2[0],
+        fileName = _metroInternalError$s2[1],
+        row = _metroInternalError$s2[2],
+        column = _metroInternalError$s2[3],
+        codeFrame = _metroInternalError$s2[4];
+      return {
+        level: 'fatal',
+        type: 'Metro Error',
+        stack: [],
+        isComponentError: false,
+        componentStackType: 'legacy',
+        componentStack: [],
+        codeFrame: {
+          fileName: fileName,
+          location: {
+            row: parseInt(row, 10),
+            column: parseInt(column, 10)
+          },
+          content: codeFrame
+        },
+        message: {
+          content: content,
+          substitutions: []
+        },
+        category: `${fileName}-${row}-${column}`,
+        extraData: error.extraData
+      };
+    }
+    var babelTransformError = message.match(RE_BABEL_TRANSFORM_ERROR_FORMAT);
+    if (babelTransformError) {
+      var _babelTransformError$ = babelTransformError.slice(1),
+        _babelTransformError$2 = (0, _slicedToArray2.default)(_babelTransformError$, 5),
+        _fileName = _babelTransformError$2[0],
+        _content = _babelTransformError$2[1],
+        _row = _babelTransformError$2[2],
+        _column = _babelTransformError$2[3],
+        _codeFrame = _babelTransformError$2[4];
+      return {
+        level: 'syntax',
+        stack: [],
+        isComponentError: false,
+        componentStackType: 'legacy',
+        componentStack: [],
+        codeFrame: {
+          fileName: _fileName,
+          location: {
+            row: parseInt(_row, 10),
+            column: parseInt(_column, 10)
+          },
+          content: _codeFrame
+        },
+        message: {
+          content: _content,
+          substitutions: []
+        },
+        category: `${_fileName}-${_row}-${_column}`,
+        extraData: error.extraData
+      };
+    }
+    if (RE_BABEL_CODE_FRAME_MARKER_PATTERN.test(message)) {
+      var babelCodeFrameError = message.match(RE_BABEL_CODE_FRAME_ERROR_FORMAT);
+      if (babelCodeFrameError) {
+        var _babelCodeFrameError$ = babelCodeFrameError.slice(1),
+          _babelCodeFrameError$2 = (0, _slicedToArray2.default)(_babelCodeFrameError$, 3),
+          _fileName2 = _babelCodeFrameError$2[0],
+          _content2 = _babelCodeFrameError$2[1],
+          _codeFrame2 = _babelCodeFrameError$2[2];
+        return {
+          level: 'syntax',
+          stack: [],
+          isComponentError: false,
+          componentStackType: 'legacy',
+          componentStack: [],
+          codeFrame: {
+            fileName: _fileName2,
+            location: null,
+            content: _codeFrame2
+          },
+          message: {
+            content: _content2,
+            substitutions: []
+          },
+          category: `${_fileName2}-${1}-${1}`,
+          extraData: error.extraData
+        };
+      }
+    }
+    if (message.match(RE_TRANSFORM_ERROR)) {
+      return {
+        level: 'syntax',
+        stack: error.stack,
+        isComponentError: error.isComponentError,
+        componentStackType: 'legacy',
+        componentStack: [],
+        message: {
+          content: message,
+          substitutions: []
+        },
+        category: message,
+        extraData: error.extraData
+      };
+    }
+    var componentStack = error.componentStack;
+    if (error.isFatal || error.isComponentError) {
+      if (componentStack != null) {
+        var _parseComponentStack = parseComponentStack(componentStack),
+          type = _parseComponentStack.type,
+          stack = _parseComponentStack.stack;
+        return Object.assign({
+          level: 'fatal',
+          stack: error.stack,
+          isComponentError: error.isComponentError,
+          componentStackType: type,
+          componentStack: stack,
+          extraData: error.extraData
+        }, parseInterpolation([message]));
+      } else {
+        return Object.assign({
+          level: 'fatal',
+          stack: error.stack,
+          isComponentError: error.isComponentError,
+          componentStackType: 'legacy',
+          componentStack: [],
+          extraData: error.extraData
+        }, parseInterpolation([message]));
+      }
+    }
+    if (componentStack != null) {
+      var _parseComponentStack2 = parseComponentStack(componentStack),
+        _type = _parseComponentStack2.type,
+        _stack = _parseComponentStack2.stack;
+      return Object.assign({
+        level: 'error',
+        stack: error.stack,
+        isComponentError: error.isComponentError,
+        componentStackType: _type,
+        componentStack: _stack,
+        extraData: error.extraData
+      }, parseInterpolation([message]));
+    }
+    return Object.assign({
+      level: 'error',
+      stack: error.stack,
+      isComponentError: error.isComponentError,
+      extraData: error.extraData
+    }, parseLogBoxLog([message]));
+  }
+  function withoutANSIColorStyles(message) {
+    if (typeof message !== 'string') {
+      return message;
+    }
+    return message.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '');
+  }
+  function parseLogBoxLog(args) {
+    var message = withoutANSIColorStyles(args[0]);
+    var argsWithoutComponentStack = [];
+    var componentStack = [];
+    var componentStackType = 'legacy';
+    if (typeof message === 'string' && message.slice(-2) === '%s' && args.length > 0) {
+      var lastArg = args[args.length - 1];
+      if (typeof lastArg === 'string' && isComponentStack(lastArg)) {
+        argsWithoutComponentStack = args.slice(0, -1);
+        argsWithoutComponentStack[0] = message.slice(0, -2);
+        var _parseComponentStack3 = parseComponentStack(lastArg),
+          type = _parseComponentStack3.type,
+          stack = _parseComponentStack3.stack;
+        componentStack = stack;
+        componentStackType = type;
+      }
+    }
+    if (componentStack.length === 0 && argsWithoutComponentStack.length === 0) {
+      for (var arg of args) {
+        if (typeof arg === 'string' && isComponentStack(arg)) {
+          var messageEndIndex = arg.search(RE_COMPONENT_STACK_LINE);
+          if (messageEndIndex < 0) {
+            messageEndIndex = arg.search(/\n/);
+          }
+          if (messageEndIndex > 0) {
+            argsWithoutComponentStack.push(arg.slice(0, messageEndIndex));
+          }
+          var _parseComponentStack4 = parseComponentStack(arg),
+            _type2 = _parseComponentStack4.type,
+            _stack2 = _parseComponentStack4.stack;
+          componentStack = _stack2;
+          componentStackType = _type2;
+        } else {
+          argsWithoutComponentStack.push(arg);
+        }
+      }
+    }
+    return Object.assign({}, parseInterpolation(argsWithoutComponentStack), {
+      componentStack: componentStack,
+      componentStackType: componentStackType
+    });
+  }
+},181,[1,34,42,157,182,47,183],"../../node_modules/react-native/Libraries/LogBox/Data/parseLogBoxLog.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var UTFSequence = _$$_REQUIRE(_dependencyMap[0], "./Utilities/deepFreezeAndThrowOnMutationInDev").default({
+    BOM: "\uFEFF",
+    BULLET: "\u2022",
+    BULLET_SP: "\xA0\u2022\xA0",
+    MIDDOT: "\xB7",
+    MIDDOT_SP: "\xA0\xB7\xA0",
+    MIDDOT_KATAKANA: "\u30FB",
+    MDASH: "\u2014",
+    MDASH_SP: "\xA0\u2014\xA0",
+    NDASH: "\u2013",
+    NDASH_SP: "\xA0\u2013\xA0",
+    NEWLINE: "\n",
+    NBSP: "\xA0",
+    PIZZA: "\uD83C\uDF55",
+    TRIANGLE_LEFT: "\u25C0",
+    TRIANGLE_RIGHT: "\u25B6"
+  });
+  var _default = exports.default = UTFSequence;
+},182,[48],"../../node_modules/react-native/Libraries/UTFSequence.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  module.exports = function () {
+    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      _ref$onlyFirst = _ref.onlyFirst,
+      onlyFirst = _ref$onlyFirst === void 0 ? false : _ref$onlyFirst;
+    var pattern = ["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)", '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))'].join('|');
+    return new RegExp(pattern, onlyFirst ? undefined : 'g');
+  };
+},183,[],"../../node_modules/ansi-regex/index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _createClass = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/createClass");
+  var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+  var _wrapNativeSuper = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/wrapNativeSuper");
+  var _toConsumableArray = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/toConsumableArray");
+  function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  /*!
+   * /**
+   *  * 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.
+   *  * /
+   */
+  /******/
+  (function () {
+    // webpackBootstrap
+    /******/
+    "use strict";
+
+    /******/
+    var __webpack_modules__ = {
+      /***/"./src/collections.ts": (/***/function _src_collectionsTs(__unused_webpack_module, exports) {
+        Object.defineProperty(exports, "__esModule", {
+          value: true
+        });
+        exports.printIteratorEntries = printIteratorEntries;
+        exports.printIteratorValues = printIteratorValues;
+        exports.printListItems = printListItems;
+        exports.printObjectProperties = printObjectProperties;
+        /**
+         * 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.
+         *
+         */
+
+        var getKeysOfEnumerableProperties = function getKeysOfEnumerableProperties(object, compareKeys) {
+          var rawKeys = Object.keys(object);
+          var keys = compareKeys === null ? rawKeys : rawKeys.sort(compareKeys);
+          if (Object.getOwnPropertySymbols) {
+            for (var symbol of Object.getOwnPropertySymbols(object)) {
+              if (Object.getOwnPropertyDescriptor(object, symbol).enumerable) {
+                keys.push(symbol);
+              }
+            }
+          }
+          return keys;
+        };
+
+        /**
+         * Return entries (for example, of a map)
+         * with spacing, indentation, and comma
+         * without surrounding punctuation (for example, braces)
+         */
+        function printIteratorEntries(iterator, config, indentation, depth, refs, printer) {
+          var separator = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : ': ';
+          var result = '';
+          var width = 0;
+          var current = iterator.next();
+          if (!current.done) {
+            result += config.spacingOuter;
+            var indentationNext = indentation + config.indent;
+            while (!current.done) {
+              result += indentationNext;
+              if (width++ === config.maxWidth) {
+                result += '…';
+                break;
+              }
+              var name = printer(current.value[0], config, indentationNext, depth, refs);
+              var value = printer(current.value[1], config, indentationNext, depth, refs);
+              result += name + separator + value;
+              current = iterator.next();
+              if (!current.done) {
+                result += `,${config.spacingInner}`;
+              } else if (!config.min) {
+                result += ',';
+              }
+            }
+            result += config.spacingOuter + indentation;
+          }
+          return result;
+        }
+
+        /**
+         * Return values (for example, of a set)
+         * with spacing, indentation, and comma
+         * without surrounding punctuation (braces or brackets)
+         */
+        function printIteratorValues(iterator, config, indentation, depth, refs, printer) {
+          var result = '';
+          var width = 0;
+          var current = iterator.next();
+          if (!current.done) {
+            result += config.spacingOuter;
+            var indentationNext = indentation + config.indent;
+            while (!current.done) {
+              result += indentationNext;
+              if (width++ === config.maxWidth) {
+                result += '…';
+                break;
+              }
+              result += printer(current.value, config, indentationNext, depth, refs);
+              current = iterator.next();
+              if (!current.done) {
+                result += `,${config.spacingInner}`;
+              } else if (!config.min) {
+                result += ',';
+              }
+            }
+            result += config.spacingOuter + indentation;
+          }
+          return result;
+        }
+
+        /**
+         * Return items (for example, of an array)
+         * with spacing, indentation, and comma
+         * without surrounding punctuation (for example, brackets)
+         **/
+        function printListItems(list, config, indentation, depth, refs, printer) {
+          var result = '';
+          list = list instanceof ArrayBuffer ? new DataView(list) : list;
+          var isDataView = function isDataView(l) {
+            return l instanceof DataView;
+          };
+          var length = isDataView(list) ? list.byteLength : list.length;
+          if (length > 0) {
+            result += config.spacingOuter;
+            var indentationNext = indentation + config.indent;
+            for (var i = 0; i < length; i++) {
+              result += indentationNext;
+              if (i === config.maxWidth) {
+                result += '…';
+                break;
+              }
+              if (isDataView(list) || i in list) {
+                result += printer(isDataView(list) ? list.getInt8(i) : list[i], config, indentationNext, depth, refs);
+              }
+              if (i < length - 1) {
+                result += `,${config.spacingInner}`;
+              } else if (!config.min) {
+                result += ',';
+              }
+            }
+            result += config.spacingOuter + indentation;
+          }
+          return result;
+        }
+
+        /**
+         * Return properties of an object
+         * with spacing, indentation, and comma
+         * without surrounding punctuation (for example, braces)
+         */
+        function printObjectProperties(val, config, indentation, depth, refs, printer) {
+          var result = '';
+          var keys = getKeysOfEnumerableProperties(val, config.compareKeys);
+          if (keys.length > 0) {
+            result += config.spacingOuter;
+            var indentationNext = indentation + config.indent;
+            for (var i = 0; i < keys.length; i++) {
+              var key = keys[i];
+              var name = printer(key, config, indentationNext, depth, refs);
+              var value = printer(val[key], config, indentationNext, depth, refs);
+              result += `${indentationNext + name}: ${value}`;
+              if (i < keys.length - 1) {
+                result += `,${config.spacingInner}`;
+              } else if (!config.min) {
+                result += ',';
+              }
+            }
+            result += config.spacingOuter + indentation;
+          }
+          return result;
+        }
+
+        /***/
+      }),
+      /***/"./src/plugins/AsymmetricMatcher.ts": (/***/function _src_plugins_AsymmetricMatcherTs(__unused_webpack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+          value: true
+        });
+        exports.test = exports.serialize = exports["default"] = void 0;
+        var _collections = __webpack_require__("./src/collections.ts");
+        var Symbol = globalThis['jest-symbol-do-not-touch'] || globalThis.Symbol;
+        /**
+         * 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.
+         */
+        var asymmetricMatcher = typeof Symbol === 'function' && Symbol.for ? Symbol.for('jest.asymmetricMatcher') : 0x1357a5;
+        var SPACE = ' ';
+        var serialize = function serialize(val, config, indentation, depth, refs, printer) {
+          var stringedValue = val.toString();
+          if (stringedValue === 'ArrayContaining' || stringedValue === 'ArrayNotContaining') {
+            if (++depth > config.maxDepth) {
+              return `[${stringedValue}]`;
+            }
+            return `${stringedValue + SPACE}[${(0, _collections.printListItems)(val.sample, config, indentation, depth, refs, printer)}]`;
+          }
+          if (stringedValue === 'ObjectContaining' || stringedValue === 'ObjectNotContaining') {
+            if (++depth > config.maxDepth) {
+              return `[${stringedValue}]`;
+            }
+            return `${stringedValue + SPACE}{${(0, _collections.printObjectProperties)(val.sample, config, indentation, depth, refs, printer)}}`;
+          }
+          if (stringedValue === 'StringMatching' || stringedValue === 'StringNotMatching') {
+            return stringedValue + SPACE + printer(val.sample, config, indentation, depth, refs);
+          }
+          if (stringedValue === 'StringContaining' || stringedValue === 'StringNotContaining') {
+            return stringedValue + SPACE + printer(val.sample, config, indentation, depth, refs);
+          }
+          if (stringedValue === 'ArrayOf' || stringedValue === 'NotArrayOf') {
+            if (++depth > config.maxDepth) {
+              return `[${stringedValue}]`;
+            }
+            return `${stringedValue + SPACE}${printer(val.sample, config, indentation, depth, refs)}`;
+          }
+          if (typeof val.toAsymmetricMatcher !== 'function') {
+            throw new TypeError(`Asymmetric matcher ${val.constructor.name} does not implement toAsymmetricMatcher()`);
+          }
+          return val.toAsymmetricMatcher();
+        };
+        exports.serialize = serialize;
+        var test = function test(val) {
+          return val && val.$$typeof === asymmetricMatcher;
+        };
+        exports.test = test;
+        var plugin = {
+          serialize: serialize,
+          test: test
+        };
+        var _default = exports["default"] = plugin;
+
+        /***/
+      }),
+      /***/"./src/plugins/DOMCollection.ts": (/***/function _src_plugins_DOMCollectionTs(__unused_webpack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+          value: true
+        });
+        exports.test = exports.serialize = exports["default"] = void 0;
+        var _collections = __webpack_require__("./src/collections.ts");
+        /**
+         * 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.
+         */
+
+        var SPACE = ' ';
+        var OBJECT_NAMES = new Set(['DOMStringMap', 'NamedNodeMap']);
+        var ARRAY_REGEXP = /^(HTML\w*Collection|NodeList)$/;
+        var testName = function testName(name) {
+          return OBJECT_NAMES.has(name) || ARRAY_REGEXP.test(name);
+        };
+        var test = function test(val) {
+          return val && val.constructor && !!val.constructor.name && testName(val.constructor.name);
+        };
+        exports.test = test;
+        var isNamedNodeMap = function isNamedNodeMap(collection) {
+          return collection.constructor.name === 'NamedNodeMap';
+        };
+        var serialize = function serialize(collection, config, indentation, depth, refs, printer) {
+          var name = collection.constructor.name;
+          if (++depth > config.maxDepth) {
+            return `[${name}]`;
+          }
+          return (config.min ? '' : name + SPACE) + (OBJECT_NAMES.has(name) ? `{${(0, _collections.printObjectProperties)(isNamedNodeMap(collection) ? _toConsumableArray(collection).reduce(function (props, attribute) {
+            props[attribute.name] = attribute.value;
+            return props;
+          }, {}) : Object.assign({}, collection), config, indentation, depth, refs, printer)}}` : `[${(0, _collections.printListItems)(_toConsumableArray(collection), config, indentation, depth, refs, printer)}]`);
+        };
+        exports.serialize = serialize;
+        var plugin = {
+          serialize: serialize,
+          test: test
+        };
+        var _default = exports["default"] = plugin;
+
+        /***/
+      }),
+      /***/"./src/plugins/DOMElement.ts": (/***/function _src_plugins_DOMElementTs(__unused_webpack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+          value: true
+        });
+        exports.test = exports.serialize = exports["default"] = void 0;
+        var _markup = __webpack_require__("./src/plugins/lib/markup.ts");
+        /**
+         * 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.
+         */
+
+        var ELEMENT_NODE = 1;
+        var TEXT_NODE = 3;
+        var COMMENT_NODE = 8;
+        var FRAGMENT_NODE = 11;
+        var ELEMENT_REGEXP = /^((HTML|SVG)\w*)?Element$/;
+        var testHasAttribute = function testHasAttribute(val) {
+          try {
+            return typeof val.hasAttribute === 'function' && val.hasAttribute('is');
+          } catch (_unused) {
+            return false;
+          }
+        };
+        var isCustomElement = function isCustomElement(val) {
+          var tagName = val == null ? void 0 : val.tagName;
+          return typeof tagName === 'string' && tagName.includes('-') || testHasAttribute(val);
+        };
+        var testNode = function testNode(val) {
+          var constructorName = val.constructor.name;
+          var nodeType = val.nodeType;
+          return nodeType === ELEMENT_NODE && (ELEMENT_REGEXP.test(constructorName) || isCustomElement(val)) || nodeType === TEXT_NODE && constructorName === 'Text' || nodeType === COMMENT_NODE && constructorName === 'Comment' || nodeType === FRAGMENT_NODE && constructorName === 'DocumentFragment';
+        };
+        var test = function test(val) {
+          var _val$constructor;
+          return ((val == null || (_val$constructor = val.constructor) == null ? void 0 : _val$constructor.name) || isCustomElement(val)) && testNode(val);
+        };
+        exports.test = test;
+        function nodeIsText(node) {
+          return node.nodeType === TEXT_NODE;
+        }
+        function nodeIsComment(node) {
+          return node.nodeType === COMMENT_NODE;
+        }
+        function nodeIsFragment(node) {
+          return node.nodeType === FRAGMENT_NODE;
+        }
+        var serialize = function serialize(node, config, indentation, depth, refs, printer) {
+          if (nodeIsText(node)) {
+            return (0, _markup.printText)(node.data, config);
+          }
+          if (nodeIsComment(node)) {
+            return (0, _markup.printComment)(node.data, config);
+          }
+          var type = nodeIsFragment(node) ? 'DocumentFragment' : node.tagName.toLowerCase();
+          if (++depth > config.maxDepth) {
+            return (0, _markup.printElementAsLeaf)(type, config);
+          }
+          return (0, _markup.printElement)(type, (0, _markup.printProps)(nodeIsFragment(node) ? [] : Array.from(node.attributes, function (attr) {
+            return attr.name;
+          }).sort(), nodeIsFragment(node) ? {} : _toConsumableArray(node.attributes).reduce(function (props, attribute) {
+            props[attribute.name] = attribute.value;
+            return props;
+          }, {}), config, indentation + config.indent, depth, refs, printer), (0, _markup.printChildren)(Array.prototype.slice.call(node.childNodes || node.children), config, indentation + config.indent, depth, refs, printer), config, indentation);
+        };
+        exports.serialize = serialize;
+        var plugin = {
+          serialize: serialize,
+          test: test
+        };
+        var _default = exports["default"] = plugin;
+
+        /***/
+      }),
+      /***/"./src/plugins/Immutable.ts": (/***/function _src_plugins_ImmutableTs(__unused_webpack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+          value: true
+        });
+        exports.test = exports.serialize = exports["default"] = void 0;
+        var _collections = __webpack_require__("./src/collections.ts");
+        /**
+         * 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.
+         */
+
+        // SENTINEL constants are from https://github.com/facebook/immutable-js
+        var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';
+        var IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@';
+        var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
+        var IS_MAP_SENTINEL = '@@__IMMUTABLE_MAP__@@';
+        var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';
+        var IS_RECORD_SENTINEL = '@@__IMMUTABLE_RECORD__@@'; // immutable v4
+        var IS_SEQ_SENTINEL = '@@__IMMUTABLE_SEQ__@@';
+        var IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';
+        var IS_STACK_SENTINEL = '@@__IMMUTABLE_STACK__@@';
+        var getImmutableName = function getImmutableName(name) {
+          return `Immutable.${name}`;
+        };
+        var printAsLeaf = function printAsLeaf(name) {
+          return `[${name}]`;
+        };
+        var SPACE = ' ';
+        var LAZY = '…'; // Seq is lazy if it calls a method like filter
+
+        var printImmutableEntries = function printImmutableEntries(val, config, indentation, depth, refs, printer, type) {
+          return ++depth > config.maxDepth ? printAsLeaf(getImmutableName(type)) : `${getImmutableName(type) + SPACE}{${(0, _collections.printIteratorEntries)(val.entries(), config, indentation, depth, refs, printer)}}`;
+        };
+
+        // Record has an entries method because it is a collection in immutable v3.
+        // Return an iterator for Immutable Record from version v3 or v4.
+        function getRecordEntries(val) {
+          var i = 0;
+          return {
+            next: function next() {
+              if (i < val._keys.length) {
+                var key = val._keys[i++];
+                return {
+                  done: false,
+                  value: [key, val.get(key)]
+                };
+              }
+              return {
+                done: true,
+                value: undefined
+              };
+            }
+          };
+        }
+        var printImmutableRecord = function printImmutableRecord(val, config, indentation, depth, refs, printer) {
+          // _name property is defined only for an Immutable Record instance
+          // which was constructed with a second optional descriptive name arg
+          var name = getImmutableName(val._name || 'Record');
+          return ++depth > config.maxDepth ? printAsLeaf(name) : `${name + SPACE}{${(0, _collections.printIteratorEntries)(getRecordEntries(val), config, indentation, depth, refs, printer)}}`;
+        };
+        var printImmutableSeq = function printImmutableSeq(val, config, indentation, depth, refs, printer) {
+          var name = getImmutableName('Seq');
+          if (++depth > config.maxDepth) {
+            return printAsLeaf(name);
+          }
+          if (val[IS_KEYED_SENTINEL]) {
+            return `${name + SPACE}{${
+            // from Immutable collection of entries or from ECMAScript object
+            val._iter || val._object ? (0, _collections.printIteratorEntries)(val.entries(), config, indentation, depth, refs, printer) : LAZY}}`;
+          }
+          return `${name + SPACE}[${val._iter ||
+          // from Immutable collection of values
+          val._array ||
+          // from ECMAScript array
+          val._collection ||
+          // from ECMAScript collection in immutable v4
+          val._iterable // from ECMAScript collection in immutable v3
+          ? (0, _collections.printIteratorValues)(val.values(), config, indentation, depth, refs, printer) : LAZY}]`;
+        };
+        var printImmutableValues = function printImmutableValues(val, config, indentation, depth, refs, printer, type) {
+          return ++depth > config.maxDepth ? printAsLeaf(getImmutableName(type)) : `${getImmutableName(type) + SPACE}[${(0, _collections.printIteratorValues)(val.values(), config, indentation, depth, refs, printer)}]`;
+        };
+        var serialize = function serialize(val, config, indentation, depth, refs, printer) {
+          if (val[IS_MAP_SENTINEL]) {
+            return printImmutableEntries(val, config, indentation, depth, refs, printer, val[IS_ORDERED_SENTINEL] ? 'OrderedMap' : 'Map');
+          }
+          if (val[IS_LIST_SENTINEL]) {
+            return printImmutableValues(val, config, indentation, depth, refs, printer, 'List');
+          }
+          if (val[IS_SET_SENTINEL]) {
+            return printImmutableValues(val, config, indentation, depth, refs, printer, val[IS_ORDERED_SENTINEL] ? 'OrderedSet' : 'Set');
+          }
+          if (val[IS_STACK_SENTINEL]) {
+            return printImmutableValues(val, config, indentation, depth, refs, printer, 'Stack');
+          }
+          if (val[IS_SEQ_SENTINEL]) {
+            return printImmutableSeq(val, config, indentation, depth, refs, printer);
+          }
+
+          // For compatibility with immutable v3 and v4, let record be the default.
+          return printImmutableRecord(val, config, indentation, depth, refs, printer);
+        };
+
+        // Explicitly comparing sentinel properties to true avoids false positive
+        // when mock identity-obj-proxy returns the key as the value for any key.
+        exports.serialize = serialize;
+        var test = function test(val) {
+          return val && (val[IS_ITERABLE_SENTINEL] === true || val[IS_RECORD_SENTINEL] === true);
+        };
+        exports.test = test;
+        var plugin = {
+          serialize: serialize,
+          test: test
+        };
+        var _default = exports["default"] = plugin;
+
+        /***/
+      }),
+      /***/"./src/plugins/ReactElement.ts": (/***/function _src_plugins_ReactElementTs(__unused_webpack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+          value: true
+        });
+        exports.test = exports.serialize = exports["default"] = void 0;
+        var ReactIs = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "react-is"));
+        var _markup = __webpack_require__("./src/plugins/lib/markup.ts");
+        function _interopRequireWildcard(e, t) {
+          if ("function" == typeof WeakMap) var r = new WeakMap(),
+            n = new WeakMap();
+          return (_interopRequireWildcard = function _interopRequireWildcard(e, t) {
+            if (!t && e && e.__esModule) return e;
+            var o,
+              i,
+              f = {
+                __proto__: null,
+                default: e
+              };
+            if (null === e || "object" != typeof e && "function" != typeof e) return f;
+            if (o = t ? n : r) {
+              if (o.has(e)) return o.get(e);
+              o.set(e, f);
+            }
+            for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]);
+            return f;
+          })(e, t);
+        }
+        /**
+         * 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.
+         */
+
+        // Given element.props.children, or subtree during recursive traversal,
+        // return flattened array of children.
+        var _getChildren = function getChildren(arg) {
+          var children = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+          if (Array.isArray(arg)) {
+            for (var item of arg) {
+              _getChildren(item, children);
+            }
+          } else if (arg != null && arg !== false && arg !== '') {
+            children.push(arg);
+          }
+          return children;
+        };
+        var getType = function getType(element) {
+          var type = element.type;
+          if (typeof type === 'string') {
+            return type;
+          }
+          if (typeof type === 'function') {
+            return type.displayName || type.name || 'Unknown';
+          }
+          if (ReactIs.isFragment(element)) {
+            return 'React.Fragment';
+          }
+          if (ReactIs.isSuspense(element)) {
+            return 'React.Suspense';
+          }
+          if (typeof type === 'object' && type !== null) {
+            if (ReactIs.isContextProvider(element)) {
+              return 'Context.Provider';
+            }
+            if (ReactIs.isContextConsumer(element)) {
+              return 'Context.Consumer';
+            }
+            if (ReactIs.isForwardRef(element)) {
+              if (type.displayName) {
+                return type.displayName;
+              }
+              var functionName = type.render.displayName || type.render.name || '';
+              return functionName === '' ? 'ForwardRef' : `ForwardRef(${functionName})`;
+            }
+            if (ReactIs.isMemo(element)) {
+              var _functionName = type.displayName || type.type.displayName || type.type.name || '';
+              return _functionName === '' ? 'Memo' : `Memo(${_functionName})`;
+            }
+          }
+          return 'UNDEFINED';
+        };
+        var getPropKeys = function getPropKeys(element) {
+          var props = element.props;
+          return Object.keys(props).filter(function (key) {
+            return key !== 'children' && props[key] !== undefined;
+          }).sort();
+        };
+        var serialize = function serialize(element, config, indentation, depth, refs, printer) {
+          return ++depth > config.maxDepth ? (0, _markup.printElementAsLeaf)(getType(element), config) : (0, _markup.printElement)(getType(element), (0, _markup.printProps)(getPropKeys(element), element.props, config, indentation + config.indent, depth, refs, printer), (0, _markup.printChildren)(_getChildren(element.props.children), config, indentation + config.indent, depth, refs, printer), config, indentation);
+        };
+        exports.serialize = serialize;
+        var test = function test(val) {
+          return val != null && ReactIs.isElement(val);
+        };
+        exports.test = test;
+        var plugin = {
+          serialize: serialize,
+          test: test
+        };
+        var _default = exports["default"] = plugin;
+
+        /***/
+      }),
+      /***/"./src/plugins/ReactTestComponent.ts": (/***/function _src_plugins_ReactTestComponentTs(__unused_webpack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+          value: true
+        });
+        exports.test = exports.serialize = exports["default"] = void 0;
+        var _markup = __webpack_require__("./src/plugins/lib/markup.ts");
+        var Symbol = globalThis['jest-symbol-do-not-touch'] || globalThis.Symbol;
+        /**
+         * 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.
+         */
+        // Child can be `number` in Stack renderer but not in Fiber renderer.
+
+        var testSymbol = typeof Symbol === 'function' && Symbol.for ? Symbol.for('react.test.json') : 0xea71357;
+        var getPropKeys = function getPropKeys(object) {
+          var props = object.props;
+          return props ? Object.keys(props).filter(function (key) {
+            return props[key] !== undefined;
+          }).sort() : [];
+        };
+        var serialize = function serialize(object, config, indentation, depth, refs, printer) {
+          return ++depth > config.maxDepth ? (0, _markup.printElementAsLeaf)(object.type, config) : (0, _markup.printElement)(object.type, object.props ? (0, _markup.printProps)(getPropKeys(object), object.props, config, indentation + config.indent, depth, refs, printer) : '', object.children ? (0, _markup.printChildren)(object.children, config, indentation + config.indent, depth, refs, printer) : '', config, indentation);
+        };
+        exports.serialize = serialize;
+        var test = function test(val) {
+          return val && val.$$typeof === testSymbol;
+        };
+        exports.test = test;
+        var plugin = {
+          serialize: serialize,
+          test: test
+        };
+        var _default = exports["default"] = plugin;
+
+        /***/
+      }),
+      /***/"./src/plugins/lib/escapeHTML.ts": (/***/function _src_plugins_lib_escapeHTMLTs(__unused_webpack_module, exports) {
+        Object.defineProperty(exports, "__esModule", {
+          value: true
+        });
+        exports["default"] = escapeHTML;
+        /**
+         * 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.
+         */
+
+        function escapeHTML(str) {
+          return str.replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+        }
+
+        /***/
+      }),
+      /***/"./src/plugins/lib/markup.ts": (/***/function _src_plugins_lib_markupTs(__unused_webpack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+          value: true
+        });
+        exports.printText = exports.printProps = exports.printElementAsLeaf = exports.printElement = exports.printComment = exports.printChildren = void 0;
+        var _escapeHTML = _interopRequireDefault(__webpack_require__("./src/plugins/lib/escapeHTML.ts"));
+        function _interopRequireDefault(e) {
+          return e && e.__esModule ? e : {
+            default: e
+          };
+        }
+        /**
+         * 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.
+         */
+
+        // Return empty string if keys is empty.
+        var printProps = function printProps(keys, props, config, indentation, depth, refs, printer) {
+          var indentationNext = indentation + config.indent;
+          var colors = config.colors;
+          return keys.map(function (key) {
+            var value = props[key];
+            var printed = printer(value, config, indentationNext, depth, refs);
+            if (typeof value !== 'string') {
+              if (printed.includes('\n')) {
+                printed = config.spacingOuter + indentationNext + printed + config.spacingOuter + indentation;
+              }
+              printed = `{${printed}}`;
+            }
+            return `${config.spacingInner + indentation + colors.prop.open + key + colors.prop.close}=${colors.value.open}${printed}${colors.value.close}`;
+          }).join('');
+        };
+
+        // Return empty string if children is empty.
+        exports.printProps = printProps;
+        var printChildren = function printChildren(children, config, indentation, depth, refs, printer) {
+          return children.map(function (child) {
+            return config.spacingOuter + indentation + (typeof child === 'string' ? printText(child, config) : printer(child, config, indentation, depth, refs));
+          }).join('');
+        };
+        exports.printChildren = printChildren;
+        var printText = function printText(text, config) {
+          var contentColor = config.colors.content;
+          return contentColor.open + (0, _escapeHTML.default)(text) + contentColor.close;
+        };
+        exports.printText = printText;
+        var printComment = function printComment(comment, config) {
+          var commentColor = config.colors.comment;
+          return `${commentColor.open}<!--${(0, _escapeHTML.default)(comment)}-->${commentColor.close}`;
+        };
+
+        // Separate the functions to format props, children, and element,
+        // so a plugin could override a particular function, if needed.
+        // Too bad, so sad: the traditional (but unnecessary) space
+        // in a self-closing tagColor requires a second test of printedProps.
+        exports.printComment = printComment;
+        var printElement = function printElement(type, printedProps, printedChildren, config, indentation) {
+          var tagColor = config.colors.tag;
+          return `${tagColor.open}<${type}${printedProps && tagColor.close + printedProps + config.spacingOuter + indentation + tagColor.open}${printedChildren ? `>${tagColor.close}${printedChildren}${config.spacingOuter}${indentation}${tagColor.open}</${type}` : `${printedProps && !config.min ? '' : ' '}/`}>${tagColor.close}`;
+        };
+        exports.printElement = printElement;
+        var printElementAsLeaf = function printElementAsLeaf(type, config) {
+          var tagColor = config.colors.tag;
+          return `${tagColor.open}<${type}${tagColor.close} …${tagColor.open} />${tagColor.close}`;
+        };
+        exports.printElementAsLeaf = printElementAsLeaf;
+
+        /***/
+      })
+
+      /******/
+    };
+    /************************************************************************/
+    /******/ // The module cache
+    /******/
+    var __webpack_module_cache__ = {};
+    /******/
+    /******/ // The require function
+    /******/
+    function __webpack_require__(moduleId) {
+      /******/ // Check if module is in cache
+      /******/var cachedModule = __webpack_module_cache__[moduleId];
+      /******/
+      if (cachedModule !== undefined) {
+        /******/return cachedModule.exports;
+        /******/
+      }
+      /******/ // Create a new module (and put it into the cache)
+      /******/
+      var module = __webpack_module_cache__[moduleId] = {
+        /******/ // no module.id needed
+        /******/ // no module.loaded needed
+        /******/exports: {}
+        /******/
+      };
+      /******/
+      /******/ // Execute the module function
+      /******/
+      __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+      /******/
+      /******/ // Return the exports of the module
+      /******/
+      return module.exports;
+      /******/
+    }
+    /******/
+    /************************************************************************/
+    var __webpack_exports__ = {};
+    // This entry needs to be wrapped in an IIFE because it uses a non-standard name for the exports (exports).
+    (function () {
+      var exports = __webpack_exports__;
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports["default"] = exports.DEFAULT_OPTIONS = void 0;
+      exports.format = format;
+      exports.plugins = void 0;
+      var _ansiStyles = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "ansi-styles"));
+      var _collections = __webpack_require__("./src/collections.ts");
+      var _AsymmetricMatcher = _interopRequireDefault(__webpack_require__("./src/plugins/AsymmetricMatcher.ts"));
+      var _DOMCollection = _interopRequireDefault(__webpack_require__("./src/plugins/DOMCollection.ts"));
+      var _DOMElement = _interopRequireDefault(__webpack_require__("./src/plugins/DOMElement.ts"));
+      var _Immutable = _interopRequireDefault(__webpack_require__("./src/plugins/Immutable.ts"));
+      var _ReactElement = _interopRequireDefault(__webpack_require__("./src/plugins/ReactElement.ts"));
+      var _ReactTestComponent = _interopRequireDefault(__webpack_require__("./src/plugins/ReactTestComponent.ts"));
+      function _interopRequireDefault(e) {
+        return e && e.__esModule ? e : {
+          default: e
+        };
+      }
+      /**
+       * 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.
+       */
+
+      var src_toString = Object.prototype.toString;
+      var toISOString = Date.prototype.toISOString;
+      var errorToString = Error.prototype.toString;
+      var regExpToString = RegExp.prototype.toString;
+
+      /**
+       * Explicitly comparing typeof constructor to function avoids undefined as name
+       * when mock identity-obj-proxy returns the key as the value for any key.
+       */
+      var getConstructorName = function getConstructorName(val) {
+        return typeof val.constructor === 'function' && val.constructor.name || 'Object';
+      };
+
+      /* global window */
+      /** Is val is equal to global window object? Works even if it does not exist :) */
+      var isWindow = function isWindow(val) {
+        return (
+          // eslint-disable-next-line unicorn/prefer-global-this
+          typeof window !== 'undefined' && val === window
+        );
+      };
+      var SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;
+      var NEWLINE_REGEXP = /\n/gi;
+      var PrettyFormatPluginError = /*#__PURE__*/function (_Error) {
+        function PrettyFormatPluginError(message, stack) {
+          var _this;
+          _classCallCheck(this, PrettyFormatPluginError);
+          _this = _callSuper(this, PrettyFormatPluginError, [message]);
+          _this.stack = stack;
+          _this.name = _this.constructor.name;
+          return _this;
+        }
+        _inherits(PrettyFormatPluginError, _Error);
+        return _createClass(PrettyFormatPluginError);
+      }(/*#__PURE__*/_wrapNativeSuper(Error));
+      function isToStringedArrayType(toStringed) {
+        return toStringed === '[object Array]' || toStringed === '[object ArrayBuffer]' || toStringed === '[object DataView]' || toStringed === '[object Float32Array]' || toStringed === '[object Float64Array]' || toStringed === '[object Int8Array]' || toStringed === '[object Int16Array]' || toStringed === '[object Int32Array]' || toStringed === '[object Uint8Array]' || toStringed === '[object Uint8ClampedArray]' || toStringed === '[object Uint16Array]' || toStringed === '[object Uint32Array]';
+      }
+      function printNumber(val) {
+        return Object.is(val, -0) ? '-0' : String(val);
+      }
+      function printBigInt(val) {
+        return String(`${val}n`);
+      }
+      function printFunction(val, printFunctionName) {
+        if (!printFunctionName) {
+          return '[Function]';
+        }
+        return `[Function ${val.name || 'anonymous'}]`;
+      }
+      function printSymbol(val) {
+        return String(val).replace(SYMBOL_REGEXP, 'Symbol($1)');
+      }
+      function printError(val) {
+        return `[${errorToString.call(val)}]`;
+      }
+
+      /**
+       * The first port of call for printing an object, handles most of the
+       * data-types in JS.
+       */
+      function printBasicValue(val, printFunctionName, escapeRegex, escapeString) {
+        if (val === true || val === false) {
+          return `${val}`;
+        }
+        if (val === undefined) {
+          return 'undefined';
+        }
+        if (val === null) {
+          return 'null';
+        }
+        var typeOf = typeof val;
+        if (typeOf === 'number') {
+          return printNumber(val);
+        }
+        if (typeOf === 'bigint') {
+          return printBigInt(val);
+        }
+        if (typeOf === 'string') {
+          if (escapeString) {
+            return `"${val.replaceAll(/"|\\/g, '\\$&')}"`;
+          }
+          return `"${val}"`;
+        }
+        if (typeOf === 'function') {
+          return printFunction(val, printFunctionName);
+        }
+        if (typeOf === 'symbol') {
+          return printSymbol(val);
+        }
+        var toStringed = src_toString.call(val);
+        if (toStringed === '[object WeakMap]') {
+          return 'WeakMap {}';
+        }
+        if (toStringed === '[object WeakSet]') {
+          return 'WeakSet {}';
+        }
+        if (toStringed === '[object Function]' || toStringed === '[object GeneratorFunction]') {
+          return printFunction(val, printFunctionName);
+        }
+        if (toStringed === '[object Symbol]') {
+          return printSymbol(val);
+        }
+        if (toStringed === '[object Date]') {
+          return Number.isNaN(+val) ? 'Date { NaN }' : toISOString.call(val);
+        }
+        if (toStringed === '[object Error]') {
+          return printError(val);
+        }
+        if (toStringed === '[object RegExp]') {
+          if (escapeRegex) {
+            // https://github.com/benjamingr/RegExp.escape/blob/main/polyfill.js
+            return regExpToString.call(val).replaceAll(/[$()*+.?[\\\]^{|}]/g, '\\$&');
+          }
+          return regExpToString.call(val);
+        }
+        if (val instanceof Error) {
+          return printError(val);
+        }
+        return null;
+      }
+
+      /**
+       * Handles more complex objects ( such as objects with circular references.
+       * maps and sets etc )
+       */
+      function printComplexValue(val, config, indentation, depth, refs, hasCalledToJSON) {
+        if (refs.includes(val)) {
+          return '[Circular]';
+        }
+        refs = _toConsumableArray(refs);
+        refs.push(val);
+        var hitMaxDepth = ++depth > config.maxDepth;
+        var min = config.min;
+        if (config.callToJSON && !hitMaxDepth && val.toJSON && typeof val.toJSON === 'function' && !hasCalledToJSON) {
+          return printer(val.toJSON(), config, indentation, depth, refs, true);
+        }
+        var toStringed = src_toString.call(val);
+        if (toStringed === '[object Arguments]') {
+          return hitMaxDepth ? '[Arguments]' : `${min ? '' : 'Arguments '}[${(0, _collections.printListItems)(val, config, indentation, depth, refs, printer)}]`;
+        }
+        if (isToStringedArrayType(toStringed)) {
+          return hitMaxDepth ? `[${val.constructor.name}]` : `${min ? '' : !config.printBasicPrototype && val.constructor.name === 'Array' ? '' : `${val.constructor.name} `}[${(0, _collections.printListItems)(val, config, indentation, depth, refs, printer)}]`;
+        }
+        if (toStringed === '[object Map]') {
+          return hitMaxDepth ? '[Map]' : `Map {${(0, _collections.printIteratorEntries)(val.entries(), config, indentation, depth, refs, printer, ' => ')}}`;
+        }
+        if (toStringed === '[object Set]') {
+          return hitMaxDepth ? '[Set]' : `Set {${(0, _collections.printIteratorValues)(val.values(), config, indentation, depth, refs, printer)}}`;
+        }
+
+        // Avoid failure to serialize global window object in jsdom test environment.
+        // For example, not even relevant if window is prop of React element.
+        return hitMaxDepth || isWindow(val) ? `[${getConstructorName(val)}]` : `${min ? '' : !config.printBasicPrototype && getConstructorName(val) === 'Object' ? '' : `${getConstructorName(val)} `}{${(0, _collections.printObjectProperties)(val, config, indentation, depth, refs, printer)}}`;
+      }
+      function isNewPlugin(plugin) {
+        return plugin.serialize != null;
+      }
+      function printPlugin(plugin, val, config, indentation, depth, refs) {
+        var printed;
+        try {
+          printed = isNewPlugin(plugin) ? plugin.serialize(val, config, indentation, depth, refs, printer) : plugin.print(val, function (valChild) {
+            return printer(valChild, config, indentation, depth, refs);
+          }, function (str) {
+            var indentationNext = indentation + config.indent;
+            return indentationNext + str.replaceAll(NEWLINE_REGEXP, `\n${indentationNext}`);
+          }, {
+            edgeSpacing: config.spacingOuter,
+            min: config.min,
+            spacing: config.spacingInner
+          }, config.colors);
+        } catch (error) {
+          throw new PrettyFormatPluginError(error.message, error.stack);
+        }
+        if (typeof printed !== 'string') {
+          throw new TypeError(`pretty-format: Plugin must return type "string" but instead returned "${typeof printed}".`);
+        }
+        return printed;
+      }
+      function findPlugin(plugins, val) {
+        for (var plugin of plugins) {
+          try {
+            if (plugin.test(val)) {
+              return plugin;
+            }
+          } catch (error) {
+            throw new PrettyFormatPluginError(error.message, error.stack);
+          }
+        }
+        return null;
+      }
+      function printer(val, config, indentation, depth, refs, hasCalledToJSON) {
+        var plugin = findPlugin(config.plugins, val);
+        if (plugin !== null) {
+          return printPlugin(plugin, val, config, indentation, depth, refs);
+        }
+        var basicResult = printBasicValue(val, config.printFunctionName, config.escapeRegex, config.escapeString);
+        if (basicResult !== null) {
+          return basicResult;
+        }
+        return printComplexValue(val, config, indentation, depth, refs, hasCalledToJSON);
+      }
+      var DEFAULT_THEME = {
+        comment: 'gray',
+        content: 'reset',
+        prop: 'yellow',
+        tag: 'cyan',
+        value: 'green'
+      };
+      var DEFAULT_THEME_KEYS = Object.keys(DEFAULT_THEME);
+
+      // could be replaced by `satisfies` operator in the future: https://github.com/microsoft/TypeScript/issues/47920
+      var toOptionsSubtype = function toOptionsSubtype(options) {
+        return options;
+      };
+      var DEFAULT_OPTIONS = exports.DEFAULT_OPTIONS = toOptionsSubtype({
+        callToJSON: true,
+        compareKeys: undefined,
+        escapeRegex: false,
+        escapeString: true,
+        highlight: false,
+        indent: 2,
+        maxDepth: Number.POSITIVE_INFINITY,
+        maxWidth: Number.POSITIVE_INFINITY,
+        min: false,
+        plugins: [],
+        printBasicPrototype: true,
+        printFunctionName: true,
+        theme: DEFAULT_THEME
+      });
+      function validateOptions(options) {
+        for (var key of Object.keys(options)) {
+          if (!Object.prototype.hasOwnProperty.call(DEFAULT_OPTIONS, key)) {
+            throw new Error(`pretty-format: Unknown option "${key}".`);
+          }
+        }
+        if (options.min && options.indent !== undefined && options.indent !== 0) {
+          throw new Error('pretty-format: Options "min" and "indent" cannot be used together.');
+        }
+        if (options.theme !== undefined) {
+          if (options.theme === null) {
+            throw new Error('pretty-format: Option "theme" must not be null.');
+          }
+          if (typeof options.theme !== 'object') {
+            throw new TypeError(`pretty-format: Option "theme" must be of type "object" but instead received "${typeof options.theme}".`);
+          }
+        }
+      }
+      var getColorsHighlight = function getColorsHighlight(options) {
+        return DEFAULT_THEME_KEYS.reduce(function (colors, key) {
+          var value = options.theme && options.theme[key] !== undefined ? options.theme[key] : DEFAULT_THEME[key];
+          var color = value && _ansiStyles.default[value];
+          if (color && typeof color.close === 'string' && typeof color.open === 'string') {
+            colors[key] = color;
+          } else {
+            throw new Error(`pretty-format: Option "theme" has a key "${key}" whose value "${value}" is undefined in ansi-styles.`);
+          }
+          return colors;
+        }, Object.create(null));
+      };
+      var getColorsEmpty = function getColorsEmpty() {
+        return DEFAULT_THEME_KEYS.reduce(function (colors, key) {
+          colors[key] = {
+            close: '',
+            open: ''
+          };
+          return colors;
+        }, Object.create(null));
+      };
+      var getPrintFunctionName = function getPrintFunctionName(options) {
+        var _options$printFunctio;
+        return (_options$printFunctio = options == null ? void 0 : options.printFunctionName) != null ? _options$printFunctio : DEFAULT_OPTIONS.printFunctionName;
+      };
+      var getEscapeRegex = function getEscapeRegex(options) {
+        var _options$escapeRegex;
+        return (_options$escapeRegex = options == null ? void 0 : options.escapeRegex) != null ? _options$escapeRegex : DEFAULT_OPTIONS.escapeRegex;
+      };
+      var getEscapeString = function getEscapeString(options) {
+        var _options$escapeString;
+        return (_options$escapeString = options == null ? void 0 : options.escapeString) != null ? _options$escapeString : DEFAULT_OPTIONS.escapeString;
+      };
+      var getConfig = function getConfig(options) {
+        var _options$callToJSON, _options$indent, _options$maxDepth, _options$maxWidth, _options$min, _options$plugins, _options$printBasicPr;
+        return {
+          callToJSON: (_options$callToJSON = options == null ? void 0 : options.callToJSON) != null ? _options$callToJSON : DEFAULT_OPTIONS.callToJSON,
+          colors: options != null && options.highlight ? getColorsHighlight(options) : getColorsEmpty(),
+          compareKeys: typeof (options == null ? void 0 : options.compareKeys) === 'function' || (options == null ? void 0 : options.compareKeys) === null ? options.compareKeys : DEFAULT_OPTIONS.compareKeys,
+          escapeRegex: getEscapeRegex(options),
+          escapeString: getEscapeString(options),
+          indent: options != null && options.min ? '' : createIndent((_options$indent = options == null ? void 0 : options.indent) != null ? _options$indent : DEFAULT_OPTIONS.indent),
+          maxDepth: (_options$maxDepth = options == null ? void 0 : options.maxDepth) != null ? _options$maxDepth : DEFAULT_OPTIONS.maxDepth,
+          maxWidth: (_options$maxWidth = options == null ? void 0 : options.maxWidth) != null ? _options$maxWidth : DEFAULT_OPTIONS.maxWidth,
+          min: (_options$min = options == null ? void 0 : options.min) != null ? _options$min : DEFAULT_OPTIONS.min,
+          plugins: (_options$plugins = options == null ? void 0 : options.plugins) != null ? _options$plugins : DEFAULT_OPTIONS.plugins,
+          printBasicPrototype: (_options$printBasicPr = options == null ? void 0 : options.printBasicPrototype) != null ? _options$printBasicPr : true,
+          printFunctionName: getPrintFunctionName(options),
+          spacingInner: options != null && options.min ? ' ' : '\n',
+          spacingOuter: options != null && options.min ? '' : '\n'
+        };
+      };
+      function createIndent(indent) {
+        return Array.from({
+          length: indent + 1
+        }).join(' ');
+      }
+
+      /**
+       * Returns a presentation string of your `val` object
+       * @param val any potential JavaScript object
+       * @param options Custom settings
+       */
+      function format(val, options) {
+        if (options) {
+          validateOptions(options);
+          if (options.plugins) {
+            var plugin = findPlugin(options.plugins, val);
+            if (plugin !== null) {
+              return printPlugin(plugin, val, getConfig(options), '', 0, []);
+            }
+          }
+        }
+        var basicResult = printBasicValue(val, getPrintFunctionName(options), getEscapeRegex(options), getEscapeString(options));
+        if (basicResult !== null) {
+          return basicResult;
+        }
+        return printComplexValue(val, getConfig(options), '', 0, []);
+      }
+      var plugins = exports.plugins = {
+        AsymmetricMatcher: _AsymmetricMatcher.default,
+        DOMCollection: _DOMCollection.default,
+        DOMElement: _DOMElement.default,
+        Immutable: _Immutable.default,
+        ReactElement: _ReactElement.default,
+        ReactTestComponent: _ReactTestComponent.default
+      };
+      var _default = exports["default"] = format;
+    })();
+    module.exports = __webpack_exports__;
+    /******/
+  })();
+},184,[12,11,18,20,23,175,42,185,188],"../../node_modules/pretty-format/build/index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  if (process.env.NODE_ENV === 'production') {
+    module.exports = _$$_REQUIRE(_dependencyMap[0], "./cjs/react-is.production.js");
+  } else {
+    module.exports = _$$_REQUIRE(_dependencyMap[1], "./cjs/react-is.development.js");
+  }
+},185,[186,187],"../../node_modules/react-is/index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  /**
+   * @license React
+   * react-is.production.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_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
+    REACT_PORTAL_TYPE = Symbol.for("react.portal"),
+    REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
+    REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
+    REACT_PROFILER_TYPE = Symbol.for("react.profiler");
+  Symbol.for("react.provider");
+  var REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
+    REACT_CONTEXT_TYPE = Symbol.for("react.context"),
+    REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
+    REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
+    REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
+    REACT_MEMO_TYPE = Symbol.for("react.memo"),
+    REACT_LAZY_TYPE = Symbol.for("react.lazy"),
+    REACT_VIEW_TRANSITION_TYPE = Symbol.for("react.view_transition"),
+    REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
+  function typeOf(object) {
+    if ("object" === typeof object && null !== object) {
+      var $$typeof = object.$$typeof;
+      switch ($$typeof) {
+        case REACT_ELEMENT_TYPE:
+          switch (object = object.type, object) {
+            case REACT_FRAGMENT_TYPE:
+            case REACT_PROFILER_TYPE:
+            case REACT_STRICT_MODE_TYPE:
+            case REACT_SUSPENSE_TYPE:
+            case REACT_SUSPENSE_LIST_TYPE:
+            case REACT_VIEW_TRANSITION_TYPE:
+              return object;
+            default:
+              switch (object = object && object.$$typeof, object) {
+                case REACT_CONTEXT_TYPE:
+                case REACT_FORWARD_REF_TYPE:
+                case REACT_LAZY_TYPE:
+                case REACT_MEMO_TYPE:
+                  return object;
+                case REACT_CONSUMER_TYPE:
+                  return object;
+                default:
+                  return $$typeof;
+              }
+          }
+        case REACT_PORTAL_TYPE:
+          return $$typeof;
+      }
+    }
+  }
+  exports.ContextConsumer = REACT_CONSUMER_TYPE;
+  exports.ContextProvider = REACT_CONTEXT_TYPE;
+  exports.Element = REACT_ELEMENT_TYPE;
+  exports.ForwardRef = REACT_FORWARD_REF_TYPE;
+  exports.Fragment = REACT_FRAGMENT_TYPE;
+  exports.Lazy = REACT_LAZY_TYPE;
+  exports.Memo = REACT_MEMO_TYPE;
+  exports.Portal = REACT_PORTAL_TYPE;
+  exports.Profiler = REACT_PROFILER_TYPE;
+  exports.StrictMode = REACT_STRICT_MODE_TYPE;
+  exports.Suspense = REACT_SUSPENSE_TYPE;
+  exports.SuspenseList = REACT_SUSPENSE_LIST_TYPE;
+  exports.isContextConsumer = function (object) {
+    return typeOf(object) === REACT_CONSUMER_TYPE;
+  };
+  exports.isContextProvider = function (object) {
+    return typeOf(object) === REACT_CONTEXT_TYPE;
+  };
+  exports.isElement = function (object) {
+    return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+  };
+  exports.isForwardRef = function (object) {
+    return typeOf(object) === REACT_FORWARD_REF_TYPE;
+  };
+  exports.isFragment = function (object) {
+    return typeOf(object) === REACT_FRAGMENT_TYPE;
+  };
+  exports.isLazy = function (object) {
+    return typeOf(object) === REACT_LAZY_TYPE;
+  };
+  exports.isMemo = function (object) {
+    return typeOf(object) === REACT_MEMO_TYPE;
+  };
+  exports.isPortal = function (object) {
+    return typeOf(object) === REACT_PORTAL_TYPE;
+  };
+  exports.isProfiler = function (object) {
+    return typeOf(object) === REACT_PROFILER_TYPE;
+  };
+  exports.isStrictMode = function (object) {
+    return typeOf(object) === REACT_STRICT_MODE_TYPE;
+  };
+  exports.isSuspense = function (object) {
+    return typeOf(object) === REACT_SUSPENSE_TYPE;
+  };
+  exports.isSuspenseList = function (object) {
+    return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;
+  };
+  exports.isValidElementType = function (type) {
+    return "string" === typeof type || "function" === typeof type || type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || "object" === typeof type && null !== type && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_CONSUMER_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_CLIENT_REFERENCE || void 0 !== type.getModuleId) ? !0 : !1;
+  };
+  exports.typeOf = typeOf;
+},186,[],"../../node_modules/react-is/cjs/react-is.production.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  /**
+   * @license React
+   * react-is.development.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";
+
+  "production" !== process.env.NODE_ENV && function () {
+    function typeOf(object) {
+      if ("object" === typeof object && null !== object) {
+        var $$typeof = object.$$typeof;
+        switch ($$typeof) {
+          case REACT_ELEMENT_TYPE:
+            switch (object = object.type, object) {
+              case REACT_FRAGMENT_TYPE:
+              case REACT_PROFILER_TYPE:
+              case REACT_STRICT_MODE_TYPE:
+              case REACT_SUSPENSE_TYPE:
+              case REACT_SUSPENSE_LIST_TYPE:
+              case REACT_VIEW_TRANSITION_TYPE:
+                return object;
+              default:
+                switch (object = object && object.$$typeof, object) {
+                  case REACT_CONTEXT_TYPE:
+                  case REACT_FORWARD_REF_TYPE:
+                  case REACT_LAZY_TYPE:
+                  case REACT_MEMO_TYPE:
+                    return object;
+                  case REACT_CONSUMER_TYPE:
+                    return object;
+                  default:
+                    return $$typeof;
+                }
+            }
+          case REACT_PORTAL_TYPE:
+            return $$typeof;
+        }
+      }
+    }
+    var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
+      REACT_PORTAL_TYPE = Symbol.for("react.portal"),
+      REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
+      REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
+      REACT_PROFILER_TYPE = Symbol.for("react.profiler");
+    Symbol.for("react.provider");
+    var REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
+      REACT_CONTEXT_TYPE = Symbol.for("react.context"),
+      REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
+      REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
+      REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
+      REACT_MEMO_TYPE = Symbol.for("react.memo"),
+      REACT_LAZY_TYPE = Symbol.for("react.lazy"),
+      REACT_VIEW_TRANSITION_TYPE = Symbol.for("react.view_transition"),
+      REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
+    exports.ContextConsumer = REACT_CONSUMER_TYPE;
+    exports.ContextProvider = REACT_CONTEXT_TYPE;
+    exports.Element = REACT_ELEMENT_TYPE;
+    exports.ForwardRef = REACT_FORWARD_REF_TYPE;
+    exports.Fragment = REACT_FRAGMENT_TYPE;
+    exports.Lazy = REACT_LAZY_TYPE;
+    exports.Memo = REACT_MEMO_TYPE;
+    exports.Portal = REACT_PORTAL_TYPE;
+    exports.Profiler = REACT_PROFILER_TYPE;
+    exports.StrictMode = REACT_STRICT_MODE_TYPE;
+    exports.Suspense = REACT_SUSPENSE_TYPE;
+    exports.SuspenseList = REACT_SUSPENSE_LIST_TYPE;
+    exports.isContextConsumer = function (object) {
+      return typeOf(object) === REACT_CONSUMER_TYPE;
+    };
+    exports.isContextProvider = function (object) {
+      return typeOf(object) === REACT_CONTEXT_TYPE;
+    };
+    exports.isElement = function (object) {
+      return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+    };
+    exports.isForwardRef = function (object) {
+      return typeOf(object) === REACT_FORWARD_REF_TYPE;
+    };
+    exports.isFragment = function (object) {
+      return typeOf(object) === REACT_FRAGMENT_TYPE;
+    };
+    exports.isLazy = function (object) {
+      return typeOf(object) === REACT_LAZY_TYPE;
+    };
+    exports.isMemo = function (object) {
+      return typeOf(object) === REACT_MEMO_TYPE;
+    };
+    exports.isPortal = function (object) {
+      return typeOf(object) === REACT_PORTAL_TYPE;
+    };
+    exports.isProfiler = function (object) {
+      return typeOf(object) === REACT_PROFILER_TYPE;
+    };
+    exports.isStrictMode = function (object) {
+      return typeOf(object) === REACT_STRICT_MODE_TYPE;
+    };
+    exports.isSuspense = function (object) {
+      return typeOf(object) === REACT_SUSPENSE_TYPE;
+    };
+    exports.isSuspenseList = function (object) {
+      return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;
+    };
+    exports.isValidElementType = function (type) {
+      return "string" === typeof type || "function" === typeof type || type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || "object" === typeof type && null !== type && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_CONSUMER_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_CLIENT_REFERENCE || void 0 !== type.getModuleId) ? !0 : !1;
+    };
+    exports.typeOf = typeOf;
+  }();
+},187,[],"../../node_modules/react-is/cjs/react-is.development.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _toConsumableArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/toConsumableArray");
+  var _slicedToArray = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray");
+  var ANSI_BACKGROUND_OFFSET = 10;
+  var wrapAnsi256 = function wrapAnsi256() {
+    var offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    return function (code) {
+      return `\u001B[${38 + offset};5;${code}m`;
+    };
+  };
+  var wrapAnsi16m = function wrapAnsi16m() {
+    var offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    return function (red, green, blue) {
+      return `\u001B[${38 + offset};2;${red};${green};${blue}m`;
+    };
+  };
+  function assembleStyles() {
+    var codes = new Map();
+    var styles = {
+      modifier: {
+        reset: [0, 0],
+        // 21 isn't widely supported and 22 does the same thing
+        bold: [1, 22],
+        dim: [2, 22],
+        italic: [3, 23],
+        underline: [4, 24],
+        overline: [53, 55],
+        inverse: [7, 27],
+        hidden: [8, 28],
+        strikethrough: [9, 29]
+      },
+      color: {
+        black: [30, 39],
+        red: [31, 39],
+        green: [32, 39],
+        yellow: [33, 39],
+        blue: [34, 39],
+        magenta: [35, 39],
+        cyan: [36, 39],
+        white: [37, 39],
+        // Bright color
+        blackBright: [90, 39],
+        redBright: [91, 39],
+        greenBright: [92, 39],
+        yellowBright: [93, 39],
+        blueBright: [94, 39],
+        magentaBright: [95, 39],
+        cyanBright: [96, 39],
+        whiteBright: [97, 39]
+      },
+      bgColor: {
+        bgBlack: [40, 49],
+        bgRed: [41, 49],
+        bgGreen: [42, 49],
+        bgYellow: [43, 49],
+        bgBlue: [44, 49],
+        bgMagenta: [45, 49],
+        bgCyan: [46, 49],
+        bgWhite: [47, 49],
+        // Bright color
+        bgBlackBright: [100, 49],
+        bgRedBright: [101, 49],
+        bgGreenBright: [102, 49],
+        bgYellowBright: [103, 49],
+        bgBlueBright: [104, 49],
+        bgMagentaBright: [105, 49],
+        bgCyanBright: [106, 49],
+        bgWhiteBright: [107, 49]
+      }
+    };
+
+    // Alias bright black as gray (and grey)
+    styles.color.gray = styles.color.blackBright;
+    styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
+    styles.color.grey = styles.color.blackBright;
+    styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
+    for (var _ref of Object.entries(styles)) {
+      var _ref2 = _slicedToArray(_ref, 2);
+      var groupName = _ref2[0];
+      var group = _ref2[1];
+      for (var _ref3 of Object.entries(group)) {
+        var _ref4 = _slicedToArray(_ref3, 2);
+        var styleName = _ref4[0];
+        var style = _ref4[1];
+        styles[styleName] = {
+          open: `\u001B[${style[0]}m`,
+          close: `\u001B[${style[1]}m`
+        };
+        group[styleName] = styles[styleName];
+        codes.set(style[0], style[1]);
+      }
+      Object.defineProperty(styles, groupName, {
+        value: group,
+        enumerable: false
+      });
+    }
+    Object.defineProperty(styles, 'codes', {
+      value: codes,
+      enumerable: false
+    });
+    styles.color.close = "\x1B[39m";
+    styles.bgColor.close = "\x1B[49m";
+    styles.color.ansi256 = wrapAnsi256();
+    styles.color.ansi16m = wrapAnsi16m();
+    styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+    styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+
+    // From https://github.com/Qix-/color-convert/blob/3f0e0d4e92e235796ccb17f6e85c72094a651f49/conversions.js
+    Object.defineProperties(styles, {
+      rgbToAnsi256: {
+        value: function value(red, green, blue) {
+          // We use the extended greyscale palette here, with the exception of
+          // black and white. normal palette only has 4 greyscale shades.
+          if (red === green && green === blue) {
+            if (red < 8) {
+              return 16;
+            }
+            if (red > 248) {
+              return 231;
+            }
+            return Math.round((red - 8) / 247 * 24) + 232;
+          }
+          return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+        },
+        enumerable: false
+      },
+      hexToRgb: {
+        value: function value(hex) {
+          var matches = /(?<colorString>[a-f\d]{6}|[a-f\d]{3})/i.exec(hex.toString(16));
+          if (!matches) {
+            return [0, 0, 0];
+          }
+          var colorString = matches.groups.colorString;
+          if (colorString.length === 3) {
+            colorString = colorString.split('').map(function (character) {
+              return character + character;
+            }).join('');
+          }
+          var integer = Number.parseInt(colorString, 16);
+          return [integer >> 16 & 0xFF, integer >> 8 & 0xFF, integer & 0xFF];
+        },
+        enumerable: false
+      },
+      hexToAnsi256: {
+        value: function value(hex) {
+          return styles.rgbToAnsi256.apply(styles, _toConsumableArray(styles.hexToRgb(hex)));
+        },
+        enumerable: false
+      }
+    });
+    return styles;
+  }
+
+  // Make the export immutable
+  Object.defineProperty(module, 'exports', {
+    enumerable: true,
+    get: assembleStyles
+  });
+},188,[42,34],"../../node_modules/ansi-styles/index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _es6Extensions = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "promise/setimmediate/es6-extensions"));
+  _$$_REQUIRE(_dependencyMap[2], "promise/setimmediate/finally");
+  if (__DEV__) {
+    _$$_REQUIRE(_dependencyMap[3], "promise/setimmediate/rejection-tracking").enable(_$$_REQUIRE(_dependencyMap[4], "./promiseRejectionTrackingOptions").default);
+  }
+  var _default = exports.default = _es6Extensions.default;
+},189,[1,190,192,193,152],"../../node_modules/react-native/Libraries/Promise.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  //This file contains the ES6 extensions to the core Promises/A+ API
+  module.exports = _$$_REQUIRE(_dependencyMap[0], "./core.js");
+
+  /* Static Functions */
+
+  var TRUE = valuePromise(true);
+  var FALSE = valuePromise(false);
+  var NULL = valuePromise(null);
+  var UNDEFINED = valuePromise(undefined);
+  var ZERO = valuePromise(0);
+  var EMPTYSTRING = valuePromise('');
+  function valuePromise(value) {
+    var p = new (_$$_REQUIRE(_dependencyMap[0], "./core.js"))(_$$_REQUIRE(_dependencyMap[0], "./core.js")._D);
+    p._y = 1;
+    p._z = value;
+    return p;
+  }
+  _$$_REQUIRE(_dependencyMap[0], "./core.js").resolve = function (value) {
+    if (value instanceof _$$_REQUIRE(_dependencyMap[0], "./core.js")) return value;
+    if (value === null) return NULL;
+    if (value === undefined) return UNDEFINED;
+    if (value === true) return TRUE;
+    if (value === false) return FALSE;
+    if (value === 0) return ZERO;
+    if (value === '') return EMPTYSTRING;
+    if (typeof value === 'object' || typeof value === 'function') {
+      try {
+        var then = value.then;
+        if (typeof then === 'function') {
+          return new (_$$_REQUIRE(_dependencyMap[0], "./core.js"))(then.bind(value));
+        }
+      } catch (ex) {
+        return new (_$$_REQUIRE(_dependencyMap[0], "./core.js"))(function (resolve, reject) {
+          reject(ex);
+        });
+      }
+    }
+    return valuePromise(value);
+  };
+  var _iterableToArray = function iterableToArray(iterable) {
+    if (typeof Array.from === 'function') {
+      // ES2015+, iterables exist
+      _iterableToArray = Array.from;
+      return Array.from(iterable);
+    }
+
+    // ES5, only arrays and array-likes exist
+    _iterableToArray = function iterableToArray(x) {
+      return Array.prototype.slice.call(x);
+    };
+    return Array.prototype.slice.call(iterable);
+  };
+  _$$_REQUIRE(_dependencyMap[0], "./core.js").all = function (arr) {
+    var args = _iterableToArray(arr);
+    return new (_$$_REQUIRE(_dependencyMap[0], "./core.js"))(function (resolve, reject) {
+      if (args.length === 0) return resolve([]);
+      var remaining = args.length;
+      function res(i, val) {
+        if (val && (typeof val === 'object' || typeof val === 'function')) {
+          if (val instanceof _$$_REQUIRE(_dependencyMap[0], "./core.js") && val.then === _$$_REQUIRE(_dependencyMap[0], "./core.js").prototype.then) {
+            while (val._y === 3) {
+              val = val._z;
+            }
+            if (val._y === 1) return res(i, val._z);
+            if (val._y === 2) reject(val._z);
+            val.then(function (val) {
+              res(i, val);
+            }, reject);
+            return;
+          } else {
+            var then = val.then;
+            if (typeof then === 'function') {
+              var p = new (_$$_REQUIRE(_dependencyMap[0], "./core.js"))(then.bind(val));
+              p.then(function (val) {
+                res(i, val);
+              }, reject);
+              return;
+            }
+          }
+        }
+        args[i] = val;
+        if (--remaining === 0) {
+          resolve(args);
+        }
+      }
+      for (var i = 0; i < args.length; i++) {
+        res(i, args[i]);
+      }
+    });
+  };
+  function onSettledFulfill(value) {
+    return {
+      status: 'fulfilled',
+      value: value
+    };
+  }
+  function onSettledReject(reason) {
+    return {
+      status: 'rejected',
+      reason: reason
+    };
+  }
+  function mapAllSettled(item) {
+    if (item && (typeof item === 'object' || typeof item === 'function')) {
+      if (item instanceof _$$_REQUIRE(_dependencyMap[0], "./core.js") && item.then === _$$_REQUIRE(_dependencyMap[0], "./core.js").prototype.then) {
+        return item.then(onSettledFulfill, onSettledReject);
+      }
+      var then = item.then;
+      if (typeof then === 'function') {
+        return new (_$$_REQUIRE(_dependencyMap[0], "./core.js"))(then.bind(item)).then(onSettledFulfill, onSettledReject);
+      }
+    }
+    return onSettledFulfill(item);
+  }
+  _$$_REQUIRE(_dependencyMap[0], "./core.js").allSettled = function (iterable) {
+    return _$$_REQUIRE(_dependencyMap[0], "./core.js").all(_iterableToArray(iterable).map(mapAllSettled));
+  };
+  _$$_REQUIRE(_dependencyMap[0], "./core.js").reject = function (value) {
+    return new (_$$_REQUIRE(_dependencyMap[0], "./core.js"))(function (resolve, reject) {
+      reject(value);
+    });
+  };
+  _$$_REQUIRE(_dependencyMap[0], "./core.js").race = function (values) {
+    return new (_$$_REQUIRE(_dependencyMap[0], "./core.js"))(function (resolve, reject) {
+      _iterableToArray(values).forEach(function (value) {
+        _$$_REQUIRE(_dependencyMap[0], "./core.js").resolve(value).then(resolve, reject);
+      });
+    });
+  };
+
+  /* Prototype Methods */
+
+  _$$_REQUIRE(_dependencyMap[0], "./core.js").prototype['catch'] = function (onRejected) {
+    return this.then(null, onRejected);
+  };
+  function getAggregateError(errors) {
+    if (typeof AggregateError === 'function') {
+      return new AggregateError(errors, 'All promises were rejected');
+    }
+    var error = new Error('All promises were rejected');
+    error.name = 'AggregateError';
+    error.errors = errors;
+    return error;
+  }
+  _$$_REQUIRE(_dependencyMap[0], "./core.js").any = function promiseAny(values) {
+    return new (_$$_REQUIRE(_dependencyMap[0], "./core.js"))(function (resolve, reject) {
+      var promises = _iterableToArray(values);
+      var hasResolved = false;
+      var rejectionReasons = [];
+      function resolveOnce(value) {
+        if (!hasResolved) {
+          hasResolved = true;
+          resolve(value);
+        }
+      }
+      function rejectionCheck(reason) {
+        rejectionReasons.push(reason);
+        if (rejectionReasons.length === promises.length) {
+          reject(getAggregateError(rejectionReasons));
+        }
+      }
+      if (promises.length === 0) {
+        reject(getAggregateError(rejectionReasons));
+      } else {
+        promises.forEach(function (value) {
+          _$$_REQUIRE(_dependencyMap[0], "./core.js").resolve(value).then(resolveOnce, rejectionCheck);
+        });
+      }
+    });
+  };
+},190,[191],"../../node_modules/promise/setimmediate/es6-extensions.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  function noop() {}
+
+  // States:
+  //
+  // 0 - pending
+  // 1 - fulfilled with _value
+  // 2 - rejected with _value
+  // 3 - adopted the state of another promise, _value
+  //
+  // once the state is no longer pending (0) it is immutable
+
+  // All `_` prefixed properties will be reduced to `_{random number}`
+  // at build time to obfuscate them and discourage their use.
+  // We don't use symbols or Object.defineProperty to fully hide them
+  // because the performance isn't good enough.
+
+  // to avoid using try/catch inside critical functions, we
+  // extract them to here.
+  var LAST_ERROR = null;
+  var IS_ERROR = {};
+  function getThen(obj) {
+    try {
+      return obj.then;
+    } catch (ex) {
+      LAST_ERROR = ex;
+      return IS_ERROR;
+    }
+  }
+  function tryCallOne(fn, a) {
+    try {
+      return fn(a);
+    } catch (ex) {
+      LAST_ERROR = ex;
+      return IS_ERROR;
+    }
+  }
+  function tryCallTwo(fn, a, b) {
+    try {
+      fn(a, b);
+    } catch (ex) {
+      LAST_ERROR = ex;
+      return IS_ERROR;
+    }
+  }
+  module.exports = Promise;
+  function Promise(fn) {
+    if (typeof this !== 'object') {
+      throw new TypeError('Promises must be constructed via new');
+    }
+    if (typeof fn !== 'function') {
+      throw new TypeError('Promise constructor\'s argument is not a function');
+    }
+    this._x = 0;
+    this._y = 0;
+    this._z = null;
+    this._A = null;
+    if (fn === noop) return;
+    doResolve(fn, this);
+  }
+  Promise._B = null;
+  Promise._C = null;
+  Promise._D = noop;
+  Promise.prototype.then = function (onFulfilled, onRejected) {
+    if (this.constructor !== Promise) {
+      return safeThen(this, onFulfilled, onRejected);
+    }
+    var res = new Promise(noop);
+    handle(this, new Handler(onFulfilled, onRejected, res));
+    return res;
+  };
+  function safeThen(self, onFulfilled, onRejected) {
+    return new self.constructor(function (resolve, reject) {
+      var res = new Promise(noop);
+      res.then(resolve, reject);
+      handle(self, new Handler(onFulfilled, onRejected, res));
+    });
+  }
+  function handle(self, deferred) {
+    while (self._y === 3) {
+      self = self._z;
+    }
+    if (Promise._B) {
+      Promise._B(self);
+    }
+    if (self._y === 0) {
+      if (self._x === 0) {
+        self._x = 1;
+        self._A = deferred;
+        return;
+      }
+      if (self._x === 1) {
+        self._x = 2;
+        self._A = [self._A, deferred];
+        return;
+      }
+      self._A.push(deferred);
+      return;
+    }
+    handleResolved(self, deferred);
+  }
+  function handleResolved(self, deferred) {
+    setImmediate(function () {
+      var cb = self._y === 1 ? deferred.onFulfilled : deferred.onRejected;
+      if (cb === null) {
+        if (self._y === 1) {
+          resolve(deferred.promise, self._z);
+        } else {
+          reject(deferred.promise, self._z);
+        }
+        return;
+      }
+      var ret = tryCallOne(cb, self._z);
+      if (ret === IS_ERROR) {
+        reject(deferred.promise, LAST_ERROR);
+      } else {
+        resolve(deferred.promise, ret);
+      }
+    });
+  }
+  function resolve(self, newValue) {
+    // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
+    if (newValue === self) {
+      return reject(self, new TypeError('A promise cannot be resolved with itself.'));
+    }
+    if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
+      var then = getThen(newValue);
+      if (then === IS_ERROR) {
+        return reject(self, LAST_ERROR);
+      }
+      if (then === self.then && newValue instanceof Promise) {
+        self._y = 3;
+        self._z = newValue;
+        finale(self);
+        return;
+      } else if (typeof then === 'function') {
+        doResolve(then.bind(newValue), self);
+        return;
+      }
+    }
+    self._y = 1;
+    self._z = newValue;
+    finale(self);
+  }
+  function reject(self, newValue) {
+    self._y = 2;
+    self._z = newValue;
+    if (Promise._C) {
+      Promise._C(self, newValue);
+    }
+    finale(self);
+  }
+  function finale(self) {
+    if (self._x === 1) {
+      handle(self, self._A);
+      self._A = null;
+    }
+    if (self._x === 2) {
+      for (var i = 0; i < self._A.length; i++) {
+        handle(self, self._A[i]);
+      }
+      self._A = null;
+    }
+  }
+  function Handler(onFulfilled, onRejected, promise) {
+    this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
+    this.onRejected = typeof onRejected === 'function' ? onRejected : null;
+    this.promise = promise;
+  }
+
+  /**
+   * Take a potentially misbehaving resolver function and make sure
+   * onFulfilled and onRejected are only called once.
+   *
+   * Makes no guarantees about asynchrony.
+   */
+  function doResolve(fn, promise) {
+    var done = false;
+    var res = tryCallTwo(fn, function (value) {
+      if (done) return;
+      done = true;
+      resolve(promise, value);
+    }, function (reason) {
+      if (done) return;
+      done = true;
+      reject(promise, reason);
+    });
+    if (!done && res === IS_ERROR) {
+      done = true;
+      reject(promise, LAST_ERROR);
+    }
+  }
+},191,[],"../../node_modules/promise/setimmediate/core.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  module.exports = _$$_REQUIRE(_dependencyMap[0], "./core.js");
+  _$$_REQUIRE(_dependencyMap[0], "./core.js").prototype.finally = function (f) {
+    return this.then(function (value) {
+      return _$$_REQUIRE(_dependencyMap[0], "./core.js").resolve(f()).then(function () {
+        return value;
+      });
+    }, function (err) {
+      return _$$_REQUIRE(_dependencyMap[0], "./core.js").resolve(f()).then(function () {
+        throw err;
+      });
+    });
+  };
+},192,[191],"../../node_modules/promise/setimmediate/finally.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var DEFAULT_WHITELIST = [ReferenceError, TypeError, RangeError];
+  var enabled = false;
+  exports.disable = disable;
+  function disable() {
+    enabled = false;
+    _$$_REQUIRE(_dependencyMap[0], "./core")._B = null;
+    _$$_REQUIRE(_dependencyMap[0], "./core")._C = null;
+  }
+  exports.enable = enable;
+  function enable(options) {
+    options = options || {};
+    if (enabled) disable();
+    enabled = true;
+    var id = 0;
+    var displayId = 0;
+    var rejections = {};
+    _$$_REQUIRE(_dependencyMap[0], "./core")._B = function (promise) {
+      if (promise._y === 2 &&
+      // IS REJECTED
+      rejections[promise._E]) {
+        if (rejections[promise._E].logged) {
+          onHandled(promise._E);
+        } else {
+          clearTimeout(rejections[promise._E].timeout);
+        }
+        delete rejections[promise._E];
+      }
+    };
+    _$$_REQUIRE(_dependencyMap[0], "./core")._C = function (promise, err) {
+      if (promise._x === 0) {
+        // not yet handled
+        promise._E = id++;
+        rejections[promise._E] = {
+          displayId: null,
+          error: err,
+          timeout: setTimeout(onUnhandled.bind(null, promise._E),
+          // For reference errors and type errors, this almost always
+          // means the programmer made a mistake, so log them after just
+          // 100ms
+          // otherwise, wait 2 seconds to see if they get handled
+          matchWhitelist(err, DEFAULT_WHITELIST) ? 100 : 2000),
+          logged: false
+        };
+      }
+    };
+    function onUnhandled(id) {
+      if (options.allRejections || matchWhitelist(rejections[id].error, options.whitelist || DEFAULT_WHITELIST)) {
+        rejections[id].displayId = displayId++;
+        if (options.onUnhandled) {
+          rejections[id].logged = true;
+          options.onUnhandled(rejections[id].displayId, rejections[id].error);
+        } else {
+          rejections[id].logged = true;
+          logError(rejections[id].displayId, rejections[id].error);
+        }
+      }
+    }
+    function onHandled(id) {
+      if (rejections[id].logged) {
+        if (options.onHandled) {
+          options.onHandled(rejections[id].displayId, rejections[id].error);
+        } else if (!rejections[id].onUnhandled) {
+          console.warn('Promise Rejection Handled (id: ' + rejections[id].displayId + '):');
+          console.warn('  This means you can ignore any previous messages of the form "Possible Unhandled Promise Rejection" with id ' + rejections[id].displayId + '.');
+        }
+      }
+    }
+  }
+  function logError(id, error) {
+    console.warn('Possible Unhandled Promise Rejection (id: ' + id + '):');
+    var errStr = (error && (error.stack || error)) + '';
+    errStr.split('\n').forEach(function (line) {
+      console.warn('  ' + line);
+    });
+  }
+  function matchWhitelist(error, list) {
+    return list.some(function (cls) {
+      return error instanceof cls;
+    });
+  }
+},193,[191],"../../node_modules/promise/setimmediate/rejection-tracking.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  if (__DEV__) {
+    if (typeof global.Promise !== 'function') {
+      console.error('Promise should exist before setting up timers.');
+    }
+  }
+  if (global.RN$Bridgeless === true) {
+    global.RN$enableMicrotasksInReact = true;
+    _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions").polyfillGlobal('queueMicrotask', function () {
+      return _$$_REQUIRE(_dependencyMap[1], "../../src/private/webapis/microtasks/specs/NativeMicrotasks").default.queueMicrotask;
+    });
+    _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions").polyfillGlobal('setImmediate', function () {
+      return _$$_REQUIRE(_dependencyMap[2], "./Timers/immediateShim").setImmediate;
+    });
+    _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions").polyfillGlobal('clearImmediate', function () {
+      return _$$_REQUIRE(_dependencyMap[2], "./Timers/immediateShim").clearImmediate;
+    });
+    _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions").polyfillGlobal('requestIdleCallback', function () {
+      return _$$_REQUIRE(_dependencyMap[3], "../../src/private/webapis/idlecallbacks/specs/NativeIdleCallbacks").default.requestIdleCallback;
+    });
+    _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions").polyfillGlobal('cancelIdleCallback', function () {
+      return _$$_REQUIRE(_dependencyMap[3], "../../src/private/webapis/idlecallbacks/specs/NativeIdleCallbacks").default.cancelIdleCallback;
+    });
+  } else {
+    var defineLazyTimer = function defineLazyTimer(name) {
+      _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions").polyfillGlobal(name, function () {
+        return _$$_REQUIRE(_dependencyMap[4], "./Timers/JSTimers").default[name];
+      });
+    };
+    defineLazyTimer('setTimeout');
+    defineLazyTimer('clearTimeout');
+    defineLazyTimer('setInterval');
+    defineLazyTimer('clearInterval');
+    defineLazyTimer('requestAnimationFrame');
+    defineLazyTimer('cancelAnimationFrame');
+    defineLazyTimer('requestIdleCallback');
+    defineLazyTimer('cancelIdleCallback');
+    _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions").polyfillGlobal('queueMicrotask', function () {
+      return _$$_REQUIRE(_dependencyMap[5], "./Timers/queueMicrotask.js").default;
+    });
+    _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions").polyfillGlobal('setImmediate', function () {
+      return _$$_REQUIRE(_dependencyMap[4], "./Timers/JSTimers").default.queueReactNativeMicrotask;
+    });
+    _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions").polyfillGlobal('clearImmediate', function () {
+      return _$$_REQUIRE(_dependencyMap[4], "./Timers/JSTimers").default.clearReactNativeMicrotask;
+    });
+  }
+},194,[114,195,196,197,198,201],"../../node_modules/react-native/Libraries/Core/setUpTimers.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.getEnforcing('NativeMicrotasksCxx');
+},195,[31],"../../node_modules/react-native/src/private/webapis/microtasks/specs/NativeMicrotasks.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.clearImmediate = clearImmediate;
+  exports.setImmediate = setImmediate;
+  var GUIID = 1;
+  var clearedImmediates = new Set();
+  function setImmediate(callback) {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+    if (arguments.length < 1) {
+      throw new TypeError('setImmediate must be called with at least one argument (a function to call)');
+    }
+    if (typeof callback !== 'function') {
+      throw new TypeError('The first argument to setImmediate must be a function.');
+    }
+    var id = GUIID++;
+    if (clearedImmediates.has(id)) {
+      clearedImmediates.delete(id);
+    }
+    global.queueMicrotask(function () {
+      if (!clearedImmediates.has(id)) {
+        callback.apply(undefined, args);
+      } else {
+        clearedImmediates.delete(id);
+      }
+    });
+    return id;
+  }
+  function clearImmediate(immediateID) {
+    clearedImmediates.add(immediateID);
+  }
+},196,[],"../../node_modules/react-native/Libraries/Core/Timers/immediateShim.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.getEnforcing('NativeIdleCallbacksCxx');
+},197,[31],"../../node_modules/react-native/src/private/webapis/idlecallbacks/specs/NativeIdleCallbacks.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _NativeTiming = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativeTiming"));
+  var FRAME_DURATION = 1000 / 60;
+  var IDLE_CALLBACK_FRAME_DEADLINE = 1;
+  var callbacks = [];
+  var types = [];
+  var timerIDs = [];
+  var freeIdxs = [];
+  var reactNativeMicrotasks = [];
+  var requestIdleCallbacks = [];
+  var requestIdleCallbackTimeouts = {};
+  var GUID = 1;
+  var errors = [];
+  var hasEmittedTimeDriftWarning = false;
+  function _getFreeIndex() {
+    var freeIdx = freeIdxs.pop();
+    if (freeIdx === undefined) {
+      return timerIDs.length;
+    }
+    return freeIdx;
+  }
+  function _allocateCallback(func, type) {
+    var id = GUID++;
+    var freeIndex = _getFreeIndex();
+    timerIDs[freeIndex] = id;
+    callbacks[freeIndex] = func;
+    types[freeIndex] = type;
+    return id;
+  }
+  function _callTimer(timerID, frameTime, didTimeout) {
+    if (timerID > GUID) {
+      console.warn('Tried to call timer with ID %s but no such timer exists.', timerID);
+    }
+    var timerIndex = timerIDs.indexOf(timerID);
+    if (timerIndex === -1) {
+      return;
+    }
+    var type = types[timerIndex];
+    var callback = callbacks[timerIndex];
+    if (!callback || !type) {
+      console.error('No callback found for timerID ' + timerID);
+      return;
+    }
+    if (__DEV__) {
+      _$$_REQUIRE(_dependencyMap[2], "../../Performance/Systrace").beginEvent(type + ' [invoke]');
+    }
+    if (type !== 'setInterval') {
+      _clearIndex(timerIndex);
+    }
+    try {
+      if (type === 'setTimeout' || type === 'setInterval' || type === 'queueReactNativeMicrotask') {
+        callback();
+      } else if (type === 'requestAnimationFrame') {
+        callback(global.performance.now());
+      } else if (type === 'requestIdleCallback') {
+        callback({
+          timeRemaining: function timeRemaining() {
+            return Math.max(0, FRAME_DURATION - (global.performance.now() - frameTime));
+          },
+          didTimeout: !!didTimeout
+        });
+      } else {
+        console.error('Tried to call a callback with invalid type: ' + type);
+      }
+    } catch (e) {
+      errors.push(e);
+    }
+    if (__DEV__) {
+      _$$_REQUIRE(_dependencyMap[2], "../../Performance/Systrace").endEvent();
+    }
+  }
+  function _callReactNativeMicrotasksPass() {
+    if (reactNativeMicrotasks.length === 0) {
+      return false;
+    }
+    if (__DEV__) {
+      _$$_REQUIRE(_dependencyMap[2], "../../Performance/Systrace").beginEvent('callReactNativeMicrotasksPass()');
+    }
+    var passReactNativeMicrotasks = reactNativeMicrotasks;
+    reactNativeMicrotasks = [];
+    for (var i = 0; i < passReactNativeMicrotasks.length; ++i) {
+      _callTimer(passReactNativeMicrotasks[i], 0);
+    }
+    if (__DEV__) {
+      _$$_REQUIRE(_dependencyMap[2], "../../Performance/Systrace").endEvent();
+    }
+    return reactNativeMicrotasks.length > 0;
+  }
+  function _clearIndex(i) {
+    timerIDs[i] = null;
+    callbacks[i] = null;
+    types[i] = null;
+    freeIdxs.push(i);
+  }
+  function _freeCallback(timerID) {
+    if (timerID == null) {
+      return;
+    }
+    var index = timerIDs.indexOf(timerID);
+    if (index !== -1) {
+      var type = types[index];
+      _clearIndex(index);
+      if (type !== 'queueReactNativeMicrotask' && type !== 'requestIdleCallback') {
+        deleteTimer(timerID);
+      }
+    }
+  }
+  var JSTimers = {
+    setTimeout: function setTimeout(func, duration) {
+      for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+        args[_key - 2] = arguments[_key];
+      }
+      var id = _allocateCallback(function () {
+        return func.apply(undefined, args);
+      }, 'setTimeout');
+      createTimer(id, duration || 0, Date.now(), false);
+      return id;
+    },
+    setInterval: function setInterval(func, duration) {
+      for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+        args[_key2 - 2] = arguments[_key2];
+      }
+      var id = _allocateCallback(function () {
+        return func.apply(undefined, args);
+      }, 'setInterval');
+      createTimer(id, duration || 0, Date.now(), true);
+      return id;
+    },
+    queueReactNativeMicrotask: function queueReactNativeMicrotask(func) {
+      for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+        args[_key3 - 1] = arguments[_key3];
+      }
+      var id = _allocateCallback(function () {
+        return func.apply(undefined, args);
+      }, 'queueReactNativeMicrotask');
+      reactNativeMicrotasks.push(id);
+      return id;
+    },
+    requestAnimationFrame: function requestAnimationFrame(func) {
+      var id = _allocateCallback(func, 'requestAnimationFrame');
+      createTimer(id, 1, Date.now(), false);
+      return id;
+    },
+    requestIdleCallback: function requestIdleCallback(func, options) {
+      if (requestIdleCallbacks.length === 0) {
+        setSendIdleEvents(true);
+      }
+      var timeout = options && options.timeout;
+      var id = _allocateCallback(timeout != null ? function (deadline) {
+        var timeoutId = requestIdleCallbackTimeouts[id];
+        if (timeoutId) {
+          JSTimers.clearTimeout(timeoutId);
+          delete requestIdleCallbackTimeouts[id];
+        }
+        return func(deadline);
+      } : func, 'requestIdleCallback');
+      requestIdleCallbacks.push(id);
+      if (timeout != null) {
+        var timeoutId = JSTimers.setTimeout(function () {
+          var index = requestIdleCallbacks.indexOf(id);
+          if (index > -1) {
+            requestIdleCallbacks.splice(index, 1);
+            _callTimer(id, global.performance.now(), true);
+          }
+          delete requestIdleCallbackTimeouts[id];
+          if (requestIdleCallbacks.length === 0) {
+            setSendIdleEvents(false);
+          }
+        }, timeout);
+        requestIdleCallbackTimeouts[id] = timeoutId;
+      }
+      return id;
+    },
+    cancelIdleCallback: function cancelIdleCallback(timerID) {
+      _freeCallback(timerID);
+      var index = requestIdleCallbacks.indexOf(timerID);
+      if (index !== -1) {
+        requestIdleCallbacks.splice(index, 1);
+      }
+      var timeoutId = requestIdleCallbackTimeouts[timerID];
+      if (timeoutId) {
+        JSTimers.clearTimeout(timeoutId);
+        delete requestIdleCallbackTimeouts[timerID];
+      }
+      if (requestIdleCallbacks.length === 0) {
+        setSendIdleEvents(false);
+      }
+    },
+    clearTimeout: function clearTimeout(timerID) {
+      _freeCallback(timerID);
+    },
+    clearInterval: function clearInterval(timerID) {
+      _freeCallback(timerID);
+    },
+    clearReactNativeMicrotask: function clearReactNativeMicrotask(timerID) {
+      _freeCallback(timerID);
+      var index = reactNativeMicrotasks.indexOf(timerID);
+      if (index !== -1) {
+        reactNativeMicrotasks.splice(index, 1);
+      }
+    },
+    cancelAnimationFrame: function cancelAnimationFrame(timerID) {
+      _freeCallback(timerID);
+    },
+    callTimers: function callTimers(timersToCall) {
+      _$$_REQUIRE(_dependencyMap[3], "invariant")(timersToCall.length !== 0, 'Cannot call `callTimers` with an empty list of IDs.');
+      errors.length = 0;
+      for (var i = 0; i < timersToCall.length; i++) {
+        _callTimer(timersToCall[i], 0);
+      }
+      var errorCount = errors.length;
+      if (errorCount > 0) {
+        if (errorCount > 1) {
+          for (var ii = 1; ii < errorCount; ii++) {
+            JSTimers.setTimeout(function (error) {
+              throw error;
+            }.bind(null, errors[ii]), 0);
+          }
+        }
+        throw errors[0];
+      }
+    },
+    callIdleCallbacks: function callIdleCallbacks(frameTime) {
+      if (FRAME_DURATION - (Date.now() - frameTime) < IDLE_CALLBACK_FRAME_DEADLINE) {
+        return;
+      }
+      errors.length = 0;
+      if (requestIdleCallbacks.length > 0) {
+        var passIdleCallbacks = requestIdleCallbacks;
+        requestIdleCallbacks = [];
+        for (var i = 0; i < passIdleCallbacks.length; ++i) {
+          _callTimer(passIdleCallbacks[i], frameTime);
+        }
+      }
+      if (requestIdleCallbacks.length === 0) {
+        setSendIdleEvents(false);
+      }
+      errors.forEach(function (error) {
+        return JSTimers.setTimeout(function () {
+          throw error;
+        }, 0);
+      });
+    },
+    callReactNativeMicrotasks: function callReactNativeMicrotasks() {
+      errors.length = 0;
+      while (_callReactNativeMicrotasksPass()) {}
+      errors.forEach(function (error) {
+        return JSTimers.setTimeout(function () {
+          throw error;
+        }, 0);
+      });
+    },
+    emitTimeDriftWarning: function emitTimeDriftWarning(warningMessage) {
+      if (hasEmittedTimeDriftWarning) {
+        return;
+      }
+      hasEmittedTimeDriftWarning = true;
+      console.warn(warningMessage);
+    }
+  };
+  function createTimer(callbackID, duration, jsSchedulingTime, repeats) {
+    _$$_REQUIRE(_dependencyMap[3], "invariant")(_NativeTiming.default, 'NativeTiming is available');
+    _NativeTiming.default.createTimer(callbackID, duration, jsSchedulingTime, repeats);
+  }
+  function deleteTimer(timerID) {
+    _$$_REQUIRE(_dependencyMap[3], "invariant")(_NativeTiming.default, 'NativeTiming is available');
+    _NativeTiming.default.deleteTimer(timerID);
+  }
+  function setSendIdleEvents(sendIdleEvents) {
+    _$$_REQUIRE(_dependencyMap[3], "invariant")(_NativeTiming.default, 'NativeTiming is available');
+    _NativeTiming.default.setSendIdleEvents(sendIdleEvents);
+  }
+  var ExportedJSTimers;
+  if (!_NativeTiming.default) {
+    console.warn("Timing native module is not available, can't set timers.");
+    ExportedJSTimers = {
+      callReactNativeMicrotasks: JSTimers.callReactNativeMicrotasks,
+      queueReactNativeMicrotask: JSTimers.queueReactNativeMicrotask
+    };
+  } else {
+    ExportedJSTimers = JSTimers;
+  }
+  _$$_REQUIRE(_dependencyMap[4], "../../BatchedBridge/BatchedBridge").default.setReactNativeMicrotasksCallback(JSTimers.callReactNativeMicrotasks);
+  var _default = exports.default = ExportedJSTimers;
+},198,[1,199,28,32,40],"../../node_modules/react-native/Libraries/Core/Timers/JSTimers.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeTiming = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../src/private/specs_DEPRECATED/modules/NativeTiming"));
+  Object.keys(_NativeTiming).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeTiming[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeTiming[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeTiming.default;
+},199,[200],"../../node_modules/react-native/Libraries/Core/Timers/NativeTiming.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.get('Timing');
+},200,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeTiming.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = queueMicrotask;
+  var resolvedPromise;
+  function queueMicrotask(callback) {
+    if (arguments.length < 1) {
+      throw new TypeError('queueMicrotask must be called with at least one argument (a function to call)');
+    }
+    if (typeof callback !== 'function') {
+      throw new TypeError('The argument to queueMicrotask must be a function.');
+    }
+    (resolvedPromise || (resolvedPromise = Promise.resolve())).then(callback).catch(function (error) {
+      return setTimeout(function () {
+        throw error;
+      }, 0);
+    });
+  }
+},201,[],"../../node_modules/react-native/Libraries/Core/Timers/queueMicrotask.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  if (__DEV__) {
+    if (typeof global.queueMicrotask !== 'function') {
+      console.error('queueMicrotask should exist before setting up React DevTools.');
+    }
+    if (console._errorOriginal != null) {
+      console.error('ExceptionsManager should be set up after React DevTools to avoid console.error arguments mutation');
+    }
+  }
+  if (__DEV__) {
+    _$$_REQUIRE(_dependencyMap[0], "../../src/private/devsupport/rndevtools/setUpFuseboxReactDevToolsDispatcher");
+    var _require = _$$_REQUIRE(_dependencyMap[1], "react-devtools-core"),
+      initialize = _require.initialize,
+      connectToDevTools = _require.connectToDevTools,
+      connectWithCustomMessagingProtocol = _require.connectWithCustomMessagingProtocol;
+    var reactDevToolsSettingsManager = _$$_REQUIRE(_dependencyMap[2], "../../src/private/devsupport/rndevtools/ReactDevToolsSettingsManager");
+    var serializedHookSettings = reactDevToolsSettingsManager.getGlobalHookSettings();
+    var maybeReactDevToolsRuntimeSettingsModuleModule = _$$_REQUIRE(_dependencyMap[3], "../../src/private/devsupport/rndevtools/specs/NativeReactDevToolsRuntimeSettingsModule").default;
+    var hookSettings = null;
+    if (serializedHookSettings != null) {
+      try {
+        var parsedSettings = JSON.parse(serializedHookSettings);
+        hookSettings = parsedSettings;
+      } catch (_unused) {
+        console.error('Failed to parse persisted React DevTools hook settings. React DevTools will be initialized with default settings.');
+      }
+    }
+    var _readReloadAndProfile = readReloadAndProfileConfig(maybeReactDevToolsRuntimeSettingsModuleModule),
+      shouldStartProfilingNow = _readReloadAndProfile.isProfiling,
+      initialProfilingSettings = _readReloadAndProfile.profilingSettings;
+    initialize(hookSettings, shouldStartProfilingNow, initialProfilingSettings);
+    var fuseboxReactDevToolsDispatcher = global.__FUSEBOX_REACT_DEVTOOLS_DISPATCHER__;
+    var reactDevToolsFuseboxGlobalBindingName = fuseboxReactDevToolsDispatcher.BINDING_NAME;
+    var ReactNativeStyleAttributes = _$$_REQUIRE(_dependencyMap[4], "../Components/View/ReactNativeStyleAttributes").default;
+    var resolveRNStyle = _$$_REQUIRE(_dependencyMap[5], "../StyleSheet/flattenStyle").default;
+    function handleReactDevToolsSettingsUpdate(settings) {
+      reactDevToolsSettingsManager.setGlobalHookSettings(JSON.stringify(settings));
+    }
+    var disconnect = null;
+    function disconnectBackendFromReactDevToolsInFuseboxIfNeeded() {
+      if (disconnect != null) {
+        disconnect();
+        disconnect = null;
+      }
+    }
+    function connectToReactDevToolsInFusebox(domain) {
+      var _readReloadAndProfile2 = readReloadAndProfileConfig(maybeReactDevToolsRuntimeSettingsModuleModule),
+        isReloadAndProfileSupported = _readReloadAndProfile2.isReloadAndProfileSupported,
+        isProfiling = _readReloadAndProfile2.isProfiling,
+        onReloadAndProfile = _readReloadAndProfile2.onReloadAndProfile,
+        onReloadAndProfileFlagsReset = _readReloadAndProfile2.onReloadAndProfileFlagsReset;
+      disconnect = connectWithCustomMessagingProtocol({
+        onSubscribe: function onSubscribe(listener) {
+          domain.onMessage.addEventListener(listener);
+        },
+        onUnsubscribe: function onUnsubscribe(listener) {
+          domain.onMessage.removeEventListener(listener);
+        },
+        onMessage: function onMessage(event, payload) {
+          domain.sendMessage({
+            event: event,
+            payload: payload
+          });
+        },
+        nativeStyleEditorValidAttributes: Object.keys(ReactNativeStyleAttributes),
+        resolveRNStyle: resolveRNStyle,
+        onSettingsUpdated: handleReactDevToolsSettingsUpdate,
+        isReloadAndProfileSupported: isReloadAndProfileSupported,
+        isProfiling: isProfiling,
+        onReloadAndProfile: onReloadAndProfile,
+        onReloadAndProfileFlagsReset: onReloadAndProfileFlagsReset
+      });
+    }
+    var isWebSocketOpen = false;
+    var ws = null;
+    function connectToWSBasedReactDevToolsFrontend() {
+      if (ws !== null && isWebSocketOpen) {
+        return;
+      }
+      if (!window.document) {
+        var AppState = _$$_REQUIRE(_dependencyMap[6], "../AppState/AppState").default;
+        var getDevServer = _$$_REQUIRE(_dependencyMap[7], "./Devtools/getDevServer").default;
+        var isAppActive = function isAppActive() {
+          return AppState.currentState !== 'background';
+        };
+        var devServer = getDevServer();
+        var host = devServer.bundleLoadedFromServer ? devServer.url.replace(/https?:\/\//, '').replace(/\/$/, '').split(':')[0] : 'localhost';
+        var port = window.__REACT_DEVTOOLS_PORT__ != null ? window.__REACT_DEVTOOLS_PORT__ : 8097;
+        var WebSocket = _$$_REQUIRE(_dependencyMap[8], "../WebSocket/WebSocket").default;
+        ws = new WebSocket('ws://' + host + ':' + port);
+        ws.addEventListener('close', function (event) {
+          isWebSocketOpen = false;
+        });
+        ws.addEventListener('open', function (event) {
+          isWebSocketOpen = true;
+        });
+        var _readReloadAndProfile3 = readReloadAndProfileConfig(maybeReactDevToolsRuntimeSettingsModuleModule),
+          isReloadAndProfileSupported = _readReloadAndProfile3.isReloadAndProfileSupported,
+          isProfiling = _readReloadAndProfile3.isProfiling,
+          onReloadAndProfile = _readReloadAndProfile3.onReloadAndProfile,
+          onReloadAndProfileFlagsReset = _readReloadAndProfile3.onReloadAndProfileFlagsReset;
+        connectToDevTools({
+          isAppActive: isAppActive,
+          resolveRNStyle: resolveRNStyle,
+          nativeStyleEditorValidAttributes: Object.keys(ReactNativeStyleAttributes),
+          websocket: ws,
+          onSettingsUpdated: handleReactDevToolsSettingsUpdate,
+          isReloadAndProfileSupported: isReloadAndProfileSupported,
+          isProfiling: isProfiling,
+          onReloadAndProfile: onReloadAndProfile,
+          onReloadAndProfileFlagsReset: onReloadAndProfileFlagsReset
+        });
+      }
+    }
+    if (global[reactDevToolsFuseboxGlobalBindingName] != null) {
+      disconnectBackendFromReactDevToolsInFuseboxIfNeeded();
+      var domain = fuseboxReactDevToolsDispatcher.initializeDomain('react-devtools');
+      connectToReactDevToolsInFusebox(domain);
+    }
+    global.__FUSEBOX_REACT_DEVTOOLS_DISPATCHER__.onDomainInitialization.addEventListener(function (domain) {
+      if (domain.name === 'react-devtools') {
+        disconnectBackendFromReactDevToolsInFuseboxIfNeeded();
+        connectToReactDevToolsInFusebox(domain);
+      }
+    });
+    var RCTNativeAppEventEmitter = _$$_REQUIRE(_dependencyMap[9], "../EventEmitter/RCTNativeAppEventEmitter").default;
+    RCTNativeAppEventEmitter.addListener('RCTDevMenuShown', connectToWSBasedReactDevToolsFrontend);
+    connectToWSBasedReactDevToolsFrontend();
+  }
+  function readReloadAndProfileConfig(maybeModule) {
+    var isReloadAndProfileSupported = maybeModule != null;
+    var config = maybeModule == null ? void 0 : maybeModule.getReloadAndProfileConfig();
+    var isProfiling = (config == null ? void 0 : config.shouldReloadAndProfile) === true;
+    var profilingSettings = {
+      recordChangeDescriptions: (config == null ? void 0 : config.recordChangeDescriptions) === true,
+      recordTimeline: false
+    };
+    var onReloadAndProfile = function onReloadAndProfile(recordChangeDescriptions) {
+      if (maybeModule == null) {
+        return;
+      }
+      maybeModule.setReloadAndProfileConfig({
+        shouldReloadAndProfile: true,
+        recordChangeDescriptions: recordChangeDescriptions
+      });
+    };
+    var onReloadAndProfileFlagsReset = function onReloadAndProfileFlagsReset() {
+      if (maybeModule == null) {
+        return;
+      }
+      maybeModule.setReloadAndProfileConfig({
+        shouldReloadAndProfile: false,
+        recordChangeDescriptions: false
+      });
+    };
+    return {
+      isReloadAndProfileSupported: isReloadAndProfileSupported,
+      isProfiling: isProfiling,
+      profilingSettings: profilingSettings,
+      onReloadAndProfile: onReloadAndProfile,
+      onReloadAndProfileFlagsReset: onReloadAndProfileFlagsReset
+    };
+  }
+},202,[203,204,215,219,51,9,220,168,225,242],"../../node_modules/react-native/Libraries/Core/setUpReactDevTools.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.Domain = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _classPrivateFieldLooseBase2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classPrivateFieldLooseBase"));
+  var _classPrivateFieldLooseKey2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classPrivateFieldLooseKey"));
+  var _listeners = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("listeners");
+  var EventScope = /*#__PURE__*/function () {
+    function EventScope() {
+      (0, _classCallCheck2.default)(this, EventScope);
+      Object.defineProperty(this, _listeners, {
+        writable: true,
+        value: new Set()
+      });
+    }
+    return (0, _createClass2.default)(EventScope, [{
+      key: "addEventListener",
+      value: function addEventListener(listener) {
+        (0, _classPrivateFieldLooseBase2.default)(this, _listeners)[_listeners].add(listener);
+      }
+    }, {
+      key: "removeEventListener",
+      value: function removeEventListener(listener) {
+        (0, _classPrivateFieldLooseBase2.default)(this, _listeners)[_listeners].delete(listener);
+      }
+    }, {
+      key: "emit",
+      value: function emit(value) {
+        for (var listener of (0, _classPrivateFieldLooseBase2.default)(this, _listeners)[_listeners]) {
+          listener(value);
+        }
+      }
+    }]);
+  }();
+  var Domain = exports.Domain = /*#__PURE__*/function () {
+    function Domain(name) {
+      (0, _classCallCheck2.default)(this, Domain);
+      if (global[FuseboxReactDevToolsDispatcher.BINDING_NAME] == null) {
+        throw new Error(`Could not create domain ${name}: receiving end doesn't exist`);
+      }
+      this.name = name;
+      this.onMessage = new EventScope();
+    }
+    return (0, _createClass2.default)(Domain, [{
+      key: "sendMessage",
+      value: function sendMessage(message) {
+        var messageWithDomain = {
+          domain: this.name,
+          message: message
+        };
+        var serializedMessageWithDomain = JSON.stringify(messageWithDomain);
+        global[FuseboxReactDevToolsDispatcher.BINDING_NAME](serializedMessageWithDomain);
+      }
+    }]);
+  }();
+  var _domainNameToDomainMap = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("domainNameToDomainMap");
+  var FuseboxReactDevToolsDispatcher = /*#__PURE__*/function () {
+    function FuseboxReactDevToolsDispatcher() {
+      (0, _classCallCheck2.default)(this, FuseboxReactDevToolsDispatcher);
+    }
+    return (0, _createClass2.default)(FuseboxReactDevToolsDispatcher, null, [{
+      key: "initializeDomain",
+      value: function initializeDomain(domainName) {
+        var domain = new Domain(domainName);
+        (0, _classPrivateFieldLooseBase2.default)(this, _domainNameToDomainMap)[_domainNameToDomainMap].set(domainName, domain);
+        this.onDomainInitialization.emit(domain);
+        return domain;
+      }
+    }, {
+      key: "sendMessage",
+      value: function sendMessage(domainName, message) {
+        var domain = (0, _classPrivateFieldLooseBase2.default)(this, _domainNameToDomainMap)[_domainNameToDomainMap].get(domainName);
+        if (domain == null) {
+          throw new Error(`Could not send message to ${domainName}: domain doesn't exist`);
+        }
+        try {
+          var parsedMessage = JSON.parse(message);
+          domain.onMessage.emit(parsedMessage);
+        } catch (err) {
+          console.error(`Error while trying to send a message to domain ${domainName}:`, err);
+        }
+      }
+    }]);
+  }();
+  Object.defineProperty(FuseboxReactDevToolsDispatcher, _domainNameToDomainMap, {
+    writable: true,
+    value: new Map()
+  });
+  FuseboxReactDevToolsDispatcher.BINDING_NAME = '__CHROME_DEVTOOLS_FRONTEND_BINDING__';
+  FuseboxReactDevToolsDispatcher.onDomainInitialization = new EventScope();
+  Object.defineProperty(global, '__FUSEBOX_REACT_DEVTOOLS_DISPATCHER__', {
+    value: FuseboxReactDevToolsDispatcher,
+    configurable: false,
+    enumerable: false,
+    writable: false
+  });
+},203,[1,11,12,26,27],"../../node_modules/react-native/src/private/devsupport/rndevtools/setUpFuseboxReactDevToolsDispatcher.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _regeneratorRuntime = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/regenerator");
+  (function webpackUniversalModuleDefinition(root, factory) {
+    if (typeof exports === 'object' && typeof module === 'object') module.exports = factory();else if (typeof define === 'function' && define.amd) define([], factory);else if (typeof exports === 'object') exports["ReactDevToolsBackend"] = factory();else root["ReactDevToolsBackend"] = factory();
+  })(self, function () {
+    return /******/function () {
+      // webpackBootstrap
+      /******/
+      var __webpack_modules__ = {
+        /***/786: (/***/function _(__unused_webpack_module, exports, __webpack_require__) {
+          "use strict";
+
+          var __webpack_unused_export__;
+          /**
+           * @license React
+           * react-debug-tools.production.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.
+           */
+
+          function _typeof(obj) {
+            "@babel/helpers - typeof";
+
+            if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+              _typeof = function _typeof(obj) {
+                return typeof obj;
+              };
+            } else {
+              _typeof = function _typeof(obj) {
+                return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+              };
+            }
+            return _typeof(obj);
+          }
+          var ErrorStackParser = __webpack_require__(206),
+            React = __webpack_require__(189),
+            assign = Object.assign,
+            ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,
+            REACT_CONTEXT_TYPE = Symbol.for("react.context"),
+            REACT_MEMO_CACHE_SENTINEL = Symbol.for("react.memo_cache_sentinel"),
+            hasOwnProperty = Object.prototype.hasOwnProperty,
+            hookLog = [],
+            primitiveStackCache = null;
+          function getPrimitiveStackCache() {
+            if (null === primitiveStackCache) {
+              var cache = new Map();
+              try {
+                Dispatcher.useContext({
+                  _currentValue: null
+                });
+                Dispatcher.useState(null);
+                Dispatcher.useReducer(function (s) {
+                  return s;
+                }, null);
+                Dispatcher.useRef(null);
+                "function" === typeof Dispatcher.useCacheRefresh && Dispatcher.useCacheRefresh();
+                Dispatcher.useLayoutEffect(function () {});
+                Dispatcher.useInsertionEffect(function () {});
+                Dispatcher.useEffect(function () {});
+                Dispatcher.useImperativeHandle(void 0, function () {
+                  return null;
+                });
+                Dispatcher.useDebugValue(null);
+                Dispatcher.useCallback(function () {});
+                Dispatcher.useTransition();
+                Dispatcher.useSyncExternalStore(function () {
+                  return function () {};
+                }, function () {
+                  return null;
+                }, function () {
+                  return null;
+                });
+                Dispatcher.useDeferredValue(null);
+                Dispatcher.useMemo(function () {
+                  return null;
+                });
+                Dispatcher.useOptimistic(null, function (s) {
+                  return s;
+                });
+                Dispatcher.useFormState(function (s) {
+                  return s;
+                }, null);
+                Dispatcher.useActionState(function (s) {
+                  return s;
+                }, null);
+                Dispatcher.useHostTransitionStatus();
+                "function" === typeof Dispatcher.useMemoCache && Dispatcher.useMemoCache(0);
+                if ("function" === typeof Dispatcher.use) {
+                  Dispatcher.use({
+                    $$typeof: REACT_CONTEXT_TYPE,
+                    _currentValue: null
+                  });
+                  Dispatcher.use({
+                    then: function then() {},
+                    status: "fulfilled",
+                    value: null
+                  });
+                  try {
+                    Dispatcher.use({
+                      then: function then() {}
+                    });
+                  } catch (x) {}
+                }
+                Dispatcher.useId();
+                "function" === typeof Dispatcher.useEffectEvent && Dispatcher.useEffectEvent(function () {});
+              } finally {
+                var readHookLog = hookLog;
+                hookLog = [];
+              }
+              for (var i = 0; i < readHookLog.length; i++) {
+                var hook = readHookLog[i];
+                cache.set(hook.primitive, ErrorStackParser.parse(hook.stackError));
+              }
+              primitiveStackCache = cache;
+            }
+            return primitiveStackCache;
+          }
+          var currentFiber = null,
+            currentHook = null,
+            currentContextDependency = null;
+          function nextHook() {
+            var hook = currentHook;
+            null !== hook && (currentHook = hook.next);
+            return hook;
+          }
+          function readContext(context) {
+            if (null === currentFiber) return context._currentValue;
+            if (null === currentContextDependency) throw Error("Context reads do not line up with context dependencies. This is a bug in React Debug Tools.");
+            hasOwnProperty.call(currentContextDependency, "memoizedValue") ? (context = currentContextDependency.memoizedValue, currentContextDependency = currentContextDependency.next) : context = context._currentValue;
+            return context;
+          }
+          var SuspenseException = 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`."),
+            Dispatcher = {
+              readContext: readContext,
+              use: function use(usable) {
+                if (null !== usable && "object" === _typeof(usable)) {
+                  if ("function" === typeof usable.then) {
+                    switch (usable.status) {
+                      case "fulfilled":
+                        var fulfilledValue = usable.value;
+                        hookLog.push({
+                          displayName: null,
+                          primitive: "Promise",
+                          stackError: Error(),
+                          value: fulfilledValue,
+                          debugInfo: void 0 === usable._debugInfo ? null : usable._debugInfo,
+                          dispatcherHookName: "Use"
+                        });
+                        return fulfilledValue;
+                      case "rejected":
+                        throw usable.reason;
+                    }
+                    hookLog.push({
+                      displayName: null,
+                      primitive: "Unresolved",
+                      stackError: Error(),
+                      value: usable,
+                      debugInfo: void 0 === usable._debugInfo ? null : usable._debugInfo,
+                      dispatcherHookName: "Use"
+                    });
+                    throw SuspenseException;
+                  }
+                  if (usable.$$typeof === REACT_CONTEXT_TYPE) return fulfilledValue = readContext(usable), hookLog.push({
+                    displayName: usable.displayName || "Context",
+                    primitive: "Context (use)",
+                    stackError: Error(),
+                    value: fulfilledValue,
+                    debugInfo: null,
+                    dispatcherHookName: "Use"
+                  }), fulfilledValue;
+                }
+                throw Error("An unsupported type was passed to use(): " + String(usable));
+              },
+              useCallback: function useCallback(callback) {
+                var hook = nextHook();
+                hookLog.push({
+                  displayName: null,
+                  primitive: "Callback",
+                  stackError: Error(),
+                  value: null !== hook ? hook.memoizedState[0] : callback,
+                  debugInfo: null,
+                  dispatcherHookName: "Callback"
+                });
+                return callback;
+              },
+              useContext: function useContext(context) {
+                var value = readContext(context);
+                hookLog.push({
+                  displayName: context.displayName || null,
+                  primitive: "Context",
+                  stackError: Error(),
+                  value: value,
+                  debugInfo: null,
+                  dispatcherHookName: "Context"
+                });
+                return value;
+              },
+              useEffect: function useEffect(create) {
+                nextHook();
+                hookLog.push({
+                  displayName: null,
+                  primitive: "Effect",
+                  stackError: Error(),
+                  value: create,
+                  debugInfo: null,
+                  dispatcherHookName: "Effect"
+                });
+              },
+              useImperativeHandle: function useImperativeHandle(ref) {
+                nextHook();
+                var instance = void 0;
+                null !== ref && "object" === _typeof(ref) && (instance = ref.current);
+                hookLog.push({
+                  displayName: null,
+                  primitive: "ImperativeHandle",
+                  stackError: Error(),
+                  value: instance,
+                  debugInfo: null,
+                  dispatcherHookName: "ImperativeHandle"
+                });
+              },
+              useLayoutEffect: function useLayoutEffect(create) {
+                nextHook();
+                hookLog.push({
+                  displayName: null,
+                  primitive: "LayoutEffect",
+                  stackError: Error(),
+                  value: create,
+                  debugInfo: null,
+                  dispatcherHookName: "LayoutEffect"
+                });
+              },
+              useInsertionEffect: function useInsertionEffect(create) {
+                nextHook();
+                hookLog.push({
+                  displayName: null,
+                  primitive: "InsertionEffect",
+                  stackError: Error(),
+                  value: create,
+                  debugInfo: null,
+                  dispatcherHookName: "InsertionEffect"
+                });
+              },
+              useMemo: function useMemo(nextCreate) {
+                var hook = nextHook();
+                nextCreate = null !== hook ? hook.memoizedState[0] : nextCreate();
+                hookLog.push({
+                  displayName: null,
+                  primitive: "Memo",
+                  stackError: Error(),
+                  value: nextCreate,
+                  debugInfo: null,
+                  dispatcherHookName: "Memo"
+                });
+                return nextCreate;
+              },
+              useReducer: function useReducer(reducer, initialArg, init) {
+                reducer = nextHook();
+                initialArg = null !== reducer ? reducer.memoizedState : void 0 !== init ? init(initialArg) : initialArg;
+                hookLog.push({
+                  displayName: null,
+                  primitive: "Reducer",
+                  stackError: Error(),
+                  value: initialArg,
+                  debugInfo: null,
+                  dispatcherHookName: "Reducer"
+                });
+                return [initialArg, function () {}];
+              },
+              useRef: function useRef(initialValue) {
+                var hook = nextHook();
+                initialValue = null !== hook ? hook.memoizedState : {
+                  current: initialValue
+                };
+                hookLog.push({
+                  displayName: null,
+                  primitive: "Ref",
+                  stackError: Error(),
+                  value: initialValue.current,
+                  debugInfo: null,
+                  dispatcherHookName: "Ref"
+                });
+                return initialValue;
+              },
+              useState: function useState(initialState) {
+                var hook = nextHook();
+                initialState = null !== hook ? hook.memoizedState : "function" === typeof initialState ? initialState() : initialState;
+                hookLog.push({
+                  displayName: null,
+                  primitive: "State",
+                  stackError: Error(),
+                  value: initialState,
+                  debugInfo: null,
+                  dispatcherHookName: "State"
+                });
+                return [initialState, function () {}];
+              },
+              useDebugValue: function useDebugValue(value, formatterFn) {
+                hookLog.push({
+                  displayName: null,
+                  primitive: "DebugValue",
+                  stackError: Error(),
+                  value: "function" === typeof formatterFn ? formatterFn(value) : value,
+                  debugInfo: null,
+                  dispatcherHookName: "DebugValue"
+                });
+              },
+              useDeferredValue: function useDeferredValue(value) {
+                var hook = nextHook();
+                value = null !== hook ? hook.memoizedState : value;
+                hookLog.push({
+                  displayName: null,
+                  primitive: "DeferredValue",
+                  stackError: Error(),
+                  value: value,
+                  debugInfo: null,
+                  dispatcherHookName: "DeferredValue"
+                });
+                return value;
+              },
+              useTransition: function useTransition() {
+                var stateHook = nextHook();
+                nextHook();
+                stateHook = null !== stateHook ? stateHook.memoizedState : !1;
+                hookLog.push({
+                  displayName: null,
+                  primitive: "Transition",
+                  stackError: Error(),
+                  value: stateHook,
+                  debugInfo: null,
+                  dispatcherHookName: "Transition"
+                });
+                return [stateHook, function () {}];
+              },
+              useSyncExternalStore: function useSyncExternalStore(subscribe, getSnapshot) {
+                nextHook();
+                nextHook();
+                subscribe = getSnapshot();
+                hookLog.push({
+                  displayName: null,
+                  primitive: "SyncExternalStore",
+                  stackError: Error(),
+                  value: subscribe,
+                  debugInfo: null,
+                  dispatcherHookName: "SyncExternalStore"
+                });
+                return subscribe;
+              },
+              useId: function useId() {
+                var hook = nextHook();
+                hook = null !== hook ? hook.memoizedState : "";
+                hookLog.push({
+                  displayName: null,
+                  primitive: "Id",
+                  stackError: Error(),
+                  value: hook,
+                  debugInfo: null,
+                  dispatcherHookName: "Id"
+                });
+                return hook;
+              },
+              useHostTransitionStatus: function useHostTransitionStatus() {
+                var status = readContext({
+                  _currentValue: null
+                });
+                hookLog.push({
+                  displayName: null,
+                  primitive: "HostTransitionStatus",
+                  stackError: Error(),
+                  value: status,
+                  debugInfo: null,
+                  dispatcherHookName: "HostTransitionStatus"
+                });
+                return status;
+              },
+              useFormState: function useFormState(action, initialState) {
+                var hook = nextHook();
+                nextHook();
+                nextHook();
+                action = Error();
+                var debugInfo = null,
+                  error = null;
+                if (null !== hook) {
+                  if (initialState = hook.memoizedState, "object" === _typeof(initialState) && null !== initialState && "function" === typeof initialState.then) switch (initialState.status) {
+                    case "fulfilled":
+                      var value = initialState.value;
+                      debugInfo = void 0 === initialState._debugInfo ? null : initialState._debugInfo;
+                      break;
+                    case "rejected":
+                      error = initialState.reason;
+                      break;
+                    default:
+                      error = SuspenseException, debugInfo = void 0 === initialState._debugInfo ? null : initialState._debugInfo, value = initialState;
+                  } else value = initialState;
+                } else value = initialState;
+                hookLog.push({
+                  displayName: null,
+                  primitive: "FormState",
+                  stackError: action,
+                  value: value,
+                  debugInfo: debugInfo,
+                  dispatcherHookName: "FormState"
+                });
+                if (null !== error) throw error;
+                return [value, function () {}, !1];
+              },
+              useActionState: function useActionState(action, initialState) {
+                var hook = nextHook();
+                nextHook();
+                nextHook();
+                action = Error();
+                var debugInfo = null,
+                  error = null;
+                if (null !== hook) {
+                  if (initialState = hook.memoizedState, "object" === _typeof(initialState) && null !== initialState && "function" === typeof initialState.then) switch (initialState.status) {
+                    case "fulfilled":
+                      var value = initialState.value;
+                      debugInfo = void 0 === initialState._debugInfo ? null : initialState._debugInfo;
+                      break;
+                    case "rejected":
+                      error = initialState.reason;
+                      break;
+                    default:
+                      error = SuspenseException, debugInfo = void 0 === initialState._debugInfo ? null : initialState._debugInfo, value = initialState;
+                  } else value = initialState;
+                } else value = initialState;
+                hookLog.push({
+                  displayName: null,
+                  primitive: "ActionState",
+                  stackError: action,
+                  value: value,
+                  debugInfo: debugInfo,
+                  dispatcherHookName: "ActionState"
+                });
+                if (null !== error) throw error;
+                return [value, function () {}, !1];
+              },
+              useOptimistic: function useOptimistic(passthrough) {
+                var hook = nextHook();
+                passthrough = null !== hook ? hook.memoizedState : passthrough;
+                hookLog.push({
+                  displayName: null,
+                  primitive: "Optimistic",
+                  stackError: Error(),
+                  value: passthrough,
+                  debugInfo: null,
+                  dispatcherHookName: "Optimistic"
+                });
+                return [passthrough, function () {}];
+              },
+              useMemoCache: function useMemoCache(size) {
+                var fiber = currentFiber;
+                if (null == fiber) return [];
+                fiber = null != fiber.updateQueue ? fiber.updateQueue.memoCache : null;
+                if (null == fiber) return [];
+                var data = fiber.data[fiber.index];
+                if (void 0 === data) {
+                  data = fiber.data[fiber.index] = Array(size);
+                  for (var i = 0; i < size; i++) {
+                    data[i] = REACT_MEMO_CACHE_SENTINEL;
+                  }
+                }
+                fiber.index++;
+                return data;
+              },
+              useCacheRefresh: function useCacheRefresh() {
+                var hook = nextHook();
+                hookLog.push({
+                  displayName: null,
+                  primitive: "CacheRefresh",
+                  stackError: Error(),
+                  value: null !== hook ? hook.memoizedState : function () {},
+                  debugInfo: null,
+                  dispatcherHookName: "CacheRefresh"
+                });
+                return function () {};
+              },
+              useEffectEvent: function useEffectEvent(callback) {
+                nextHook();
+                hookLog.push({
+                  displayName: null,
+                  primitive: "EffectEvent",
+                  stackError: Error(),
+                  value: callback,
+                  debugInfo: null,
+                  dispatcherHookName: "EffectEvent"
+                });
+                return callback;
+              }
+            },
+            DispatcherProxyHandler = {
+              get: function get(target, prop) {
+                if (target.hasOwnProperty(prop)) return target[prop];
+                target = Error("Missing method in Dispatcher: " + prop);
+                target.name = "ReactDebugToolsUnsupportedHookError";
+                throw target;
+              }
+            },
+            DispatcherProxy = "undefined" === typeof Proxy ? Dispatcher : new Proxy(Dispatcher, DispatcherProxyHandler),
+            mostLikelyAncestorIndex = 0;
+          function findSharedIndex(hookStack, rootStack, rootIndex) {
+            var source = rootStack[rootIndex].source,
+              i = 0;
+            a: for (; i < hookStack.length; i++) {
+              if (hookStack[i].source === source) {
+                for (var a = rootIndex + 1, b = i + 1; a < rootStack.length && b < hookStack.length; a++, b++) {
+                  if (hookStack[b].source !== rootStack[a].source) continue a;
+                }
+                return i;
+              }
+            }
+            return -1;
+          }
+          function isReactWrapper(functionName, wrapperName) {
+            functionName = parseHookName(functionName);
+            return "HostTransitionStatus" === wrapperName ? functionName === wrapperName || "FormStatus" === functionName : functionName === wrapperName;
+          }
+          function parseHookName(functionName) {
+            if (!functionName) return "";
+            var startIndex = functionName.lastIndexOf("[as ");
+            if (-1 !== startIndex) return parseHookName(functionName.slice(startIndex + 4, -1));
+            startIndex = functionName.lastIndexOf(".");
+            startIndex = -1 === startIndex ? 0 : startIndex + 1;
+            functionName.slice(startIndex).startsWith("unstable_") && (startIndex += 9);
+            functionName.slice(startIndex).startsWith("experimental_") && (startIndex += 13);
+            if ("use" === functionName.slice(startIndex, startIndex + 3)) {
+              if (3 === functionName.length - startIndex) return "Use";
+              startIndex += 3;
+            }
+            return functionName.slice(startIndex);
+          }
+          function buildTree(rootStack$jscomp$0, readHookLog) {
+            for (var rootChildren = [], prevStack = null, levelChildren = rootChildren, nativeHookID = 0, stackOfChildren = [], i = 0; i < readHookLog.length; i++) {
+              var hook = readHookLog[i];
+              var rootStack = rootStack$jscomp$0;
+              var JSCompiler_inline_result = ErrorStackParser.parse(hook.stackError);
+              b: {
+                var hookStack = JSCompiler_inline_result,
+                  rootIndex = findSharedIndex(hookStack, rootStack, mostLikelyAncestorIndex);
+                if (-1 !== rootIndex) rootStack = rootIndex;else {
+                  for (var i$jscomp$0 = 0; i$jscomp$0 < rootStack.length && 5 > i$jscomp$0; i$jscomp$0++) {
+                    if (rootIndex = findSharedIndex(hookStack, rootStack, i$jscomp$0), -1 !== rootIndex) {
+                      mostLikelyAncestorIndex = i$jscomp$0;
+                      rootStack = rootIndex;
+                      break b;
+                    }
+                  }
+                  rootStack = -1;
+                }
+              }
+              b: {
+                hookStack = JSCompiler_inline_result;
+                rootIndex = getPrimitiveStackCache().get(hook.primitive);
+                if (void 0 !== rootIndex) for (i$jscomp$0 = 0; i$jscomp$0 < rootIndex.length && i$jscomp$0 < hookStack.length; i$jscomp$0++) {
+                  if (rootIndex[i$jscomp$0].source !== hookStack[i$jscomp$0].source) {
+                    i$jscomp$0 < hookStack.length - 1 && isReactWrapper(hookStack[i$jscomp$0].functionName, hook.dispatcherHookName) && i$jscomp$0++;
+                    i$jscomp$0 < hookStack.length - 1 && isReactWrapper(hookStack[i$jscomp$0].functionName, hook.dispatcherHookName) && i$jscomp$0++;
+                    hookStack = i$jscomp$0;
+                    break b;
+                  }
+                }
+                hookStack = -1;
+              }
+              JSCompiler_inline_result = -1 === rootStack || -1 === hookStack || 2 > rootStack - hookStack ? -1 === hookStack ? [null, null] : [JSCompiler_inline_result[hookStack - 1], null] : [JSCompiler_inline_result[hookStack - 1], JSCompiler_inline_result.slice(hookStack, rootStack - 1)];
+              hookStack = JSCompiler_inline_result[0];
+              JSCompiler_inline_result = JSCompiler_inline_result[1];
+              rootStack = hook.displayName;
+              null === rootStack && null !== hookStack && (rootStack = parseHookName(hookStack.functionName) || parseHookName(hook.dispatcherHookName));
+              if (null !== JSCompiler_inline_result) {
+                hookStack = 0;
+                if (null !== prevStack) {
+                  for (; hookStack < JSCompiler_inline_result.length && hookStack < prevStack.length && JSCompiler_inline_result[JSCompiler_inline_result.length - hookStack - 1].source === prevStack[prevStack.length - hookStack - 1].source;) {
+                    hookStack++;
+                  }
+                  for (prevStack = prevStack.length - 1; prevStack > hookStack; prevStack--) {
+                    levelChildren = stackOfChildren.pop();
+                  }
+                }
+                for (prevStack = JSCompiler_inline_result.length - hookStack - 1; 1 <= prevStack; prevStack--) {
+                  hookStack = [], rootIndex = JSCompiler_inline_result[prevStack], rootIndex = {
+                    id: null,
+                    isStateEditable: !1,
+                    name: parseHookName(JSCompiler_inline_result[prevStack - 1].functionName),
+                    value: void 0,
+                    subHooks: hookStack,
+                    debugInfo: null,
+                    hookSource: {
+                      lineNumber: rootIndex.lineNumber,
+                      columnNumber: rootIndex.columnNumber,
+                      functionName: rootIndex.functionName,
+                      fileName: rootIndex.fileName
+                    }
+                  }, levelChildren.push(rootIndex), stackOfChildren.push(levelChildren), levelChildren = hookStack;
+                }
+                prevStack = JSCompiler_inline_result;
+              }
+              hookStack = hook.primitive;
+              rootIndex = hook.debugInfo;
+              hook = {
+                id: "Context" === hookStack || "Context (use)" === hookStack || "DebugValue" === hookStack || "Promise" === hookStack || "Unresolved" === hookStack || "HostTransitionStatus" === hookStack ? null : nativeHookID++,
+                isStateEditable: "Reducer" === hookStack || "State" === hookStack,
+                name: rootStack || hookStack,
+                value: hook.value,
+                subHooks: [],
+                debugInfo: rootIndex,
+                hookSource: null
+              };
+              rootStack = {
+                lineNumber: null,
+                functionName: null,
+                fileName: null,
+                columnNumber: null
+              };
+              JSCompiler_inline_result && 1 <= JSCompiler_inline_result.length && (JSCompiler_inline_result = JSCompiler_inline_result[0], rootStack.lineNumber = JSCompiler_inline_result.lineNumber, rootStack.functionName = JSCompiler_inline_result.functionName, rootStack.fileName = JSCompiler_inline_result.fileName, rootStack.columnNumber = JSCompiler_inline_result.columnNumber);
+              hook.hookSource = rootStack;
+              levelChildren.push(hook);
+            }
+            processDebugValues(rootChildren, null);
+            return rootChildren;
+          }
+          function processDebugValues(hooksTree, parentHooksNode) {
+            for (var debugValueHooksNodes = [], i = 0; i < hooksTree.length; i++) {
+              var hooksNode = hooksTree[i];
+              "DebugValue" === hooksNode.name && 0 === hooksNode.subHooks.length ? (hooksTree.splice(i, 1), i--, debugValueHooksNodes.push(hooksNode)) : processDebugValues(hooksNode.subHooks, hooksNode);
+            }
+            null !== parentHooksNode && (1 === debugValueHooksNodes.length ? parentHooksNode.value = debugValueHooksNodes[0].value : 1 < debugValueHooksNodes.length && (parentHooksNode.value = debugValueHooksNodes.map(function (_ref) {
+              return _ref.value;
+            })));
+          }
+          function handleRenderFunctionError(error) {
+            if (error !== SuspenseException) {
+              if (error instanceof Error && "ReactDebugToolsUnsupportedHookError" === error.name) throw error;
+              var wrapperError = Error("Error rendering inspected component", {
+                cause: error
+              });
+              wrapperError.name = "ReactDebugToolsRenderError";
+              wrapperError.cause = error;
+              throw wrapperError;
+            }
+          }
+          function inspectHooks(renderFunction, props, currentDispatcher) {
+            null == currentDispatcher && (currentDispatcher = ReactSharedInternals);
+            var previousDispatcher = currentDispatcher.H;
+            currentDispatcher.H = DispatcherProxy;
+            try {
+              var ancestorStackError = Error();
+              renderFunction(props);
+            } catch (error) {
+              handleRenderFunctionError(error);
+            } finally {
+              renderFunction = hookLog, hookLog = [], currentDispatcher.H = previousDispatcher;
+            }
+            currentDispatcher = ErrorStackParser.parse(ancestorStackError);
+            return buildTree(currentDispatcher, renderFunction);
+          }
+          function restoreContexts(contextMap) {
+            contextMap.forEach(function (value, context) {
+              return context._currentValue = value;
+            });
+          }
+          __webpack_unused_export__ = inspectHooks;
+          exports.inspectHooksOfFiber = function (fiber, currentDispatcher) {
+            null == currentDispatcher && (currentDispatcher = ReactSharedInternals);
+            if (0 !== fiber.tag && 15 !== fiber.tag && 11 !== fiber.tag) throw Error("Unknown Fiber. Needs to be a function component to inspect hooks.");
+            getPrimitiveStackCache();
+            currentHook = fiber.memoizedState;
+            currentFiber = fiber;
+            if (hasOwnProperty.call(currentFiber, "dependencies")) {
+              var dependencies = currentFiber.dependencies;
+              currentContextDependency = null !== dependencies ? dependencies.firstContext : null;
+            } else if (hasOwnProperty.call(currentFiber, "dependencies_old")) dependencies = currentFiber.dependencies_old, currentContextDependency = null !== dependencies ? dependencies.firstContext : null;else if (hasOwnProperty.call(currentFiber, "dependencies_new")) dependencies = currentFiber.dependencies_new, currentContextDependency = null !== dependencies ? dependencies.firstContext : null;else if (hasOwnProperty.call(currentFiber, "contextDependencies")) dependencies = currentFiber.contextDependencies, currentContextDependency = null !== dependencies ? dependencies.first : null;else throw Error("Unsupported React version. This is a bug in React Debug Tools.");
+            dependencies = fiber.type;
+            var props = fiber.memoizedProps;
+            if (dependencies !== fiber.elementType && dependencies && dependencies.defaultProps) {
+              props = assign({}, props);
+              var defaultProps = dependencies.defaultProps;
+              for (propName in defaultProps) {
+                void 0 === props[propName] && (props[propName] = defaultProps[propName]);
+              }
+            }
+            var propName = new Map();
+            try {
+              if (null !== currentContextDependency && !hasOwnProperty.call(currentContextDependency, "memoizedValue")) for (defaultProps = fiber; defaultProps;) {
+                if (10 === defaultProps.tag) {
+                  var context = defaultProps.type;
+                  void 0 !== context._context && (context = context._context);
+                  propName.has(context) || (propName.set(context, context._currentValue), context._currentValue = defaultProps.memoizedProps.value);
+                }
+                defaultProps = defaultProps.return;
+              }
+              if (11 === fiber.tag) {
+                var renderFunction = dependencies.render;
+                context = props;
+                var ref = fiber.ref;
+                fiber = currentDispatcher;
+                var previousDispatcher = fiber.H;
+                fiber.H = DispatcherProxy;
+                try {
+                  var ancestorStackError = Error();
+                  renderFunction(context, ref);
+                } catch (error) {
+                  handleRenderFunctionError(error);
+                } finally {
+                  var readHookLog = hookLog;
+                  hookLog = [];
+                  fiber.H = previousDispatcher;
+                }
+                var rootStack = ErrorStackParser.parse(ancestorStackError);
+                return buildTree(rootStack, readHookLog);
+              }
+              return inspectHooks(dependencies, props, currentDispatcher);
+            } finally {
+              currentContextDependency = currentHook = currentFiber = null, restoreContexts(propName);
+            }
+          };
+
+          /***/
+        }),
+        /***/987: (/***/function _(module, __unused_webpack_exports, __webpack_require__) {
+          "use strict";
+
+          if (true) {
+            module.exports = __webpack_require__(786);
+          } else {}
+
+          /***/
+        }),
+        /***/126: (/***/function _(__unused_webpack_module, exports, __webpack_require__) {
+          "use strict";
+
+          /* provided dependency */
+          var process = __webpack_require__(169);
+          /**
+           * @license React
+           * react.production.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.
+           */
+
+          function _typeof(obj) {
+            "@babel/helpers - typeof";
+
+            if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+              _typeof = function _typeof(obj) {
+                return typeof obj;
+              };
+            } else {
+              _typeof = function _typeof(obj) {
+                return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+              };
+            }
+            return _typeof(obj);
+          }
+          var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
+            REACT_PORTAL_TYPE = Symbol.for("react.portal"),
+            REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
+            REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
+            REACT_PROFILER_TYPE = Symbol.for("react.profiler"),
+            REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
+            REACT_CONTEXT_TYPE = Symbol.for("react.context"),
+            REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
+            REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
+            REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
+            REACT_MEMO_TYPE = Symbol.for("react.memo"),
+            REACT_LAZY_TYPE = Symbol.for("react.lazy"),
+            REACT_ACTIVITY_TYPE = Symbol.for("react.activity"),
+            REACT_POSTPONE_TYPE = Symbol.for("react.postpone"),
+            REACT_VIEW_TRANSITION_TYPE = Symbol.for("react.view_transition"),
+            MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+          function getIteratorFn(maybeIterable) {
+            if (null === maybeIterable || "object" !== _typeof(maybeIterable)) return null;
+            maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
+            return "function" === typeof maybeIterable ? maybeIterable : null;
+          }
+          var ReactNoopUpdateQueue = {
+              isMounted: function isMounted() {
+                return !1;
+              },
+              enqueueForceUpdate: function enqueueForceUpdate() {},
+              enqueueReplaceState: function enqueueReplaceState() {},
+              enqueueSetState: function enqueueSetState() {}
+            },
+            assign = Object.assign,
+            emptyObject = {};
+          function Component(props, context, updater) {
+            this.props = props;
+            this.context = context;
+            this.refs = emptyObject;
+            this.updater = updater || ReactNoopUpdateQueue;
+          }
+          Component.prototype.isReactComponent = {};
+          Component.prototype.setState = function (partialState, callback) {
+            if ("object" !== _typeof(partialState) && "function" !== typeof partialState && null != partialState) throw Error("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");
+          };
+          Component.prototype.forceUpdate = function (callback) {
+            this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
+          };
+          function ComponentDummy() {}
+          ComponentDummy.prototype = Component.prototype;
+          function PureComponent(props, context, updater) {
+            this.props = props;
+            this.context = context;
+            this.refs = emptyObject;
+            this.updater = updater || ReactNoopUpdateQueue;
+          }
+          var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
+          pureComponentPrototype.constructor = PureComponent;
+          assign(pureComponentPrototype, Component.prototype);
+          pureComponentPrototype.isPureReactComponent = !0;
+          var isArrayImpl = Array.isArray;
+          function noop() {}
+          var ReactSharedInternals = {
+              H: null,
+              A: null,
+              T: null,
+              S: null,
+              G: null
+            },
+            hasOwnProperty = Object.prototype.hasOwnProperty;
+          function ReactElement(type, key, self, source, owner, props) {
+            self = props.ref;
+            return {
+              $$typeof: REACT_ELEMENT_TYPE,
+              type: type,
+              key: key,
+              ref: void 0 !== self ? self : null,
+              props: props
+            };
+          }
+          function cloneAndReplaceKey(oldElement, newKey) {
+            return ReactElement(oldElement.type, newKey, void 0, void 0, void 0, oldElement.props);
+          }
+          function isValidElement(object) {
+            return "object" === _typeof(object) && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+          }
+          function escape(key) {
+            var escaperLookup = {
+              "=": "=0",
+              ":": "=2"
+            };
+            return "$" + key.replace(/[=:]/g, function (match) {
+              return escaperLookup[match];
+            });
+          }
+          var userProvidedKeyEscapeRegex = /\/+/g;
+          function getElementKey(element, index) {
+            return "object" === _typeof(element) && null !== element && null != element.key ? escape("" + element.key) : index.toString(36);
+          }
+          function resolveThenable(thenable) {
+            switch (thenable.status) {
+              case "fulfilled":
+                return thenable.value;
+              case "rejected":
+                throw thenable.reason;
+              default:
+                switch ("string" === typeof thenable.status ? thenable.then(noop, noop) : (thenable.status = "pending", thenable.then(function (fulfilledValue) {
+                  "pending" === thenable.status && (thenable.status = "fulfilled", thenable.value = fulfilledValue);
+                }, function (error) {
+                  "pending" === thenable.status && (thenable.status = "rejected", thenable.reason = error);
+                })), thenable.status) {
+                  case "fulfilled":
+                    return thenable.value;
+                  case "rejected":
+                    throw thenable.reason;
+                }
+            }
+            throw thenable;
+          }
+          function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
+            var type = _typeof(children);
+            if ("undefined" === type || "boolean" === type) children = null;
+            var invokeCallback = !1;
+            if (null === children) invokeCallback = !0;else switch (type) {
+              case "bigint":
+              case "string":
+              case "number":
+                invokeCallback = !0;
+                break;
+              case "object":
+                switch (children.$$typeof) {
+                  case REACT_ELEMENT_TYPE:
+                  case REACT_PORTAL_TYPE:
+                    invokeCallback = !0;
+                    break;
+                  case REACT_LAZY_TYPE:
+                    return invokeCallback = children._init, mapIntoArray(invokeCallback(children._payload), array, escapedPrefix, nameSoFar, callback);
+                }
+            }
+            if (invokeCallback) return callback = callback(children), invokeCallback = "" === nameSoFar ? "." + getElementKey(children, 0) : nameSoFar, isArrayImpl(callback) ? (escapedPrefix = "", null != invokeCallback && (escapedPrefix = invokeCallback.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array, escapedPrefix, "", function (c) {
+              return c;
+            })) : null != callback && (isValidElement(callback) && (callback = cloneAndReplaceKey(callback, escapedPrefix + (null == callback.key || children && children.key === callback.key ? "" : ("" + callback.key).replace(userProvidedKeyEscapeRegex, "$&/") + "/") + invokeCallback)), array.push(callback)), 1;
+            invokeCallback = 0;
+            var nextNamePrefix = "" === nameSoFar ? "." : nameSoFar + ":";
+            if (isArrayImpl(children)) for (var i = 0; i < children.length; i++) {
+              nameSoFar = children[i], type = nextNamePrefix + getElementKey(nameSoFar, i), invokeCallback += mapIntoArray(nameSoFar, array, escapedPrefix, type, callback);
+            } else if (i = getIteratorFn(children), "function" === typeof i) for (children = i.call(children), i = 0; !(nameSoFar = children.next()).done;) {
+              nameSoFar = nameSoFar.value, type = nextNamePrefix + getElementKey(nameSoFar, i++), invokeCallback += mapIntoArray(nameSoFar, array, escapedPrefix, type, callback);
+            } else if ("object" === type) {
+              if ("function" === typeof children.then) return mapIntoArray(resolveThenable(children), array, escapedPrefix, nameSoFar, callback);
+              array = String(children);
+              throw Error("Objects are not valid as a React child (found: " + ("[object Object]" === array ? "object with keys {" + Object.keys(children).join(", ") + "}" : array) + "). If you meant to render a collection of children, use an array instead.");
+            }
+            return invokeCallback;
+          }
+          function mapChildren(children, func, context) {
+            if (null == children) return children;
+            var result = [],
+              count = 0;
+            mapIntoArray(children, result, "", "", function (child) {
+              return func.call(context, child, count++);
+            });
+            return result;
+          }
+          function lazyInitializer(payload) {
+            if (-1 === payload._status) {
+              var ctor = payload._result;
+              ctor = ctor();
+              ctor.then(function (moduleObject) {
+                if (0 === payload._status || -1 === payload._status) payload._status = 1, payload._result = moduleObject;
+              }, function (error) {
+                if (0 === payload._status || -1 === payload._status) payload._status = 2, payload._result = error;
+              });
+              -1 === payload._status && (payload._status = 0, payload._result = ctor);
+            }
+            if (1 === payload._status) return payload._result.default;
+            throw payload._result;
+          }
+          function useOptimistic(passthrough, reducer) {
+            return ReactSharedInternals.H.useOptimistic(passthrough, reducer);
+          }
+          var reportGlobalError = "function" === typeof reportError ? reportError : function (error) {
+            if ("object" === (typeof window === "undefined" ? "undefined" : _typeof(window)) && "function" === typeof window.ErrorEvent) {
+              var event = new window.ErrorEvent("error", {
+                bubbles: !0,
+                cancelable: !0,
+                message: "object" === _typeof(error) && null !== error && "string" === typeof error.message ? String(error.message) : String(error),
+                error: error
+              });
+              if (!window.dispatchEvent(event)) return;
+            } else if ("object" === (typeof process === "undefined" ? "undefined" : _typeof(process)) && "function" === typeof process.emit) {
+              process.emit("uncaughtException", error);
+              return;
+            }
+            console.error(error);
+          };
+          function startTransition(scope) {
+            var prevTransition = ReactSharedInternals.T,
+              currentTransition = {};
+            currentTransition.types = null !== prevTransition ? prevTransition.types : null;
+            currentTransition.gesture = null;
+            ReactSharedInternals.T = currentTransition;
+            try {
+              var returnValue = scope(),
+                onStartTransitionFinish = ReactSharedInternals.S;
+              null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
+              "object" === _typeof(returnValue) && null !== returnValue && "function" === typeof returnValue.then && returnValue.then(noop, reportGlobalError);
+            } catch (error) {
+              reportGlobalError(error);
+            } finally {
+              null !== prevTransition && null !== currentTransition.types && (prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
+            }
+          }
+          function addTransitionType(type) {
+            var transition = ReactSharedInternals.T;
+            if (null !== transition) {
+              var transitionTypes = transition.types;
+              null === transitionTypes ? transition.types = [type] : -1 === transitionTypes.indexOf(type) && transitionTypes.push(type);
+            } else startTransition(addTransitionType.bind(null, type));
+          }
+          exports.Children = {
+            map: mapChildren,
+            forEach: function forEach(children, forEachFunc, forEachContext) {
+              mapChildren(children, function () {
+                forEachFunc.apply(this, arguments);
+              }, forEachContext);
+            },
+            count: function count(children) {
+              var n = 0;
+              mapChildren(children, function () {
+                n++;
+              });
+              return n;
+            },
+            toArray: function toArray(children) {
+              return mapChildren(children, function (child) {
+                return child;
+              }) || [];
+            },
+            only: function only(children) {
+              if (!isValidElement(children)) throw Error("React.Children.only expected to receive a single React element child.");
+              return 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.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
+          exports.__COMPILER_RUNTIME = {
+            __proto__: null,
+            c: function c(size) {
+              return ReactSharedInternals.H.useMemoCache(size);
+            }
+          };
+          exports.cache = function (fn) {
+            return function () {
+              return fn.apply(null, arguments);
+            };
+          };
+          exports.cacheSignal = function () {
+            return null;
+          };
+          exports.cloneElement = function (element, config, children) {
+            if (null === element || void 0 === element) throw Error("The argument must be a React element, but you passed " + element + ".");
+            var props = assign({}, element.props),
+              key = element.key,
+              owner = void 0;
+            if (null != config) for (propName in void 0 !== config.ref && (owner = void 0), void 0 !== config.key && (key = "" + config.key), config) {
+              !hasOwnProperty.call(config, propName) || "key" === propName || "__self" === propName || "__source" === propName || "ref" === propName && void 0 === config.ref || (props[propName] = config[propName]);
+            }
+            var propName = arguments.length - 2;
+            if (1 === propName) props.children = children;else if (1 < propName) {
+              for (var childArray = Array(propName), i = 0; i < propName; i++) {
+                childArray[i] = arguments[i + 2];
+              }
+              props.children = childArray;
+            }
+            return ReactElement(element.type, key, void 0, void 0, owner, props);
+          };
+          exports.createContext = function (defaultValue) {
+            defaultValue = {
+              $$typeof: REACT_CONTEXT_TYPE,
+              _currentValue: defaultValue,
+              _currentValue2: defaultValue,
+              _threadCount: 0,
+              Provider: null,
+              Consumer: null
+            };
+            defaultValue.Provider = defaultValue;
+            defaultValue.Consumer = {
+              $$typeof: REACT_CONSUMER_TYPE,
+              _context: defaultValue
+            };
+            return defaultValue;
+          };
+          exports.createElement = function (type, config, children) {
+            var propName,
+              props = {},
+              key = null;
+            if (null != config) for (propName in void 0 !== config.key && (key = "" + config.key), config) {
+              hasOwnProperty.call(config, propName) && "key" !== propName && "__self" !== propName && "__source" !== propName && (props[propName] = config[propName]);
+            }
+            var childrenLength = arguments.length - 2;
+            if (1 === childrenLength) props.children = children;else if (1 < childrenLength) {
+              for (var childArray = Array(childrenLength), i = 0; i < childrenLength; i++) {
+                childArray[i] = arguments[i + 2];
+              }
+              props.children = childArray;
+            }
+            if (type && type.defaultProps) for (propName in childrenLength = type.defaultProps, childrenLength) {
+              void 0 === props[propName] && (props[propName] = childrenLength[propName]);
+            }
+            return ReactElement(type, key, void 0, void 0, null, props);
+          };
+          exports.createRef = function () {
+            return {
+              current: null
+            };
+          };
+          exports.experimental_useEffectEvent = function (callback) {
+            return ReactSharedInternals.H.useEffectEvent(callback);
+          };
+          exports.experimental_useOptimistic = function (passthrough, reducer) {
+            return useOptimistic(passthrough, reducer);
+          };
+          exports.forwardRef = function (render) {
+            return {
+              $$typeof: REACT_FORWARD_REF_TYPE,
+              render: render
+            };
+          };
+          exports.isValidElement = isValidElement;
+          exports.lazy = function (ctor) {
+            return {
+              $$typeof: REACT_LAZY_TYPE,
+              _payload: {
+                _status: -1,
+                _result: ctor
+              },
+              _init: lazyInitializer
+            };
+          };
+          exports.memo = function (type, compare) {
+            return {
+              $$typeof: REACT_MEMO_TYPE,
+              type: type,
+              compare: void 0 === compare ? null : compare
+            };
+          };
+          exports.startTransition = startTransition;
+          exports.unstable_Activity = REACT_ACTIVITY_TYPE;
+          exports.unstable_SuspenseList = REACT_SUSPENSE_LIST_TYPE;
+          exports.unstable_ViewTransition = REACT_VIEW_TRANSITION_TYPE;
+          exports.unstable_addTransitionType = addTransitionType;
+          exports.unstable_getCacheForType = function (resourceType) {
+            var dispatcher = ReactSharedInternals.A;
+            return dispatcher ? dispatcher.getCacheForType(resourceType) : resourceType();
+          };
+          exports.unstable_postpone = function (reason) {
+            reason = Error(reason);
+            reason.$$typeof = REACT_POSTPONE_TYPE;
+            throw reason;
+          };
+          exports.unstable_startGestureTransition = function (provider, scope, options) {
+            if (null == provider) throw Error("A Timeline is required as the first argument to startGestureTransition.");
+            var prevTransition = ReactSharedInternals.T,
+              currentTransition = {
+                types: null
+              };
+            currentTransition.gesture = provider;
+            ReactSharedInternals.T = currentTransition;
+            try {
+              scope();
+              var onStartGestureTransitionFinish = ReactSharedInternals.G;
+              if (null !== onStartGestureTransitionFinish) return onStartGestureTransitionFinish(currentTransition, provider, options);
+            } catch (error) {
+              reportGlobalError(error);
+            } finally {
+              ReactSharedInternals.T = prevTransition;
+            }
+            return noop;
+          };
+          exports.unstable_useCacheRefresh = function () {
+            return ReactSharedInternals.H.useCacheRefresh();
+          };
+          exports.use = function (usable) {
+            return ReactSharedInternals.H.use(usable);
+          };
+          exports.useActionState = function (action, initialState, permalink) {
+            return ReactSharedInternals.H.useActionState(action, initialState, permalink);
+          };
+          exports.useCallback = function (callback, deps) {
+            return ReactSharedInternals.H.useCallback(callback, deps);
+          };
+          exports.useContext = function (Context) {
+            return ReactSharedInternals.H.useContext(Context);
+          };
+          exports.useDebugValue = function () {};
+          exports.useDeferredValue = function (value, initialValue) {
+            return ReactSharedInternals.H.useDeferredValue(value, initialValue);
+          };
+          exports.useEffect = function (create, deps) {
+            return ReactSharedInternals.H.useEffect(create, deps);
+          };
+          exports.useId = function () {
+            return ReactSharedInternals.H.useId();
+          };
+          exports.useImperativeHandle = function (ref, create, deps) {
+            return ReactSharedInternals.H.useImperativeHandle(ref, create, deps);
+          };
+          exports.useInsertionEffect = function (create, deps) {
+            return ReactSharedInternals.H.useInsertionEffect(create, deps);
+          };
+          exports.useLayoutEffect = function (create, deps) {
+            return ReactSharedInternals.H.useLayoutEffect(create, deps);
+          };
+          exports.useMemo = function (create, deps) {
+            return ReactSharedInternals.H.useMemo(create, deps);
+          };
+          exports.useOptimistic = useOptimistic;
+          exports.useReducer = function (reducer, initialArg, init) {
+            return ReactSharedInternals.H.useReducer(reducer, initialArg, init);
+          };
+          exports.useRef = function (initialValue) {
+            return ReactSharedInternals.H.useRef(initialValue);
+          };
+          exports.useState = function (initialState) {
+            return ReactSharedInternals.H.useState(initialState);
+          };
+          exports.useSyncExternalStore = function (subscribe, getSnapshot, getServerSnapshot) {
+            return ReactSharedInternals.H.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+          };
+          exports.useTransition = function () {
+            return ReactSharedInternals.H.useTransition();
+          };
+          exports.version = "19.2.0-experimental-5d87cd22-20250704";
+
+          /***/
+        }),
+        /***/189: (/***/function _(module, __unused_webpack_exports, __webpack_require__) {
+          "use strict";
+
+          if (true) {
+            module.exports = __webpack_require__(126);
+          } else {}
+
+          /***/
+        }),
+        /***/206: (/***/function _(module, exports, __webpack_require__) {
+          var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;
+          function _typeof(obj) {
+            "@babel/helpers - typeof";
+
+            if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+              _typeof = function _typeof(obj) {
+                return typeof obj;
+              };
+            } else {
+              _typeof = function _typeof(obj) {
+                return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+              };
+            }
+            return _typeof(obj);
+          }
+          (function (root, factory) {
+            'use strict';
+
+            // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js, Rhino, and browsers.
+
+            /* istanbul ignore next */
+            if (true) {
+              !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(430)], __WEBPACK_AMD_DEFINE_FACTORY__ = factory, __WEBPACK_AMD_DEFINE_RESULT__ = typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? __WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__) : __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+            } else {}
+          })(this, function ErrorStackParser(StackFrame) {
+            'use strict';
+
+            var FIREFOX_SAFARI_STACK_REGEXP = /(^|@)\S+:\d+/;
+            var CHROME_IE_STACK_REGEXP = /^\s*at .*(\S+:\d+|\(native\))/m;
+            var SAFARI_NATIVE_CODE_REGEXP = /^(eval@)?(\[native code])?$/;
+            return {
+              /**
+               * Given an Error object, extract the most information from it.
+               *
+               * @param {Error} error object
+               * @return {Array} of StackFrames
+               */
+              parse: function ErrorStackParser$$parse(error) {
+                if (typeof error.stacktrace !== 'undefined' || typeof error['opera#sourceloc'] !== 'undefined') {
+                  return this.parseOpera(error);
+                } else if (error.stack && error.stack.match(CHROME_IE_STACK_REGEXP)) {
+                  return this.parseV8OrIE(error);
+                } else if (error.stack) {
+                  return this.parseFFOrSafari(error);
+                } else {
+                  throw new Error('Cannot parse given Error object');
+                }
+              },
+              // Separate line and column numbers from a string of the form: (URI:Line:Column)
+              extractLocation: function ErrorStackParser$$extractLocation(urlLike) {
+                // Fail-fast but return locations like "(native)"
+                if (urlLike.indexOf(':') === -1) {
+                  return [urlLike];
+                }
+                var regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
+                var parts = regExp.exec(urlLike.replace(/[()]/g, ''));
+                return [parts[1], parts[2] || undefined, parts[3] || undefined];
+              },
+              parseV8OrIE: function ErrorStackParser$$parseV8OrIE(error) {
+                var filtered = error.stack.split('\n').filter(function (line) {
+                  return !!line.match(CHROME_IE_STACK_REGEXP);
+                }, this);
+                return filtered.map(function (line) {
+                  if (line.indexOf('(eval ') > -1) {
+                    // Throw away eval information until we implement stacktrace.js/stackframe#8
+                    line = line.replace(/eval code/g, 'eval').replace(/(\(eval at [^()]*)|(\),.*$)/g, '');
+                  }
+                  var sanitizedLine = line.replace(/^\s+/, '').replace(/\(eval code/g, '('); // capture and preseve the parenthesized location "(/foo/my bar.js:12:87)" in
+                  // case it has spaces in it, as the string is split on \s+ later on
+
+                  var location = sanitizedLine.match(/ (\((.+):(\d+):(\d+)\)$)/); // remove the parenthesized location from the line, if it was matched
+
+                  sanitizedLine = location ? sanitizedLine.replace(location[0], '') : sanitizedLine;
+                  var tokens = sanitizedLine.split(/\s+/).slice(1); // if a location was matched, pass it to extractLocation() otherwise pop the last token
+
+                  var locationParts = this.extractLocation(location ? location[1] : tokens.pop());
+                  var functionName = tokens.join(' ') || undefined;
+                  var fileName = ['eval', '<anonymous>'].indexOf(locationParts[0]) > -1 ? undefined : locationParts[0];
+                  return new StackFrame({
+                    functionName: functionName,
+                    fileName: fileName,
+                    lineNumber: locationParts[1],
+                    columnNumber: locationParts[2],
+                    source: line
+                  });
+                }, this);
+              },
+              parseFFOrSafari: function ErrorStackParser$$parseFFOrSafari(error) {
+                var filtered = error.stack.split('\n').filter(function (line) {
+                  return !line.match(SAFARI_NATIVE_CODE_REGEXP);
+                }, this);
+                return filtered.map(function (line) {
+                  // Throw away eval information until we implement stacktrace.js/stackframe#8
+                  if (line.indexOf(' > eval') > -1) {
+                    line = line.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ':$1');
+                  }
+                  if (line.indexOf('@') === -1 && line.indexOf(':') === -1) {
+                    // Safari eval frames only have function names and nothing else
+                    return new StackFrame({
+                      functionName: line
+                    });
+                  } else {
+                    var functionNameRegex = /((.*".+"[^@]*)?[^@]*)(?:@)/;
+                    var matches = line.match(functionNameRegex);
+                    var functionName = matches && matches[1] ? matches[1] : undefined;
+                    var locationParts = this.extractLocation(line.replace(functionNameRegex, ''));
+                    return new StackFrame({
+                      functionName: functionName,
+                      fileName: locationParts[0],
+                      lineNumber: locationParts[1],
+                      columnNumber: locationParts[2],
+                      source: line
+                    });
+                  }
+                }, this);
+              },
+              parseOpera: function ErrorStackParser$$parseOpera(e) {
+                if (!e.stacktrace || e.message.indexOf('\n') > -1 && e.message.split('\n').length > e.stacktrace.split('\n').length) {
+                  return this.parseOpera9(e);
+                } else if (!e.stack) {
+                  return this.parseOpera10(e);
+                } else {
+                  return this.parseOpera11(e);
+                }
+              },
+              parseOpera9: function ErrorStackParser$$parseOpera9(e) {
+                var lineRE = /Line (\d+).*script (?:in )?(\S+)/i;
+                var lines = e.message.split('\n');
+                var result = [];
+                for (var i = 2, len = lines.length; i < len; i += 2) {
+                  var match = lineRE.exec(lines[i]);
+                  if (match) {
+                    result.push(new StackFrame({
+                      fileName: match[2],
+                      lineNumber: match[1],
+                      source: lines[i]
+                    }));
+                  }
+                }
+                return result;
+              },
+              parseOpera10: function ErrorStackParser$$parseOpera10(e) {
+                var lineRE = /Line (\d+).*script (?:in )?(\S+)(?:: In function (\S+))?$/i;
+                var lines = e.stacktrace.split('\n');
+                var result = [];
+                for (var i = 0, len = lines.length; i < len; i += 2) {
+                  var match = lineRE.exec(lines[i]);
+                  if (match) {
+                    result.push(new StackFrame({
+                      functionName: match[3] || undefined,
+                      fileName: match[2],
+                      lineNumber: match[1],
+                      source: lines[i]
+                    }));
+                  }
+                }
+                return result;
+              },
+              // Opera 10.65+ Error.stack very similar to FF/Safari
+              parseOpera11: function ErrorStackParser$$parseOpera11(error) {
+                var filtered = error.stack.split('\n').filter(function (line) {
+                  return !!line.match(FIREFOX_SAFARI_STACK_REGEXP) && !line.match(/^Error created at/);
+                }, this);
+                return filtered.map(function (line) {
+                  var tokens = line.split('@');
+                  var locationParts = this.extractLocation(tokens.pop());
+                  var functionCall = tokens.shift() || '';
+                  var functionName = functionCall.replace(/<anonymous function(: (\w+))?>/, '$2').replace(/\([^)]*\)/g, '') || undefined;
+                  var argsRaw;
+                  if (functionCall.match(/\(([^)]*)\)/)) {
+                    argsRaw = functionCall.replace(/^[^(]+\(([^)]*)\)$/, '$1');
+                  }
+                  var args = argsRaw === undefined || argsRaw === '[arguments not available]' ? undefined : argsRaw.split(',');
+                  return new StackFrame({
+                    functionName: functionName,
+                    args: args,
+                    fileName: locationParts[0],
+                    lineNumber: locationParts[1],
+                    columnNumber: locationParts[2],
+                    source: line
+                  });
+                }, this);
+              }
+            };
+          });
+
+          /***/
+        }),
+        /***/730: (/***/function _(module, __unused_webpack_exports, __webpack_require__) {
+          "use strict";
+
+          // A linked list to keep track of recently-used-ness
+          function _classCallCheck(instance, Constructor) {
+            if (!(instance instanceof Constructor)) {
+              throw new TypeError("Cannot call a class as a function");
+            }
+          }
+          function _defineProperties(target, props) {
+            for (var i = 0; i < props.length; i++) {
+              var descriptor = props[i];
+              descriptor.enumerable = descriptor.enumerable || false;
+              descriptor.configurable = true;
+              if ("value" in descriptor) descriptor.writable = true;
+              Object.defineProperty(target, descriptor.key, descriptor);
+            }
+          }
+          function _createClass(Constructor, protoProps, staticProps) {
+            if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+            if (staticProps) _defineProperties(Constructor, staticProps);
+            return Constructor;
+          }
+          var Yallist = __webpack_require__(695);
+          var MAX = Symbol('max');
+          var LENGTH = Symbol('length');
+          var LENGTH_CALCULATOR = Symbol('lengthCalculator');
+          var ALLOW_STALE = Symbol('allowStale');
+          var MAX_AGE = Symbol('maxAge');
+          var DISPOSE = Symbol('dispose');
+          var NO_DISPOSE_ON_SET = Symbol('noDisposeOnSet');
+          var LRU_LIST = Symbol('lruList');
+          var CACHE = Symbol('cache');
+          var UPDATE_AGE_ON_GET = Symbol('updateAgeOnGet');
+          var naiveLength = function naiveLength() {
+            return 1;
+          }; // lruList is a yallist where the head is the youngest
+          // item, and the tail is the oldest.  the list contains the Hit
+          // objects as the entries.
+          // Each Hit object has a reference to its Yallist.Node.  This
+          // never changes.
+          //
+          // cache is a Map (or PseudoMap) that matches the keys to
+          // the Yallist.Node object.
+
+          var LRUCache = /*#__PURE__*/function () {
+            function LRUCache(options) {
+              _classCallCheck(this, LRUCache);
+              if (typeof options === 'number') options = {
+                max: options
+              };
+              if (!options) options = {};
+              if (options.max && (typeof options.max !== 'number' || options.max < 0)) throw new TypeError('max must be a non-negative number'); // Kind of weird to have a default max of Infinity, but oh well.
+
+              var max = this[MAX] = options.max || Infinity;
+              var lc = options.length || naiveLength;
+              this[LENGTH_CALCULATOR] = typeof lc !== 'function' ? naiveLength : lc;
+              this[ALLOW_STALE] = options.stale || false;
+              if (options.maxAge && typeof options.maxAge !== 'number') throw new TypeError('maxAge must be a number');
+              this[MAX_AGE] = options.maxAge || 0;
+              this[DISPOSE] = options.dispose;
+              this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;
+              this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false;
+              this.reset();
+            } // resize the cache when the max changes.
+
+            return _createClass(LRUCache, [{
+              key: "max",
+              get: function get() {
+                return this[MAX];
+              },
+              set: function set(mL) {
+                if (typeof mL !== 'number' || mL < 0) throw new TypeError('max must be a non-negative number');
+                this[MAX] = mL || Infinity;
+                trim(this);
+              }
+            }, {
+              key: "allowStale",
+              get: function get() {
+                return this[ALLOW_STALE];
+              },
+              set: function set(allowStale) {
+                this[ALLOW_STALE] = !!allowStale;
+              }
+            }, {
+              key: "maxAge",
+              get: function get() {
+                return this[MAX_AGE];
+              } // resize the cache when the lengthCalculator changes.
+              ,
+
+              set: function set(mA) {
+                if (typeof mA !== 'number') throw new TypeError('maxAge must be a non-negative number');
+                this[MAX_AGE] = mA;
+                trim(this);
+              }
+            }, {
+              key: "lengthCalculator",
+              get: function get() {
+                return this[LENGTH_CALCULATOR];
+              },
+              set: function set(lC) {
+                var _this = this;
+                if (typeof lC !== 'function') lC = naiveLength;
+                if (lC !== this[LENGTH_CALCULATOR]) {
+                  this[LENGTH_CALCULATOR] = lC;
+                  this[LENGTH] = 0;
+                  this[LRU_LIST].forEach(function (hit) {
+                    hit.length = _this[LENGTH_CALCULATOR](hit.value, hit.key);
+                    _this[LENGTH] += hit.length;
+                  });
+                }
+                trim(this);
+              }
+            }, {
+              key: "length",
+              get: function get() {
+                return this[LENGTH];
+              }
+            }, {
+              key: "itemCount",
+              get: function get() {
+                return this[LRU_LIST].length;
+              }
+            }, {
+              key: "rforEach",
+              value: function rforEach(fn, thisp) {
+                thisp = thisp || this;
+                for (var walker = this[LRU_LIST].tail; walker !== null;) {
+                  var prev = walker.prev;
+                  forEachStep(this, fn, walker, thisp);
+                  walker = prev;
+                }
+              }
+            }, {
+              key: "forEach",
+              value: function forEach(fn, thisp) {
+                thisp = thisp || this;
+                for (var walker = this[LRU_LIST].head; walker !== null;) {
+                  var next = walker.next;
+                  forEachStep(this, fn, walker, thisp);
+                  walker = next;
+                }
+              }
+            }, {
+              key: "keys",
+              value: function keys() {
+                return this[LRU_LIST].toArray().map(function (k) {
+                  return k.key;
+                });
+              }
+            }, {
+              key: "values",
+              value: function values() {
+                return this[LRU_LIST].toArray().map(function (k) {
+                  return k.value;
+                });
+              }
+            }, {
+              key: "reset",
+              value: function reset() {
+                var _this2 = this;
+                if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) {
+                  this[LRU_LIST].forEach(function (hit) {
+                    return _this2[DISPOSE](hit.key, hit.value);
+                  });
+                }
+                this[CACHE] = new Map(); // hash of items by key
+
+                this[LRU_LIST] = new Yallist(); // list of items in order of use recency
+
+                this[LENGTH] = 0; // length of items in the list
+              }
+            }, {
+              key: "dump",
+              value: function dump() {
+                var _this3 = this;
+                return this[LRU_LIST].map(function (hit) {
+                  return isStale(_this3, hit) ? false : {
+                    k: hit.key,
+                    v: hit.value,
+                    e: hit.now + (hit.maxAge || 0)
+                  };
+                }).toArray().filter(function (h) {
+                  return h;
+                });
+              }
+            }, {
+              key: "dumpLru",
+              value: function dumpLru() {
+                return this[LRU_LIST];
+              }
+            }, {
+              key: "set",
+              value: function set(key, value, maxAge) {
+                maxAge = maxAge || this[MAX_AGE];
+                if (maxAge && typeof maxAge !== 'number') throw new TypeError('maxAge must be a number');
+                var now = maxAge ? Date.now() : 0;
+                var len = this[LENGTH_CALCULATOR](value, key);
+                if (this[CACHE].has(key)) {
+                  if (len > this[MAX]) {
+                    _del(this, this[CACHE].get(key));
+                    return false;
+                  }
+                  var node = this[CACHE].get(key);
+                  var item = node.value; // dispose of the old one before overwriting
+                  // split out into 2 ifs for better coverage tracking
+
+                  if (this[DISPOSE]) {
+                    if (!this[NO_DISPOSE_ON_SET]) this[DISPOSE](key, item.value);
+                  }
+                  item.now = now;
+                  item.maxAge = maxAge;
+                  item.value = value;
+                  this[LENGTH] += len - item.length;
+                  item.length = len;
+                  this.get(key);
+                  trim(this);
+                  return true;
+                }
+                var hit = new Entry(key, value, len, now, maxAge); // oversized objects fall out of cache automatically.
+
+                if (hit.length > this[MAX]) {
+                  if (this[DISPOSE]) this[DISPOSE](key, value);
+                  return false;
+                }
+                this[LENGTH] += hit.length;
+                this[LRU_LIST].unshift(hit);
+                this[CACHE].set(key, this[LRU_LIST].head);
+                trim(this);
+                return true;
+              }
+            }, {
+              key: "has",
+              value: function has(key) {
+                if (!this[CACHE].has(key)) return false;
+                var hit = this[CACHE].get(key).value;
+                return !isStale(this, hit);
+              }
+            }, {
+              key: "get",
+              value: function get(key) {
+                return _get(this, key, true);
+              }
+            }, {
+              key: "peek",
+              value: function peek(key) {
+                return _get(this, key, false);
+              }
+            }, {
+              key: "pop",
+              value: function pop() {
+                var node = this[LRU_LIST].tail;
+                if (!node) return null;
+                _del(this, node);
+                return node.value;
+              }
+            }, {
+              key: "del",
+              value: function del(key) {
+                _del(this, this[CACHE].get(key));
+              }
+            }, {
+              key: "load",
+              value: function load(arr) {
+                // reset the cache
+                this.reset();
+                var now = Date.now(); // A previous serialized cache has the most recent items first
+
+                for (var l = arr.length - 1; l >= 0; l--) {
+                  var hit = arr[l];
+                  var expiresAt = hit.e || 0;
+                  if (expiresAt === 0)
+                    // the item was created without expiration in a non aged cache
+                    this.set(hit.k, hit.v);else {
+                    var maxAge = expiresAt - now; // dont add already expired items
+
+                    if (maxAge > 0) {
+                      this.set(hit.k, hit.v, maxAge);
+                    }
+                  }
+                }
+              }
+            }, {
+              key: "prune",
+              value: function prune() {
+                var _this4 = this;
+                this[CACHE].forEach(function (value, key) {
+                  return _get(_this4, key, false);
+                });
+              }
+            }]);
+          }();
+          var _get = function _get(self, key, doUse) {
+            var node = self[CACHE].get(key);
+            if (node) {
+              var hit = node.value;
+              if (isStale(self, hit)) {
+                _del(self, node);
+                if (!self[ALLOW_STALE]) return undefined;
+              } else {
+                if (doUse) {
+                  if (self[UPDATE_AGE_ON_GET]) node.value.now = Date.now();
+                  self[LRU_LIST].unshiftNode(node);
+                }
+              }
+              return hit.value;
+            }
+          };
+          var isStale = function isStale(self, hit) {
+            if (!hit || !hit.maxAge && !self[MAX_AGE]) return false;
+            var diff = Date.now() - hit.now;
+            return hit.maxAge ? diff > hit.maxAge : self[MAX_AGE] && diff > self[MAX_AGE];
+          };
+          var trim = function trim(self) {
+            if (self[LENGTH] > self[MAX]) {
+              for (var walker = self[LRU_LIST].tail; self[LENGTH] > self[MAX] && walker !== null;) {
+                // We know that we're about to delete this one, and also
+                // what the next least recently used key will be, so just
+                // go ahead and set it now.
+                var prev = walker.prev;
+                _del(self, walker);
+                walker = prev;
+              }
+            }
+          };
+          var _del = function _del(self, node) {
+            if (node) {
+              var hit = node.value;
+              if (self[DISPOSE]) self[DISPOSE](hit.key, hit.value);
+              self[LENGTH] -= hit.length;
+              self[CACHE].delete(hit.key);
+              self[LRU_LIST].removeNode(node);
+            }
+          };
+          var Entry = /*#__PURE__*/_createClass(function Entry(key, value, length, now, maxAge) {
+            _classCallCheck(this, Entry);
+            this.key = key;
+            this.value = value;
+            this.length = length;
+            this.now = now;
+            this.maxAge = maxAge || 0;
+          });
+          var forEachStep = function forEachStep(self, fn, node, thisp) {
+            var hit = node.value;
+            if (isStale(self, hit)) {
+              _del(self, node);
+              if (!self[ALLOW_STALE]) hit = undefined;
+            }
+            if (hit) fn.call(thisp, hit.value, hit.key, self);
+          };
+          module.exports = LRUCache;
+
+          /***/
+        }),
+        /***/169: (/***/function _(module) {
+          // shim for using process in browser
+          var process = module.exports = {}; // cached from whatever global is present so that test runners that stub it
+          // don't break things.  But we need to wrap it in a try catch in case it is
+          // wrapped in strict mode code which doesn't define any globals.  It's inside a
+          // function because try/catches deoptimize in certain engines.
+
+          var cachedSetTimeout;
+          var cachedClearTimeout;
+          function defaultSetTimout() {
+            throw new Error('setTimeout has not been defined');
+          }
+          function defaultClearTimeout() {
+            throw new Error('clearTimeout has not been defined');
+          }
+          (function () {
+            try {
+              if (typeof setTimeout === 'function') {
+                cachedSetTimeout = setTimeout;
+              } else {
+                cachedSetTimeout = defaultSetTimout;
+              }
+            } catch (e) {
+              cachedSetTimeout = defaultSetTimout;
+            }
+            try {
+              if (typeof clearTimeout === 'function') {
+                cachedClearTimeout = clearTimeout;
+              } else {
+                cachedClearTimeout = defaultClearTimeout;
+              }
+            } catch (e) {
+              cachedClearTimeout = defaultClearTimeout;
+            }
+          })();
+          function runTimeout(fun) {
+            if (cachedSetTimeout === setTimeout) {
+              //normal enviroments in sane situations
+              return setTimeout(fun, 0);
+            } // if setTimeout wasn't available but was latter defined
+
+            if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+              cachedSetTimeout = setTimeout;
+              return setTimeout(fun, 0);
+            }
+            try {
+              // when when somebody has screwed with setTimeout but no I.E. maddness
+              return cachedSetTimeout(fun, 0);
+            } catch (e) {
+              try {
+                // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+                return cachedSetTimeout.call(null, fun, 0);
+              } catch (e) {
+                // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+                return cachedSetTimeout.call(this, fun, 0);
+              }
+            }
+          }
+          function runClearTimeout(marker) {
+            if (cachedClearTimeout === clearTimeout) {
+              //normal enviroments in sane situations
+              return clearTimeout(marker);
+            } // if clearTimeout wasn't available but was latter defined
+
+            if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+              cachedClearTimeout = clearTimeout;
+              return clearTimeout(marker);
+            }
+            try {
+              // when when somebody has screwed with setTimeout but no I.E. maddness
+              return cachedClearTimeout(marker);
+            } catch (e) {
+              try {
+                // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
+                return cachedClearTimeout.call(null, marker);
+              } catch (e) {
+                // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+                // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+                return cachedClearTimeout.call(this, marker);
+              }
+            }
+          }
+          var queue = [];
+          var draining = false;
+          var currentQueue;
+          var queueIndex = -1;
+          function cleanUpNextTick() {
+            if (!draining || !currentQueue) {
+              return;
+            }
+            draining = false;
+            if (currentQueue.length) {
+              queue = currentQueue.concat(queue);
+            } else {
+              queueIndex = -1;
+            }
+            if (queue.length) {
+              drainQueue();
+            }
+          }
+          function drainQueue() {
+            if (draining) {
+              return;
+            }
+            var timeout = runTimeout(cleanUpNextTick);
+            draining = true;
+            var len = queue.length;
+            while (len) {
+              currentQueue = queue;
+              queue = [];
+              while (++queueIndex < len) {
+                if (currentQueue) {
+                  currentQueue[queueIndex].run();
+                }
+              }
+              queueIndex = -1;
+              len = queue.length;
+            }
+            currentQueue = null;
+            draining = false;
+            runClearTimeout(timeout);
+          }
+          process.nextTick = function (fun) {
+            var args = new Array(arguments.length - 1);
+            if (arguments.length > 1) {
+              for (var i = 1; i < arguments.length; i++) {
+                args[i - 1] = arguments[i];
+              }
+            }
+            queue.push(new Item(fun, args));
+            if (queue.length === 1 && !draining) {
+              runTimeout(drainQueue);
+            }
+          }; // v8 likes predictible objects
+
+          function Item(fun, array) {
+            this.fun = fun;
+            this.array = array;
+          }
+          Item.prototype.run = function () {
+            this.fun.apply(null, this.array);
+          };
+          process.title = 'browser';
+          process.browser = true;
+          process.env = {};
+          process.argv = [];
+          process.version = ''; // empty string to avoid regexp issues
+
+          process.versions = {};
+          function noop() {}
+          process.on = noop;
+          process.addListener = noop;
+          process.once = noop;
+          process.off = noop;
+          process.removeListener = noop;
+          process.removeAllListeners = noop;
+          process.emit = noop;
+          process.prependListener = noop;
+          process.prependOnceListener = noop;
+          process.listeners = function (name) {
+            return [];
+          };
+          process.binding = function (name) {
+            throw new Error('process.binding is not supported');
+          };
+          process.cwd = function () {
+            return '/';
+          };
+          process.chdir = function (dir) {
+            throw new Error('process.chdir is not supported');
+          };
+          process.umask = function () {
+            return 0;
+          };
+
+          /***/
+        }),
+        /***/430: (/***/function _(module, exports) {
+          var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;
+          function _typeof(obj) {
+            "@babel/helpers - typeof";
+
+            if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+              _typeof = function _typeof(obj) {
+                return typeof obj;
+              };
+            } else {
+              _typeof = function _typeof(obj) {
+                return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+              };
+            }
+            return _typeof(obj);
+          }
+          (function (root, factory) {
+            'use strict';
+
+            // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js, Rhino, and browsers.
+
+            /* istanbul ignore next */
+            if (true) {
+              !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = factory, __WEBPACK_AMD_DEFINE_RESULT__ = typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? __WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__) : __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+            } else {}
+          })(this, function () {
+            'use strict';
+
+            function _isNumber(n) {
+              return !isNaN(parseFloat(n)) && isFinite(n);
+            }
+            function _capitalize(str) {
+              return str.charAt(0).toUpperCase() + str.substring(1);
+            }
+            function _getter(p) {
+              return function () {
+                return this[p];
+              };
+            }
+            var booleanProps = ['isConstructor', 'isEval', 'isNative', 'isToplevel'];
+            var numericProps = ['columnNumber', 'lineNumber'];
+            var stringProps = ['fileName', 'functionName', 'source'];
+            var arrayProps = ['args'];
+            var props = booleanProps.concat(numericProps, stringProps, arrayProps);
+            function StackFrame(obj) {
+              if (!obj) return;
+              for (var i = 0; i < props.length; i++) {
+                if (obj[props[i]] !== undefined) {
+                  this['set' + _capitalize(props[i])](obj[props[i]]);
+                }
+              }
+            }
+            StackFrame.prototype = {
+              getArgs: function getArgs() {
+                return this.args;
+              },
+              setArgs: function setArgs(v) {
+                if (Object.prototype.toString.call(v) !== '[object Array]') {
+                  throw new TypeError('Args must be an Array');
+                }
+                this.args = v;
+              },
+              getEvalOrigin: function getEvalOrigin() {
+                return this.evalOrigin;
+              },
+              setEvalOrigin: function setEvalOrigin(v) {
+                if (v instanceof StackFrame) {
+                  this.evalOrigin = v;
+                } else if (v instanceof Object) {
+                  this.evalOrigin = new StackFrame(v);
+                } else {
+                  throw new TypeError('Eval Origin must be an Object or StackFrame');
+                }
+              },
+              toString: function toString() {
+                var fileName = this.getFileName() || '';
+                var lineNumber = this.getLineNumber() || '';
+                var columnNumber = this.getColumnNumber() || '';
+                var functionName = this.getFunctionName() || '';
+                if (this.getIsEval()) {
+                  if (fileName) {
+                    return '[eval] (' + fileName + ':' + lineNumber + ':' + columnNumber + ')';
+                  }
+                  return '[eval]:' + lineNumber + ':' + columnNumber;
+                }
+                if (functionName) {
+                  return functionName + ' (' + fileName + ':' + lineNumber + ':' + columnNumber + ')';
+                }
+                return fileName + ':' + lineNumber + ':' + columnNumber;
+              }
+            };
+            StackFrame.fromString = function StackFrame$$fromString(str) {
+              var argsStartIndex = str.indexOf('(');
+              var argsEndIndex = str.lastIndexOf(')');
+              var functionName = str.substring(0, argsStartIndex);
+              var args = str.substring(argsStartIndex + 1, argsEndIndex).split(',');
+              var locationString = str.substring(argsEndIndex + 1);
+              if (locationString.indexOf('@') === 0) {
+                var parts = /@(.+?)(?::(\d+))?(?::(\d+))?$/.exec(locationString, '');
+                var fileName = parts[1];
+                var lineNumber = parts[2];
+                var columnNumber = parts[3];
+              }
+              return new StackFrame({
+                functionName: functionName,
+                args: args || undefined,
+                fileName: fileName,
+                lineNumber: lineNumber || undefined,
+                columnNumber: columnNumber || undefined
+              });
+            };
+            for (var i = 0; i < booleanProps.length; i++) {
+              StackFrame.prototype['get' + _capitalize(booleanProps[i])] = _getter(booleanProps[i]);
+              StackFrame.prototype['set' + _capitalize(booleanProps[i])] = function (p) {
+                return function (v) {
+                  this[p] = Boolean(v);
+                };
+              }(booleanProps[i]);
+            }
+            for (var j = 0; j < numericProps.length; j++) {
+              StackFrame.prototype['get' + _capitalize(numericProps[j])] = _getter(numericProps[j]);
+              StackFrame.prototype['set' + _capitalize(numericProps[j])] = function (p) {
+                return function (v) {
+                  if (!_isNumber(v)) {
+                    throw new TypeError(p + ' must be a Number');
+                  }
+                  this[p] = Number(v);
+                };
+              }(numericProps[j]);
+            }
+            for (var k = 0; k < stringProps.length; k++) {
+              StackFrame.prototype['get' + _capitalize(stringProps[k])] = _getter(stringProps[k]);
+              StackFrame.prototype['set' + _capitalize(stringProps[k])] = function (p) {
+                return function (v) {
+                  this[p] = String(v);
+                };
+              }(stringProps[k]);
+            }
+            return StackFrame;
+          });
+
+          /***/
+        }),
+        /***/476: (/***/function _(module) {
+          "use strict";
+
+          module.exports = function (Yallist) {
+            Yallist.prototype[Symbol.iterator] = /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+              var walker;
+              return _regeneratorRuntime.wrap(function _callee$(_context) {
+                while (1) {
+                  switch (_context.prev = _context.next) {
+                    case 0:
+                      walker = this.head;
+                    case 1:
+                      if (!walker) {
+                        _context.next = 7;
+                        break;
+                      }
+                      _context.next = 4;
+                      return walker.value;
+                    case 4:
+                      walker = walker.next;
+                      _context.next = 1;
+                      break;
+                    case 7:
+                    case "end":
+                      return _context.stop();
+                  }
+                }
+              }, _callee, this);
+            });
+          };
+
+          /***/
+        }),
+        /***/695: (/***/function _(module, __unused_webpack_exports, __webpack_require__) {
+          "use strict";
+
+          module.exports = Yallist;
+          Yallist.Node = Node;
+          Yallist.create = Yallist;
+          function Yallist(list) {
+            var self = this;
+            if (!(self instanceof Yallist)) {
+              self = new Yallist();
+            }
+            self.tail = null;
+            self.head = null;
+            self.length = 0;
+            if (list && typeof list.forEach === 'function') {
+              list.forEach(function (item) {
+                self.push(item);
+              });
+            } else if (arguments.length > 0) {
+              for (var i = 0, l = arguments.length; i < l; i++) {
+                self.push(arguments[i]);
+              }
+            }
+            return self;
+          }
+          Yallist.prototype.removeNode = function (node) {
+            if (node.list !== this) {
+              throw new Error('removing node which does not belong to this list');
+            }
+            var next = node.next;
+            var prev = node.prev;
+            if (next) {
+              next.prev = prev;
+            }
+            if (prev) {
+              prev.next = next;
+            }
+            if (node === this.head) {
+              this.head = next;
+            }
+            if (node === this.tail) {
+              this.tail = prev;
+            }
+            node.list.length--;
+            node.next = null;
+            node.prev = null;
+            node.list = null;
+            return next;
+          };
+          Yallist.prototype.unshiftNode = function (node) {
+            if (node === this.head) {
+              return;
+            }
+            if (node.list) {
+              node.list.removeNode(node);
+            }
+            var head = this.head;
+            node.list = this;
+            node.next = head;
+            if (head) {
+              head.prev = node;
+            }
+            this.head = node;
+            if (!this.tail) {
+              this.tail = node;
+            }
+            this.length++;
+          };
+          Yallist.prototype.pushNode = function (node) {
+            if (node === this.tail) {
+              return;
+            }
+            if (node.list) {
+              node.list.removeNode(node);
+            }
+            var tail = this.tail;
+            node.list = this;
+            node.prev = tail;
+            if (tail) {
+              tail.next = node;
+            }
+            this.tail = node;
+            if (!this.head) {
+              this.head = node;
+            }
+            this.length++;
+          };
+          Yallist.prototype.push = function () {
+            for (var i = 0, l = arguments.length; i < l; i++) {
+              push(this, arguments[i]);
+            }
+            return this.length;
+          };
+          Yallist.prototype.unshift = function () {
+            for (var i = 0, l = arguments.length; i < l; i++) {
+              unshift(this, arguments[i]);
+            }
+            return this.length;
+          };
+          Yallist.prototype.pop = function () {
+            if (!this.tail) {
+              return undefined;
+            }
+            var res = this.tail.value;
+            this.tail = this.tail.prev;
+            if (this.tail) {
+              this.tail.next = null;
+            } else {
+              this.head = null;
+            }
+            this.length--;
+            return res;
+          };
+          Yallist.prototype.shift = function () {
+            if (!this.head) {
+              return undefined;
+            }
+            var res = this.head.value;
+            this.head = this.head.next;
+            if (this.head) {
+              this.head.prev = null;
+            } else {
+              this.tail = null;
+            }
+            this.length--;
+            return res;
+          };
+          Yallist.prototype.forEach = function (fn, thisp) {
+            thisp = thisp || this;
+            for (var walker = this.head, i = 0; walker !== null; i++) {
+              fn.call(thisp, walker.value, i, this);
+              walker = walker.next;
+            }
+          };
+          Yallist.prototype.forEachReverse = function (fn, thisp) {
+            thisp = thisp || this;
+            for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
+              fn.call(thisp, walker.value, i, this);
+              walker = walker.prev;
+            }
+          };
+          Yallist.prototype.get = function (n) {
+            for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
+              // abort out of the list early if we hit a cycle
+              walker = walker.next;
+            }
+            if (i === n && walker !== null) {
+              return walker.value;
+            }
+          };
+          Yallist.prototype.getReverse = function (n) {
+            for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
+              // abort out of the list early if we hit a cycle
+              walker = walker.prev;
+            }
+            if (i === n && walker !== null) {
+              return walker.value;
+            }
+          };
+          Yallist.prototype.map = function (fn, thisp) {
+            thisp = thisp || this;
+            var res = new Yallist();
+            for (var walker = this.head; walker !== null;) {
+              res.push(fn.call(thisp, walker.value, this));
+              walker = walker.next;
+            }
+            return res;
+          };
+          Yallist.prototype.mapReverse = function (fn, thisp) {
+            thisp = thisp || this;
+            var res = new Yallist();
+            for (var walker = this.tail; walker !== null;) {
+              res.push(fn.call(thisp, walker.value, this));
+              walker = walker.prev;
+            }
+            return res;
+          };
+          Yallist.prototype.reduce = function (fn, initial) {
+            var acc;
+            var walker = this.head;
+            if (arguments.length > 1) {
+              acc = initial;
+            } else if (this.head) {
+              walker = this.head.next;
+              acc = this.head.value;
+            } else {
+              throw new TypeError('Reduce of empty list with no initial value');
+            }
+            for (var i = 0; walker !== null; i++) {
+              acc = fn(acc, walker.value, i);
+              walker = walker.next;
+            }
+            return acc;
+          };
+          Yallist.prototype.reduceReverse = function (fn, initial) {
+            var acc;
+            var walker = this.tail;
+            if (arguments.length > 1) {
+              acc = initial;
+            } else if (this.tail) {
+              walker = this.tail.prev;
+              acc = this.tail.value;
+            } else {
+              throw new TypeError('Reduce of empty list with no initial value');
+            }
+            for (var i = this.length - 1; walker !== null; i--) {
+              acc = fn(acc, walker.value, i);
+              walker = walker.prev;
+            }
+            return acc;
+          };
+          Yallist.prototype.toArray = function () {
+            var arr = new Array(this.length);
+            for (var i = 0, walker = this.head; walker !== null; i++) {
+              arr[i] = walker.value;
+              walker = walker.next;
+            }
+            return arr;
+          };
+          Yallist.prototype.toArrayReverse = function () {
+            var arr = new Array(this.length);
+            for (var i = 0, walker = this.tail; walker !== null; i++) {
+              arr[i] = walker.value;
+              walker = walker.prev;
+            }
+            return arr;
+          };
+          Yallist.prototype.slice = function (from, to) {
+            to = to || this.length;
+            if (to < 0) {
+              to += this.length;
+            }
+            from = from || 0;
+            if (from < 0) {
+              from += this.length;
+            }
+            var ret = new Yallist();
+            if (to < from || to < 0) {
+              return ret;
+            }
+            if (from < 0) {
+              from = 0;
+            }
+            if (to > this.length) {
+              to = this.length;
+            }
+            for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
+              walker = walker.next;
+            }
+            for (; walker !== null && i < to; i++, walker = walker.next) {
+              ret.push(walker.value);
+            }
+            return ret;
+          };
+          Yallist.prototype.sliceReverse = function (from, to) {
+            to = to || this.length;
+            if (to < 0) {
+              to += this.length;
+            }
+            from = from || 0;
+            if (from < 0) {
+              from += this.length;
+            }
+            var ret = new Yallist();
+            if (to < from || to < 0) {
+              return ret;
+            }
+            if (from < 0) {
+              from = 0;
+            }
+            if (to > this.length) {
+              to = this.length;
+            }
+            for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
+              walker = walker.prev;
+            }
+            for (; walker !== null && i > from; i--, walker = walker.prev) {
+              ret.push(walker.value);
+            }
+            return ret;
+          };
+          Yallist.prototype.splice = function (start, deleteCount
+          /*, ...nodes */) {
+            if (start > this.length) {
+              start = this.length - 1;
+            }
+            if (start < 0) {
+              start = this.length + start;
+            }
+            for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
+              walker = walker.next;
+            }
+            var ret = [];
+            for (var i = 0; walker && i < deleteCount; i++) {
+              ret.push(walker.value);
+              walker = this.removeNode(walker);
+            }
+            if (walker === null) {
+              walker = this.tail;
+            }
+            if (walker !== this.head && walker !== this.tail) {
+              walker = walker.prev;
+            }
+            for (var i = 2; i < arguments.length; i++) {
+              walker = insert(this, walker, arguments[i]);
+            }
+            return ret;
+          };
+          Yallist.prototype.reverse = function () {
+            var head = this.head;
+            var tail = this.tail;
+            for (var walker = head; walker !== null; walker = walker.prev) {
+              var p = walker.prev;
+              walker.prev = walker.next;
+              walker.next = p;
+            }
+            this.head = tail;
+            this.tail = head;
+            return this;
+          };
+          function insert(self, node, value) {
+            var inserted = node === self.head ? new Node(value, null, node, self) : new Node(value, node, node.next, self);
+            if (inserted.next === null) {
+              self.tail = inserted;
+            }
+            if (inserted.prev === null) {
+              self.head = inserted;
+            }
+            self.length++;
+            return inserted;
+          }
+          function push(self, item) {
+            self.tail = new Node(item, self.tail, null, self);
+            if (!self.head) {
+              self.head = self.tail;
+            }
+            self.length++;
+          }
+          function unshift(self, item) {
+            self.head = new Node(item, null, self.head, self);
+            if (!self.tail) {
+              self.tail = self.head;
+            }
+            self.length++;
+          }
+          function Node(value, prev, next, list) {
+            if (!(this instanceof Node)) {
+              return new Node(value, prev, next, list);
+            }
+            this.list = list;
+            this.value = value;
+            if (prev) {
+              prev.next = this;
+              this.prev = prev;
+            } else {
+              this.prev = null;
+            }
+            if (next) {
+              next.prev = this;
+              this.next = next;
+            } else {
+              this.next = null;
+            }
+          }
+          try {
+            // add if support for Symbol.iterator is present
+            __webpack_require__(476)(Yallist);
+          } catch (er) {}
+
+          /***/
+        })
+
+        /******/
+      };
+      /************************************************************************/
+      /******/ // The module cache
+      /******/
+      var __webpack_module_cache__ = {};
+      /******/
+      /******/ // The require function
+      /******/
+      function __webpack_require__(moduleId) {
+        /******/ // Check if module is in cache
+        /******/var cachedModule = __webpack_module_cache__[moduleId];
+        /******/
+        if (cachedModule !== undefined) {
+          /******/return cachedModule.exports;
+          /******/
+        }
+        /******/ // Create a new module (and put it into the cache)
+        /******/
+        var module = __webpack_module_cache__[moduleId] = {
+          /******/ // no module.id needed
+          /******/ // no module.loaded needed
+          /******/exports: {}
+          /******/
+        };
+        /******/
+        /******/ // Execute the module function
+        /******/
+        __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+        /******/
+        /******/ // Return the exports of the module
+        /******/
+        return module.exports;
+        /******/
+      }
+      /******/
+      /************************************************************************/
+      /******/ /* webpack/runtime/compat get default export */
+      /******/
+      (function () {
+        /******/ // getDefaultExport function for compatibility with non-harmony modules
+        /******/__webpack_require__.n = function (module) {
+          /******/var getter = module && module.__esModule ? /******/function () {
+            return module['default'];
+          } : /******/function () {
+            return module;
+          };
+          /******/
+          __webpack_require__.d(getter, {
+            a: getter
+          });
+          /******/
+          return getter;
+          /******/
+        };
+        /******/
+      })();
+      /******/
+      /******/ /* webpack/runtime/define property getters */
+      /******/
+      (function () {
+        /******/ // define getter functions for harmony exports
+        /******/__webpack_require__.d = function (exports, definition) {
+          /******/for (var key in definition) {
+            /******/if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+              /******/Object.defineProperty(exports, key, {
+                enumerable: true,
+                get: definition[key]
+              });
+              /******/
+            }
+            /******/
+          }
+          /******/
+        };
+        /******/
+      })();
+      /******/
+      /******/ /* webpack/runtime/hasOwnProperty shorthand */
+      /******/
+      (function () {
+        /******/__webpack_require__.o = function (obj, prop) {
+          return Object.prototype.hasOwnProperty.call(obj, prop);
+        };
+        /******/
+      })();
+      /******/
+      /******/ /* webpack/runtime/make namespace object */
+      /******/
+      (function () {
+        /******/ // define __esModule on exports
+        /******/__webpack_require__.r = function (exports) {
+          /******/if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+            /******/Object.defineProperty(exports, Symbol.toStringTag, {
+              value: 'Module'
+            });
+            /******/
+          }
+          /******/
+          Object.defineProperty(exports, '__esModule', {
+            value: true
+          });
+          /******/
+        };
+        /******/
+      })();
+      /******/
+      /************************************************************************/
+      var __webpack_exports__ = {};
+      // This entry need to be wrapped in an IIFE because it need to be in strict mode.
+      (function () {
+        "use strict";
+
+        // ESM COMPAT FLAG
+        __webpack_require__.r(__webpack_exports__);
+
+        // EXPORTS
+        __webpack_require__.d(__webpack_exports__, {
+          "connectToDevTools": function connectToDevTools() {
+            return /* binding */_connectToDevTools;
+          },
+          "connectWithCustomMessagingProtocol": function connectWithCustomMessagingProtocol() {
+            return /* binding */_connectWithCustomMessagingProtocol;
+          },
+          "initialize": function initialize() {
+            return /* binding */backend_initialize;
+          }
+        });
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/events.js
+        function _classCallCheck(instance, Constructor) {
+          if (!(instance instanceof Constructor)) {
+            throw new TypeError("Cannot call a class as a function");
+          }
+        }
+        function _defineProperties(target, props) {
+          for (var i = 0; i < props.length; i++) {
+            var descriptor = props[i];
+            descriptor.enumerable = descriptor.enumerable || false;
+            descriptor.configurable = true;
+            if ("value" in descriptor) descriptor.writable = true;
+            Object.defineProperty(target, descriptor.key, descriptor);
+          }
+        }
+        function _createClass(Constructor, protoProps, staticProps) {
+          if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+          if (staticProps) _defineProperties(Constructor, staticProps);
+          return Constructor;
+        }
+        function _defineProperty(obj, key, value) {
+          if (key in obj) {
+            Object.defineProperty(obj, key, {
+              value: value,
+              enumerable: true,
+              configurable: true,
+              writable: true
+            });
+          } else {
+            obj[key] = value;
+          }
+          return obj;
+        }
+
+        /**
+         * 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.
+         *
+         * 
+         */
+        var EventEmitter = /*#__PURE__*/function () {
+          function EventEmitter() {
+            _classCallCheck(this, EventEmitter);
+            _defineProperty(this, "listenersMap", new Map());
+          }
+          return _createClass(EventEmitter, [{
+            key: "addListener",
+            value: function addListener(event, listener) {
+              var listeners = this.listenersMap.get(event);
+              if (listeners === undefined) {
+                this.listenersMap.set(event, [listener]);
+              } else {
+                var index = listeners.indexOf(listener);
+                if (index < 0) {
+                  listeners.push(listener);
+                }
+              }
+            }
+          }, {
+            key: "emit",
+            value: function emit(event) {
+              var listeners = this.listenersMap.get(event);
+              if (listeners !== undefined) {
+                for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+                  args[_key - 1] = arguments[_key];
+                }
+                if (listeners.length === 1) {
+                  // No need to clone or try/catch
+                  var listener = listeners[0];
+                  listener.apply(null, args);
+                } else {
+                  var didThrow = false;
+                  var caughtError = null;
+                  var clonedListeners = Array.from(listeners);
+                  for (var i = 0; i < clonedListeners.length; i++) {
+                    var _listener = clonedListeners[i];
+                    try {
+                      _listener.apply(null, args);
+                    } catch (error) {
+                      if (caughtError === null) {
+                        didThrow = true;
+                        caughtError = error;
+                      }
+                    }
+                  }
+                  if (didThrow) {
+                    throw caughtError;
+                  }
+                }
+              }
+            }
+          }, {
+            key: "removeAllListeners",
+            value: function removeAllListeners() {
+              this.listenersMap.clear();
+            }
+          }, {
+            key: "removeListener",
+            value: function removeListener(event, listener) {
+              var listeners = this.listenersMap.get(event);
+              if (listeners !== undefined) {
+                var index = listeners.indexOf(listener);
+                if (index >= 0) {
+                  listeners.splice(index, 1);
+                }
+              }
+            }
+          }]);
+        }();
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/constants.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.
+         *
+         * 
+         */
+        var CHROME_WEBSTORE_EXTENSION_ID = 'fmkadmapgofadopljbjfkapdkoienihi';
+        var INTERNAL_EXTENSION_ID = 'dnjnjgbfilfphmojnmhliehogmojhclc';
+        var LOCAL_EXTENSION_ID = 'ikiahnapldjmdmpkmfhjdjilojjhgcbf'; // Flip this flag to true to enable verbose console debug logging.
+
+        var __DEBUG__ = false; // Flip this flag to true to enable performance.mark() and performance.measure() timings.
+
+        var __PERFORMANCE_PROFILE__ = false;
+        var TREE_OPERATION_ADD = 1;
+        var TREE_OPERATION_REMOVE = 2;
+        var TREE_OPERATION_REORDER_CHILDREN = 3;
+        var TREE_OPERATION_UPDATE_TREE_BASE_DURATION = 4;
+        var TREE_OPERATION_UPDATE_ERRORS_OR_WARNINGS = 5;
+        var TREE_OPERATION_REMOVE_ROOT = 6;
+        var TREE_OPERATION_SET_SUBTREE_MODE = 7;
+        var PROFILING_FLAG_BASIC_SUPPORT = 1;
+        var PROFILING_FLAG_TIMELINE_SUPPORT = 2;
+        var LOCAL_STORAGE_DEFAULT_TAB_KEY = 'React::DevTools::defaultTab';
+        var constants_LOCAL_STORAGE_COMPONENT_FILTER_PREFERENCES_KEY = 'React::DevTools::componentFilters';
+        var SESSION_STORAGE_LAST_SELECTION_KEY = 'React::DevTools::lastSelection';
+        var constants_LOCAL_STORAGE_OPEN_IN_EDITOR_URL = 'React::DevTools::openInEditorUrl';
+        var LOCAL_STORAGE_OPEN_IN_EDITOR_URL_PRESET = 'React::DevTools::openInEditorUrlPreset';
+        var LOCAL_STORAGE_PARSE_HOOK_NAMES_KEY = 'React::DevTools::parseHookNames';
+        var constants_SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY = 'React::DevTools::recordChangeDescriptions';
+        var constants_SESSION_STORAGE_RECORD_TIMELINE_KEY = 'React::DevTools::recordTimeline';
+        var constants_SESSION_STORAGE_RELOAD_AND_PROFILE_KEY = 'React::DevTools::reloadAndProfile';
+        var LOCAL_STORAGE_BROWSER_THEME = 'React::DevTools::theme';
+        var LOCAL_STORAGE_TRACE_UPDATES_ENABLED_KEY = 'React::DevTools::traceUpdatesEnabled';
+        var LOCAL_STORAGE_SUPPORTS_PROFILING_KEY = 'React::DevTools::supportsProfiling';
+        var PROFILER_EXPORT_VERSION = 5;
+        var FIREFOX_CONSOLE_DIMMING_COLOR = 'color: rgba(124, 124, 124, 0.75)';
+        var ANSI_STYLE_DIMMING_TEMPLATE = '\x1b[2;38;2;124;124;124m%s\x1b[0m';
+        var ANSI_STYLE_DIMMING_TEMPLATE_WITH_COMPONENT_STACK = '\x1b[2;38;2;124;124;124m%s %o\x1b[0m';
+        ; // CONCATENATED MODULE: ../../node_modules/compare-versions/lib/esm/index.js
+        function _typeof(obj) {
+          "@babel/helpers - typeof";
+
+          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+            _typeof = function _typeof(obj) {
+              return typeof obj;
+            };
+          } else {
+            _typeof = function _typeof(obj) {
+              return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+            };
+          }
+          return _typeof(obj);
+        }
+        function _slicedToArray(arr, i) {
+          return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+        }
+        function _nonIterableRest() {
+          throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+        }
+        function _unsupportedIterableToArray(o, minLen) {
+          if (!o) return;
+          if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+          var n = Object.prototype.toString.call(o).slice(8, -1);
+          if (n === "Object" && o.constructor) n = o.constructor.name;
+          if (n === "Map" || n === "Set") return Array.from(o);
+          if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+        }
+        function _arrayLikeToArray(arr, len) {
+          if (len == null || len > arr.length) len = arr.length;
+          for (var i = 0, arr2 = new Array(len); i < len; i++) {
+            arr2[i] = arr[i];
+          }
+          return arr2;
+        }
+        function _iterableToArrayLimit(arr, i) {
+          if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
+          var _arr = [];
+          var _n = true;
+          var _d = false;
+          var _e = undefined;
+          try {
+            for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+              _arr.push(_s.value);
+              if (i && _arr.length === i) break;
+            }
+          } catch (err) {
+            _d = true;
+            _e = err;
+          } finally {
+            try {
+              if (!_n && _i["return"] != null) _i["return"]();
+            } finally {
+              if (_d) throw _e;
+            }
+          }
+          return _arr;
+        }
+        function _arrayWithHoles(arr) {
+          if (Array.isArray(arr)) return arr;
+        }
+
+        /**
+         * Compare [semver](https://semver.org/) version strings to find greater, equal or lesser.
+         * This library supports the full semver specification, including comparing versions with different number of digits like `1.0.0`, `1.0`, `1`, and pre-release versions like `1.0.0-alpha`.
+         * @param v1 - First version to compare
+         * @param v2 - Second version to compare
+         * @returns Numeric value compatible with the [Array.sort(fn) interface](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#Parameters).
+         */
+        var compareVersions = function compareVersions(v1, v2) {
+          // validate input and split into segments
+          var n1 = validateAndParse(v1);
+          var n2 = validateAndParse(v2); // pop off the patch
+
+          var p1 = n1.pop();
+          var p2 = n2.pop(); // validate numbers
+
+          var r = compareSegments(n1, n2);
+          if (r !== 0) return r; // validate pre-release
+
+          if (p1 && p2) {
+            return compareSegments(p1.split('.'), p2.split('.'));
+          } else if (p1 || p2) {
+            return p1 ? -1 : 1;
+          }
+          return 0;
+        };
+        /**
+         * Validate [semver](https://semver.org/) version strings.
+         *
+         * @param version Version number to validate
+         * @returns `true` if the version number is a valid semver version number, `false` otherwise.
+         *
+         * @example
+         * ```
+         * validate('1.0.0-rc.1'); // return true
+         * validate('1.0-rc.1'); // return false
+         * validate('foo'); // return false
+         * ```
+         */
+
+        var validate = function validate(version) {
+          return typeof version === 'string' && /^[v\d]/.test(version) && semver.test(version);
+        };
+        /**
+         * Compare [semver](https://semver.org/) version strings using the specified operator.
+         *
+         * @param v1 First version to compare
+         * @param v2 Second version to compare
+         * @param operator Allowed arithmetic operator to use
+         * @returns `true` if the comparison between the firstVersion and the secondVersion satisfies the operator, `false` otherwise.
+         *
+         * @example
+         * ```
+         * compare('10.1.8', '10.0.4', '>'); // return true
+         * compare('10.0.1', '10.0.1', '='); // return true
+         * compare('10.1.1', '10.2.2', '<'); // return true
+         * compare('10.1.1', '10.2.2', '<='); // return true
+         * compare('10.1.1', '10.2.2', '>='); // return false
+         * ```
+         */
+
+        var compare = function compare(v1, v2, operator) {
+          // validate input operator
+          assertValidOperator(operator); // since result of compareVersions can only be -1 or 0 or 1
+          // a simple map can be used to replace switch
+
+          var res = compareVersions(v1, v2);
+          return operatorResMap[operator].includes(res);
+        };
+        /**
+         * Match [npm semver](https://docs.npmjs.com/cli/v6/using-npm/semver) version range.
+         *
+         * @param version Version number to match
+         * @param range Range pattern for version
+         * @returns `true` if the version number is within the range, `false` otherwise.
+         *
+         * @example
+         * ```
+         * satisfies('1.1.0', '^1.0.0'); // return true
+         * satisfies('1.1.0', '~1.0.0'); // return false
+         * ```
+         */
+
+        var satisfies = function satisfies(version, range) {
+          // if no range operator then "="
+          var m = range.match(/^([<>=~^]+)/);
+          var op = m ? m[1] : '='; // if gt/lt/eq then operator compare
+
+          if (op !== '^' && op !== '~') return compare(version, range, op); // else range of either "~" or "^" is assumed
+
+          var _validateAndParse = validateAndParse(version),
+            _validateAndParse2 = _slicedToArray(_validateAndParse, 5),
+            v1 = _validateAndParse2[0],
+            v2 = _validateAndParse2[1],
+            v3 = _validateAndParse2[2],
+            vp = _validateAndParse2[4];
+          var _validateAndParse3 = validateAndParse(range),
+            _validateAndParse4 = _slicedToArray(_validateAndParse3, 5),
+            r1 = _validateAndParse4[0],
+            r2 = _validateAndParse4[1],
+            r3 = _validateAndParse4[2],
+            rp = _validateAndParse4[4];
+          var v = [v1, v2, v3];
+          var r = [r1, r2 !== null && r2 !== void 0 ? r2 : 'x', r3 !== null && r3 !== void 0 ? r3 : 'x']; // validate pre-release
+
+          if (rp) {
+            if (!vp) return false;
+            if (compareSegments(v, r) !== 0) return false;
+            if (compareSegments(vp.split('.'), rp.split('.')) === -1) return false;
+          } // first non-zero number
+
+          var nonZero = r.findIndex(function (v) {
+            return v !== '0';
+          }) + 1; // pointer to where segments can be >=
+
+          var i = op === '~' ? 2 : nonZero > 1 ? nonZero : 1; // before pointer must be equal
+
+          if (compareSegments(v.slice(0, i), r.slice(0, i)) !== 0) return false; // after pointer must be >=
+
+          if (compareSegments(v.slice(i), r.slice(i)) === -1) return false;
+          return true;
+        };
+        var semver = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
+        var validateAndParse = function validateAndParse(version) {
+          if (typeof version !== 'string') {
+            throw new TypeError('Invalid argument expected string');
+          }
+          var match = version.match(semver);
+          if (!match) {
+            throw new Error("Invalid argument not valid semver ('".concat(version, "' received)"));
+          }
+          match.shift();
+          return match;
+        };
+        var isWildcard = function isWildcard(s) {
+          return s === '*' || s === 'x' || s === 'X';
+        };
+        var tryParse = function tryParse(v) {
+          var n = parseInt(v, 10);
+          return isNaN(n) ? v : n;
+        };
+        var forceType = function forceType(a, b) {
+          return _typeof(a) !== _typeof(b) ? [String(a), String(b)] : [a, b];
+        };
+        var compareStrings = function compareStrings(a, b) {
+          if (isWildcard(a) || isWildcard(b)) return 0;
+          var _forceType = forceType(tryParse(a), tryParse(b)),
+            _forceType2 = _slicedToArray(_forceType, 2),
+            ap = _forceType2[0],
+            bp = _forceType2[1];
+          if (ap > bp) return 1;
+          if (ap < bp) return -1;
+          return 0;
+        };
+        var compareSegments = function compareSegments(a, b) {
+          for (var i = 0; i < Math.max(a.length, b.length); i++) {
+            var r = compareStrings(a[i] || '0', b[i] || '0');
+            if (r !== 0) return r;
+          }
+          return 0;
+        };
+        var operatorResMap = {
+          '>': [1],
+          '>=': [0, 1],
+          '=': [0],
+          '<=': [-1, 0],
+          '<': [-1]
+        };
+        var allowedOperators = Object.keys(operatorResMap);
+        var assertValidOperator = function assertValidOperator(op) {
+          if (typeof op !== 'string') {
+            throw new TypeError("Invalid operator type, expected string but got ".concat(_typeof(op)));
+          }
+          if (allowedOperators.indexOf(op) === -1) {
+            throw new Error("Invalid operator, expected one of ".concat(allowedOperators.join('|')));
+          }
+        };
+        // EXTERNAL MODULE: ../../node_modules/lru-cache/index.js
+        var lru_cache = __webpack_require__(730);
+        var lru_cache_default = /*#__PURE__*/__webpack_require__.n(lru_cache);
+        ; // CONCATENATED MODULE: ../shared/ReactFeatureFlags.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.
+         *
+         * 
+         */
+        // -----------------------------------------------------------------------------
+        // Land or remove (zero effort)
+        //
+        // Flags that can likely be deleted or landed without consequences
+        // -----------------------------------------------------------------------------
+        // None
+        // -----------------------------------------------------------------------------
+        // 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.
+        // -----------------------------------------------------------------------------
+        var enableHydrationLaneScheduling = true; // -----------------------------------------------------------------------------
+        // 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
+
+        var favorSafetyOverHydrationPerf = true; // Need to remove didTimeout argument from Scheduler before landing
+
+        var disableSchedulerTimeoutInWorkLoop = false; // -----------------------------------------------------------------------------
+        // 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.
+
+        var enableSuspenseCallback = false; // Experimental Scope support.
+
+        var enableScopeAPI = false; // Experimental Create Event Handle API.
+
+        var enableCreateEventHandleAPI = false; // Support legacy Primer support on internal FB www
+
+        var enableLegacyFBSupport = false; // -----------------------------------------------------------------------------
+        // Ongoing experiments
+        //
+        // These are features that we're either actively exploring or are reasonably
+        // likely to include in an upcoming release.
+        // -----------------------------------------------------------------------------
+        // Yield to the browser event loop and not just the scheduler event loop before passive effects.
+        // Fix gated tests that fail with this flag enabled before turning it back on.
+
+        var enableYieldingBeforePassive = false; // Experiment to intentionally yield less to block high framerate animations.
+
+        var enableThrottledScheduling = false;
+        var enableLegacyCache = /* unused pure expression or super */null && true;
+        var enableAsyncIterableChildren = /* unused pure expression or super */null && true;
+        var enableTaint = /* unused pure expression or super */null && true;
+        var enablePostpone = /* unused pure expression or super */null && true;
+        var enableHalt = /* unused pure expression or super */null && true;
+        var enableViewTransition = /* unused pure expression or super */null && true;
+        var enableGestureTransition = /* unused pure expression or super */null && true;
+        var enableScrollEndPolyfill = /* unused pure expression or super */null && true;
+        var enableSuspenseyImages = false;
+        var enableFizzBlockingRender = /* unused pure expression or super */null && true; // rel="expect"
+
+        var enableSrcObject = /* unused pure expression or super */null && true;
+        var enableHydrationChangeEvent = /* unused pure expression or super */null && true;
+        var enableDefaultTransitionIndicator = /* unused pure expression or super */null && true;
+        /**
+         * Switches Fiber creation to a simple object instead of a constructor.
+         */
+
+        var enableObjectFiber = false;
+        var enableTransitionTracing = false; // FB-only usage. The new API has different semantics.
+
+        var enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber
+
+        var enableSuspenseAvoidThisFallback = false;
+        var enableCPUSuspense = /* unused pure expression or super */null && true; // Test this at Meta before enabling.
+
+        var enableNoCloningMemoCache = false;
+        var enableUseEffectEventHook = /* unused pure expression or super */null && true; // Test in www before enabling in open source.
+        // Enables DOM-server to stream its instruction set as data-attributes
+        // (handled with an MutationObserver) instead of inline-scripts
+
+        var enableFizzExternalRuntime = /* unused pure expression or super */null && true;
+        var alwaysThrottleRetries = true;
+        var passChildrenWhenCloningPersistedNodes = false;
+        /**
+         * Enables a new Fiber flag used in persisted mode to reduce the number
+         * of cloned host components.
+         */
+
+        var enablePersistedModeClonedFlag = false;
+        var enableEagerAlternateStateNodeCleanup = true;
+        /**
+         * Enables an expiration time for retry lanes to avoid starvation.
+         */
+
+        var enableRetryLaneExpiration = false;
+        var retryLaneExpirationMs = 5000;
+        var syncLaneExpirationMs = 250;
+        var transitionLaneExpirationMs = 5000;
+        /**
+         * Enables a new error detection for infinite render loops from updates caused
+         * by setState or similar outside of the component owning the state.
+         */
+
+        var enableInfiniteRenderLoopDetection = false;
+        var enableLazyPublicInstanceInFabric = false;
+        var enableFragmentRefs = /* unused pure expression or super */null && true; // -----------------------------------------------------------------------------
+        // Ready for next major.
+        //
+        // Alias __NEXT_MAJOR__ to __EXPERIMENTAL__ for easier skimming.
+        // -----------------------------------------------------------------------------
+        // TODO: Anything that's set to `true` in this section should either be cleaned
+        // up (if it's on everywhere, including Meta and RN builds) or moved to a
+        // different section of this file.
+        // const __NEXT_MAJOR__ = __EXPERIMENTAL__;
+        // Renames the internal symbol for elements since they have changed signature/constructor
+
+        var renameElementSymbol = true;
+        /**
+         * Enables a fix to run insertion effect cleanup on hidden subtrees.
+         */
+
+        var enableHiddenSubtreeInsertionEffectCleanup = false;
+        /**
+         * Removes legacy style context defined using static `contextTypes` and consumed with static `childContextTypes`.
+         */
+
+        var disableLegacyContext = true;
+        /**
+         * Removes legacy style context just from function components.
+         */
+
+        var disableLegacyContextForFunctionComponents = true; // Enable the moveBefore() alternative to insertBefore(). This preserves states of moves.
+
+        var enableMoveBefore = false; // Disabled caching behavior of `react/cache` in client runtimes.
+
+        var disableClientCache = true; // Warn on any usage of ReactTestRenderer
+
+        var enableReactTestRendererWarning = true; // Disables legacy mode
+        // This allows us to land breaking changes to remove legacy mode APIs in experimental builds
+        // before removing them in stable in the next Major
+
+        var disableLegacyMode = true; // -----------------------------------------------------------------------------
+        // Chopping Block
+        //
+        // Planned feature deprecations and breaking changes. Sorted roughly in order of
+        // when we plan to enable them.
+        // -----------------------------------------------------------------------------
+        // -----------------------------------------------------------------------------
+        // 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.
+
+        var disableCommentsAsDOMContainers = true;
+        var enableTrustedTypesIntegration = false; // Prevent the value and checked attributes from syncing with their related
+        // DOM properties
+
+        var disableInputAttributeSyncing = false; // Disables children for <textarea> elements
+
+        var disableTextareaChildren = false; // -----------------------------------------------------------------------------
+        // Debugging and DevTools
+        // -----------------------------------------------------------------------------
+        // Gather advanced timing metrics for Profiler subtrees.
+
+        var enableProfilerTimer = /* unused pure expression or super */null && false; // Adds performance.measure() marks using Chrome extensions to allow formatted
+        // Component rendering tracks to show up in the Performance tab.
+        // This flag will be used for both Server Component and Client Component tracks.
+        // All calls should also be gated on enableProfilerTimer.
+
+        var enableComponentPerformanceTrack = true; // Adds user timing marks for e.g. state updates, suspense, and work loop stuff,
+        // for an experimental timeline tool.
+
+        var enableSchedulingProfiler = !enableComponentPerformanceTrack && false; // Record durations for commit and passive effects phases.
+
+        var enableProfilerCommitHooks = /* unused pure expression or super */null && false; // Phase param passed to onRender callback differentiates between an "update" and a "cascading-update".
+
+        var enableProfilerNestedUpdatePhase = /* unused pure expression or super */null && false;
+        var enableAsyncDebugInfo = /* unused pure expression or super */null && true; // Track which Fiber(s) schedule render work.
+
+        var enableUpdaterTracking = /* unused pure expression or super */null && false;
+        var ownerStackLimit = 1e4;
+        ; // CONCATENATED MODULE: ../shared/ReactSymbols.js
+        function ReactSymbols_typeof(obj) {
+          "@babel/helpers - typeof";
+
+          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+            ReactSymbols_typeof = function _typeof(obj) {
+              return typeof obj;
+            };
+          } else {
+            ReactSymbols_typeof = function _typeof(obj) {
+              return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+            };
+          }
+          return ReactSymbols_typeof(obj);
+        }
+
+        /**
+         * 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.
+         *
+         * 
+         */
+        // 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.
+
+        var REACT_LEGACY_ELEMENT_TYPE = Symbol.for('react.element');
+        var REACT_ELEMENT_TYPE = renameElementSymbol ? Symbol.for('react.transitional.element') : REACT_LEGACY_ELEMENT_TYPE;
+        var REACT_PORTAL_TYPE = Symbol.for('react.portal');
+        var REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+        var REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+        var REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+        var REACT_CONSUMER_TYPE = Symbol.for('react.consumer');
+        var REACT_CONTEXT_TYPE = Symbol.for('react.context');
+        var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+        var REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+        var REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+        var REACT_MEMO_TYPE = Symbol.for('react.memo');
+        var REACT_LAZY_TYPE = Symbol.for('react.lazy');
+        var REACT_SCOPE_TYPE = Symbol.for('react.scope');
+        var REACT_ACTIVITY_TYPE = Symbol.for('react.activity');
+        var REACT_LEGACY_HIDDEN_TYPE = Symbol.for('react.legacy_hidden');
+        var REACT_TRACING_MARKER_TYPE = Symbol.for('react.tracing_marker');
+        var REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+        var REACT_POSTPONE_TYPE = Symbol.for('react.postpone');
+        var REACT_VIEW_TRANSITION_TYPE = Symbol.for('react.view_transition');
+        var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+        var FAUX_ITERATOR_SYMBOL = '@@iterator';
+        function getIteratorFn(maybeIterable) {
+          if (maybeIterable === null || ReactSymbols_typeof(maybeIterable) !== 'object') {
+            return null;
+          }
+          var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+          if (typeof maybeIterator === 'function') {
+            return maybeIterator;
+          }
+          return null;
+        }
+        var ASYNC_ITERATOR = Symbol.asyncIterator;
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/frontend/types.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.
+         *
+         * 
+         */
+
+        /**
+         * WARNING:
+         * This file contains types that are designed for React DevTools UI and how it interacts with the backend.
+         * They might be used in different versions of DevTools backends.
+         * Be mindful of backwards compatibility when making changes.
+         */
+        // WARNING
+        // The values below are referenced by ComponentFilters (which are saved via localStorage).
+        // Do not change them or it will break previously saved user customizations.
+        // If new element types are added, use new numbers rather than re-ordering existing ones.
+        //
+        // Changing these types is also a backwards breaking change for the standalone shell,
+        // since the frontend and backend must share the same values-
+        // and the backend is embedded in certain environments (like React Native).
+        var types_ElementTypeClass = 1;
+        var ElementTypeContext = 2;
+        var types_ElementTypeFunction = 5;
+        var types_ElementTypeForwardRef = 6;
+        var ElementTypeHostComponent = 7;
+        var types_ElementTypeMemo = 8;
+        var ElementTypeOtherOrUnknown = 9;
+        var ElementTypeProfiler = 10;
+        var ElementTypeRoot = 11;
+        var ElementTypeSuspense = 12;
+        var ElementTypeSuspenseList = 13;
+        var ElementTypeTracingMarker = 14;
+        var types_ElementTypeVirtual = 15;
+        var ElementTypeViewTransition = 16;
+        var ElementTypeActivity = 17; // Different types of elements displayed in the Elements tree.
+        // These types may be used to visually distinguish types,
+        // or to enable/disable certain functionality.
+
+        // WARNING
+        // The values below are referenced by ComponentFilters (which are saved via localStorage).
+        // Do not change them or it will break previously saved user customizations.
+        // If new filter types are added, use new numbers rather than re-ordering existing ones.
+        var ComponentFilterElementType = 1;
+        var ComponentFilterDisplayName = 2;
+        var ComponentFilterLocation = 3;
+        var ComponentFilterHOC = 4;
+        var ComponentFilterEnvironmentName = 5; // Hide all elements of types in this Set.
+        // We hide host components only by default.
+        // Hide all elements with displayNames or paths matching one or more of the RegExps in this Set.
+        // Path filters are only used when elements include debug source location.
+        // Map of hook source ("<filename>:<line-number>:<column-number>") to name.
+        // Hook source is used instead of the hook itself because the latter is not stable between element inspections.
+        // We use a Map rather than an Array because of nested hooks and traversal ordering.
+
+        var StrictMode = 1; // Each element on the frontend corresponds to an ElementID (e.g. a Fiber) on the backend.
+        // Some of its information (e.g. id, type, displayName) come from the backend.
+        // Other bits (e.g. weight and depth) are computed on the frontend for windowing and display purposes.
+        // Elements are updated on a push basis– meaning the backend pushes updates to the frontend when needed.
+        // TODO: Add profiling type
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/isArray.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.
+         *
+         * 
+         */
+        var isArray = Array.isArray;
+        /* harmony default export */
+        var src_isArray = isArray;
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/utils.js
+        /* provided dependency */
+        var process = __webpack_require__(169);
+        function ownKeys(object, enumerableOnly) {
+          var keys = Object.keys(object);
+          if (Object.getOwnPropertySymbols) {
+            var symbols = Object.getOwnPropertySymbols(object);
+            if (enumerableOnly) symbols = symbols.filter(function (sym) {
+              return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+            keys.push.apply(keys, symbols);
+          }
+          return keys;
+        }
+        function _objectSpread(target) {
+          for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i] != null ? arguments[i] : {};
+            if (i % 2) {
+              ownKeys(Object(source), true).forEach(function (key) {
+                utils_defineProperty(target, key, source[key]);
+              });
+            } else if (Object.getOwnPropertyDescriptors) {
+              Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+            } else {
+              ownKeys(Object(source)).forEach(function (key) {
+                Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+              });
+            }
+          }
+          return target;
+        }
+        function utils_defineProperty(obj, key, value) {
+          if (key in obj) {
+            Object.defineProperty(obj, key, {
+              value: value,
+              enumerable: true,
+              configurable: true,
+              writable: true
+            });
+          } else {
+            obj[key] = value;
+          }
+          return obj;
+        }
+        function utils_typeof(obj) {
+          "@babel/helpers - typeof";
+
+          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+            utils_typeof = function _typeof(obj) {
+              return typeof obj;
+            };
+          } else {
+            utils_typeof = function _typeof(obj) {
+              return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+            };
+          }
+          return utils_typeof(obj);
+        }
+        function _toConsumableArray(arr) {
+          return _arrayWithoutHoles(arr) || _iterableToArray(arr) || utils_unsupportedIterableToArray(arr) || _nonIterableSpread();
+        }
+        function _nonIterableSpread() {
+          throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+        }
+        function utils_unsupportedIterableToArray(o, minLen) {
+          if (!o) return;
+          if (typeof o === "string") return utils_arrayLikeToArray(o, minLen);
+          var n = Object.prototype.toString.call(o).slice(8, -1);
+          if (n === "Object" && o.constructor) n = o.constructor.name;
+          if (n === "Map" || n === "Set") return Array.from(o);
+          if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return utils_arrayLikeToArray(o, minLen);
+        }
+        function _iterableToArray(iter) {
+          if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
+        }
+        function _arrayWithoutHoles(arr) {
+          if (Array.isArray(arr)) return utils_arrayLikeToArray(arr);
+        }
+        function utils_arrayLikeToArray(arr, len) {
+          if (len == null || len > arr.length) len = arr.length;
+          for (var i = 0, arr2 = new Array(len); i < len; i++) {
+            arr2[i] = arr[i];
+          }
+          return arr2;
+        }
+
+        /**
+         * 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.
+         *
+         * 
+         */
+
+        // $FlowFixMe[method-unbinding]
+
+        var utils_hasOwnProperty = Object.prototype.hasOwnProperty;
+        var cachedDisplayNames = new WeakMap(); // On large trees, encoding takes significant time.
+        // Try to reuse the already encoded strings.
+
+        var encodedStringCache = new (lru_cache_default())({
+          max: 1000
+        }); // Previously, the type of `Context.Provider`.
+
+        var LEGACY_REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+        function alphaSortKeys(a, b) {
+          if (a.toString() > b.toString()) {
+            return 1;
+          } else if (b.toString() > a.toString()) {
+            return -1;
+          } else {
+            return 0;
+          }
+        }
+        function getAllEnumerableKeys(obj) {
+          var keys = new Set();
+          var current = obj;
+          var _loop = function _loop() {
+            var currentKeys = [].concat(_toConsumableArray(Object.keys(current)), _toConsumableArray(Object.getOwnPropertySymbols(current)));
+            var descriptors = Object.getOwnPropertyDescriptors(current);
+            currentKeys.forEach(function (key) {
+              // $FlowFixMe[incompatible-type]: key can be a Symbol https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor
+              if (descriptors[key].enumerable) {
+                keys.add(key);
+              }
+            });
+            current = Object.getPrototypeOf(current);
+          };
+          while (current != null) {
+            _loop();
+          }
+          return keys;
+        } // Mirror https://github.com/facebook/react/blob/7c21bf72ace77094fd1910cc350a548287ef8350/packages/shared/getComponentName.js#L27-L37
+
+        function getWrappedDisplayName(outerType, innerType, wrapperName, fallbackName) {
+          var displayName = outerType === null || outerType === void 0 ? void 0 : outerType.displayName;
+          return displayName || "".concat(wrapperName, "(").concat(getDisplayName(innerType, fallbackName), ")");
+        }
+        function getDisplayName(type) {
+          var fallbackName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'Anonymous';
+          var nameFromCache = cachedDisplayNames.get(type);
+          if (nameFromCache != null) {
+            return nameFromCache;
+          }
+          var displayName = fallbackName; // The displayName property is not guaranteed to be a string.
+          // It's only safe to use for our purposes if it's a string.
+          // github.com/facebook/react-devtools/issues/803
+
+          if (typeof type.displayName === 'string') {
+            displayName = type.displayName;
+          } else if (typeof type.name === 'string' && type.name !== '') {
+            displayName = type.name;
+          }
+          cachedDisplayNames.set(type, displayName);
+          return displayName;
+        }
+        var uidCounter = 0;
+        function getUID() {
+          return ++uidCounter;
+        }
+        function utfDecodeStringWithRanges(array, left, right) {
+          var string = '';
+          for (var i = left; i <= right; i++) {
+            string += String.fromCodePoint(array[i]);
+          }
+          return string;
+        }
+        function surrogatePairToCodePoint(charCode1, charCode2) {
+          return ((charCode1 & 0x3ff) << 10) + (charCode2 & 0x3ff) + 0x10000;
+        } // Credit for this encoding approach goes to Tim Down:
+        // https://stackoverflow.com/questions/4877326/how-can-i-tell-if-a-string-contains-multibyte-characters-in-javascript
+
+        function utfEncodeString(string) {
+          var cached = encodedStringCache.get(string);
+          if (cached !== undefined) {
+            return cached;
+          }
+          var encoded = [];
+          var i = 0;
+          var charCode;
+          while (i < string.length) {
+            charCode = string.charCodeAt(i); // Handle multibyte unicode characters (like emoji).
+
+            if ((charCode & 0xf800) === 0xd800) {
+              encoded.push(surrogatePairToCodePoint(charCode, string.charCodeAt(++i)));
+            } else {
+              encoded.push(charCode);
+            }
+            ++i;
+          }
+          encodedStringCache.set(string, encoded);
+          return encoded;
+        }
+        function printOperationsArray(operations) {
+          // The first two values are always rendererID and rootID
+          var rendererID = operations[0];
+          var rootID = operations[1];
+          var logs = ["operations for renderer:".concat(rendererID, " and root:").concat(rootID)];
+          var i = 2; // Reassemble the string table.
+
+          var stringTable = [null // ID = 0 corresponds to the null string.
+          ];
+          var stringTableSize = operations[i++];
+          var stringTableEnd = i + stringTableSize;
+          while (i < stringTableEnd) {
+            var nextLength = operations[i++];
+            var nextString = utfDecodeStringWithRanges(operations, i, i + nextLength - 1);
+            stringTable.push(nextString);
+            i += nextLength;
+          }
+          while (i < operations.length) {
+            var operation = operations[i];
+            switch (operation) {
+              case TREE_OPERATION_ADD:
+                {
+                  var _id = operations[i + 1];
+                  var type = operations[i + 2];
+                  i += 3;
+                  if (type === ElementTypeRoot) {
+                    logs.push("Add new root node ".concat(_id));
+                    i++; // isStrictModeCompliant
+
+                    i++; // supportsProfiling
+
+                    i++; // supportsStrictMode
+
+                    i++; // hasOwnerMetadata
+                  } else {
+                    var parentID = operations[i];
+                    i++;
+                    i++; // ownerID
+
+                    var displayNameStringID = operations[i];
+                    var displayName = stringTable[displayNameStringID];
+                    i++;
+                    i++; // key
+
+                    logs.push("Add node ".concat(_id, " (").concat(displayName || 'null', ") as child of ").concat(parentID));
+                  }
+                  break;
+                }
+              case TREE_OPERATION_REMOVE:
+                {
+                  var removeLength = operations[i + 1];
+                  i += 2;
+                  for (var removeIndex = 0; removeIndex < removeLength; removeIndex++) {
+                    var _id2 = operations[i];
+                    i += 1;
+                    logs.push("Remove node ".concat(_id2));
+                  }
+                  break;
+                }
+              case TREE_OPERATION_REMOVE_ROOT:
+                {
+                  i += 1;
+                  logs.push("Remove root ".concat(rootID));
+                  break;
+                }
+              case TREE_OPERATION_SET_SUBTREE_MODE:
+                {
+                  var _id3 = operations[i + 1];
+                  var mode = operations[i + 1];
+                  i += 3;
+                  logs.push("Mode ".concat(mode, " set for subtree with root ").concat(_id3));
+                  break;
+                }
+              case TREE_OPERATION_REORDER_CHILDREN:
+                {
+                  var _id4 = operations[i + 1];
+                  var numChildren = operations[i + 2];
+                  i += 3;
+                  var children = operations.slice(i, i + numChildren);
+                  i += numChildren;
+                  logs.push("Re-order node ".concat(_id4, " children ").concat(children.join(',')));
+                  break;
+                }
+              case TREE_OPERATION_UPDATE_TREE_BASE_DURATION:
+                // Base duration updates are only sent while profiling is in progress.
+                // We can ignore them at this point.
+                // The profiler UI uses them lazily in order to generate the tree.
+                i += 3;
+                break;
+              case TREE_OPERATION_UPDATE_ERRORS_OR_WARNINGS:
+                var id = operations[i + 1];
+                var numErrors = operations[i + 2];
+                var numWarnings = operations[i + 3];
+                i += 4;
+                logs.push("Node ".concat(id, " has ").concat(numErrors, " errors and ").concat(numWarnings, " warnings"));
+                break;
+              default:
+                throw Error("Unsupported Bridge operation \"".concat(operation, "\""));
+            }
+          }
+          console.log(logs.join('\n  '));
+        }
+        function getDefaultComponentFilters() {
+          return [{
+            type: ComponentFilterElementType,
+            value: ElementTypeHostComponent,
+            isEnabled: true
+          }];
+        }
+        function getSavedComponentFilters() {
+          try {
+            var raw = localStorageGetItem(LOCAL_STORAGE_COMPONENT_FILTER_PREFERENCES_KEY);
+            if (raw != null) {
+              var parsedFilters = JSON.parse(raw);
+              return filterOutLocationComponentFilters(parsedFilters);
+            }
+          } catch (error) {}
+          return getDefaultComponentFilters();
+        }
+        function setSavedComponentFilters(componentFilters) {
+          localStorageSetItem(LOCAL_STORAGE_COMPONENT_FILTER_PREFERENCES_KEY, JSON.stringify(filterOutLocationComponentFilters(componentFilters)));
+        } // Following __debugSource removal from Fiber, the new approach for finding the source location
+        // of a component, represented by the Fiber, is based on lazily generating and parsing component stack frames
+        // To find the original location, React DevTools will perform symbolication, source maps are required for that.
+        // In order to start filtering Fibers, we need to find location for all of them, which can't be done lazily.
+        // Eager symbolication can become quite expensive for large applications.
+
+        function filterOutLocationComponentFilters(componentFilters) {
+          // This is just an additional check to preserve the previous state
+          // Filters can be stored on the backend side or in user land (in a window object)
+          if (!Array.isArray(componentFilters)) {
+            return componentFilters;
+          }
+          return componentFilters.filter(function (f) {
+            return f.type !== ComponentFilterLocation;
+          });
+        }
+        function getDefaultOpenInEditorURL() {
+          return typeof process.env.EDITOR_URL === 'string' ? process.env.EDITOR_URL : '';
+        }
+        function getOpenInEditorURL() {
+          try {
+            var raw = localStorageGetItem(LOCAL_STORAGE_OPEN_IN_EDITOR_URL);
+            if (raw != null) {
+              return JSON.parse(raw);
+            }
+          } catch (error) {}
+          return getDefaultOpenInEditorURL();
+        }
+        function parseElementDisplayNameFromBackend(displayName, type) {
+          if (displayName === null) {
+            return {
+              formattedDisplayName: null,
+              hocDisplayNames: null,
+              compiledWithForget: false
+            };
+          }
+          if (displayName.startsWith('Forget(')) {
+            var displayNameWithoutForgetWrapper = displayName.slice(7, displayName.length - 1);
+            var _parseElementDisplayN = parseElementDisplayNameFromBackend(displayNameWithoutForgetWrapper, type),
+              formattedDisplayName = _parseElementDisplayN.formattedDisplayName,
+              _hocDisplayNames = _parseElementDisplayN.hocDisplayNames;
+            return {
+              formattedDisplayName: formattedDisplayName,
+              hocDisplayNames: _hocDisplayNames,
+              compiledWithForget: true
+            };
+          }
+          var hocDisplayNames = null;
+          switch (type) {
+            case ElementTypeClass:
+            case ElementTypeForwardRef:
+            case ElementTypeFunction:
+            case ElementTypeMemo:
+            case ElementTypeVirtual:
+              if (displayName.indexOf('(') >= 0) {
+                var matches = displayName.match(/[^()]+/g);
+                if (matches != null) {
+                  // $FlowFixMe[incompatible-type]
+                  displayName = matches.pop();
+                  hocDisplayNames = matches;
+                }
+              }
+              break;
+            default:
+              break;
+          }
+          return {
+            // $FlowFixMe[incompatible-return]
+            formattedDisplayName: displayName,
+            hocDisplayNames: hocDisplayNames,
+            compiledWithForget: false
+          };
+        } // Pulled from react-compat
+        // https://github.com/developit/preact-compat/blob/7c5de00e7c85e2ffd011bf3af02899b63f699d3a/src/index.js#L349
+
+        function shallowDiffers(prev, next) {
+          for (var attribute in prev) {
+            if (!(attribute in next)) {
+              return true;
+            }
+          }
+          for (var _attribute in next) {
+            if (prev[_attribute] !== next[_attribute]) {
+              return true;
+            }
+          }
+          return false;
+        }
+        function utils_getInObject(object, path) {
+          return path.reduce(function (reduced, attr) {
+            if (reduced) {
+              if (utils_hasOwnProperty.call(reduced, attr)) {
+                return reduced[attr];
+              }
+              if (typeof reduced[Symbol.iterator] === 'function') {
+                // Convert iterable to array and return array[index]
+                //
+                // TRICKY
+                // Don't use [...spread] syntax for this purpose.
+                // This project uses @babel/plugin-transform-spread in "loose" mode which only works with Array values.
+                // Other types (e.g. typed arrays, Sets) will not spread correctly.
+                return Array.from(reduced)[attr];
+              }
+            }
+            return null;
+          }, object);
+        }
+        function deletePathInObject(object, path) {
+          var length = path.length;
+          var last = path[length - 1];
+          if (object != null) {
+            var parent = utils_getInObject(object, path.slice(0, length - 1));
+            if (parent) {
+              if (src_isArray(parent)) {
+                parent.splice(last, 1);
+              } else {
+                delete parent[last];
+              }
+            }
+          }
+        }
+        function renamePathInObject(object, oldPath, newPath) {
+          var length = oldPath.length;
+          if (object != null) {
+            var parent = utils_getInObject(object, oldPath.slice(0, length - 1));
+            if (parent) {
+              var lastOld = oldPath[length - 1];
+              var lastNew = newPath[length - 1];
+              parent[lastNew] = parent[lastOld];
+              if (src_isArray(parent)) {
+                parent.splice(lastOld, 1);
+              } else {
+                delete parent[lastOld];
+              }
+            }
+          }
+        }
+        function utils_setInObject(object, path, value) {
+          var length = path.length;
+          var last = path[length - 1];
+          if (object != null) {
+            var parent = utils_getInObject(object, path.slice(0, length - 1));
+            if (parent) {
+              parent[last] = value;
+            }
+          }
+        }
+        function isError(data) {
+          // If it doesn't event look like an error, it won't be an actual error.
+          if ('name' in data && 'message' in data) {
+            while (data) {
+              // $FlowFixMe[method-unbinding]
+              if (Object.prototype.toString.call(data) === '[object Error]') {
+                return true;
+              }
+              data = Object.getPrototypeOf(data);
+            }
+          }
+          return false;
+        }
+        /**
+         * Get a enhanced/artificial type string based on the object instance
+         */
+
+        function getDataType(data) {
+          if (data === null) {
+            return 'null';
+          } else if (data === undefined) {
+            return 'undefined';
+          }
+          if (typeof HTMLElement !== 'undefined' && data instanceof HTMLElement) {
+            return 'html_element';
+          }
+          var type = utils_typeof(data);
+          switch (type) {
+            case 'bigint':
+              return 'bigint';
+            case 'boolean':
+              return 'boolean';
+            case 'function':
+              return 'function';
+            case 'number':
+              if (Number.isNaN(data)) {
+                return 'nan';
+              } else if (!Number.isFinite(data)) {
+                return 'infinity';
+              } else {
+                return 'number';
+              }
+            case 'object':
+              if (data.$$typeof === REACT_ELEMENT_TYPE || data.$$typeof === REACT_LEGACY_ELEMENT_TYPE) {
+                return 'react_element';
+              }
+              if (src_isArray(data)) {
+                return 'array';
+              } else if (ArrayBuffer.isView(data)) {
+                return utils_hasOwnProperty.call(data.constructor, 'BYTES_PER_ELEMENT') ? 'typed_array' : 'data_view';
+              } else if (data.constructor && data.constructor.name === 'ArrayBuffer') {
+                // HACK This ArrayBuffer check is gross; is there a better way?
+                // We could try to create a new DataView with the value.
+                // If it doesn't error, we know it's an ArrayBuffer,
+                // but this seems kind of awkward and expensive.
+                return 'array_buffer';
+              } else if (typeof data[Symbol.iterator] === 'function') {
+                var iterator = data[Symbol.iterator]();
+                if (!iterator) {// Proxies might break assumptoins about iterators.
+                  // See github.com/facebook/react/issues/21654
+                } else {
+                  return iterator === data ? 'opaque_iterator' : 'iterator';
+                }
+              } else if (data.constructor && data.constructor.name === 'RegExp') {
+                return 'regexp';
+              } else if (typeof data.then === 'function') {
+                return 'thenable';
+              } else if (isError(data)) {
+                return 'error';
+              } else {
+                // $FlowFixMe[method-unbinding]
+                var toStringValue = Object.prototype.toString.call(data);
+                if (toStringValue === '[object Date]') {
+                  return 'date';
+                } else if (toStringValue === '[object HTMLAllCollection]') {
+                  return 'html_all_collection';
+                }
+              }
+              if (!isPlainObject(data)) {
+                return 'class_instance';
+              }
+              return 'object';
+            case 'string':
+              return 'string';
+            case 'symbol':
+              return 'symbol';
+            case 'undefined':
+              if (
+              // $FlowFixMe[method-unbinding]
+              Object.prototype.toString.call(data) === '[object HTMLAllCollection]') {
+                return 'html_all_collection';
+              }
+              return 'undefined';
+            default:
+              return 'unknown';
+          }
+        } // Fork of packages/react-is/src/ReactIs.js:30, but with legacy element type
+        // Which has been changed in https://github.com/facebook/react/pull/28813
+
+        function typeOfWithLegacyElementSymbol(object) {
+          if (utils_typeof(object) === 'object' && object !== null) {
+            var $$typeof = object.$$typeof;
+            switch ($$typeof) {
+              case REACT_ELEMENT_TYPE:
+              case REACT_LEGACY_ELEMENT_TYPE:
+                var type = object.type;
+                switch (type) {
+                  case REACT_FRAGMENT_TYPE:
+                  case REACT_PROFILER_TYPE:
+                  case REACT_STRICT_MODE_TYPE:
+                  case REACT_SUSPENSE_TYPE:
+                  case REACT_SUSPENSE_LIST_TYPE:
+                  case REACT_VIEW_TRANSITION_TYPE:
+                    return type;
+                  default:
+                    var $$typeofType = type && type.$$typeof;
+                    switch ($$typeofType) {
+                      case REACT_CONTEXT_TYPE:
+                      case REACT_FORWARD_REF_TYPE:
+                      case REACT_LAZY_TYPE:
+                      case REACT_MEMO_TYPE:
+                        return $$typeofType;
+                      case REACT_CONSUMER_TYPE:
+                        return $$typeofType;
+                      // Fall through
+
+                      default:
+                        return $$typeof;
+                    }
+                }
+              case REACT_PORTAL_TYPE:
+                return $$typeof;
+            }
+          }
+          return undefined;
+        }
+        function getDisplayNameForReactElement(element) {
+          var elementType = typeOfWithLegacyElementSymbol(element);
+          switch (elementType) {
+            case REACT_CONSUMER_TYPE:
+              return 'ContextConsumer';
+            case LEGACY_REACT_PROVIDER_TYPE:
+              return 'ContextProvider';
+            case REACT_CONTEXT_TYPE:
+              return 'Context';
+            case REACT_FORWARD_REF_TYPE:
+              return 'ForwardRef';
+            case REACT_FRAGMENT_TYPE:
+              return 'Fragment';
+            case REACT_LAZY_TYPE:
+              return 'Lazy';
+            case REACT_MEMO_TYPE:
+              return 'Memo';
+            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_VIEW_TRANSITION_TYPE:
+              return 'ViewTransition';
+            case REACT_TRACING_MARKER_TYPE:
+              return 'TracingMarker';
+            default:
+              var type = element.type;
+              if (typeof type === 'string') {
+                return type;
+              } else if (typeof type === 'function') {
+                return getDisplayName(type, 'Anonymous');
+              } else if (type != null) {
+                return 'NotImplementedInDevtools';
+              } else {
+                return 'Element';
+              }
+          }
+        }
+        var MAX_PREVIEW_STRING_LENGTH = 50;
+        function truncateForDisplay(string) {
+          var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : MAX_PREVIEW_STRING_LENGTH;
+          if (string.length > length) {
+            return string.slice(0, length) + '…';
+          } else {
+            return string;
+          }
+        } // Attempts to mimic Chrome's inline preview for values.
+        // For example, the following value...
+        //   {
+        //      foo: 123,
+        //      bar: "abc",
+        //      baz: [true, false],
+        //      qux: { ab: 1, cd: 2 }
+        //   };
+        //
+        // Would show a preview of...
+        //   {foo: 123, bar: "abc", baz: Array(2), qux: {…}}
+        //
+        // And the following value...
+        //   [
+        //     123,
+        //     "abc",
+        //     [true, false],
+        //     { foo: 123, bar: "abc" }
+        //   ];
+        //
+        // Would show a preview of...
+        //   [123, "abc", Array(2), {…}]
+
+        function formatDataForPreview(data, showFormattedValue) {
+          if (data != null && utils_hasOwnProperty.call(data, meta.type)) {
+            return showFormattedValue ? data[meta.preview_long] : data[meta.preview_short];
+          }
+          var type = getDataType(data);
+          switch (type) {
+            case 'html_element':
+              return "<".concat(truncateForDisplay(data.tagName.toLowerCase()), " />");
+            case 'function':
+              if (typeof data.name === 'function' || data.name === '') {
+                return '() => {}';
+              }
+              return "".concat(truncateForDisplay(data.name), "() {}");
+            case 'string':
+              return "\"".concat(data, "\"");
+            case 'bigint':
+              return truncateForDisplay(data.toString() + 'n');
+            case 'regexp':
+              return truncateForDisplay(data.toString());
+            case 'symbol':
+              return truncateForDisplay(data.toString());
+            case 'react_element':
+              return "<".concat(truncateForDisplay(getDisplayNameForReactElement(data) || 'Unknown'), " />");
+            case 'array_buffer':
+              return "ArrayBuffer(".concat(data.byteLength, ")");
+            case 'data_view':
+              return "DataView(".concat(data.buffer.byteLength, ")");
+            case 'array':
+              if (showFormattedValue) {
+                var formatted = '';
+                for (var i = 0; i < data.length; i++) {
+                  if (i > 0) {
+                    formatted += ', ';
+                  }
+                  formatted += formatDataForPreview(data[i], false);
+                  if (formatted.length > MAX_PREVIEW_STRING_LENGTH) {
+                    // Prevent doing a lot of unnecessary iteration...
+                    break;
+                  }
+                }
+                return "[".concat(truncateForDisplay(formatted), "]");
+              } else {
+                var length = utils_hasOwnProperty.call(data, meta.size) ? data[meta.size] : data.length;
+                return "Array(".concat(length, ")");
+              }
+            case 'typed_array':
+              var shortName = "".concat(data.constructor.name, "(").concat(data.length, ")");
+              if (showFormattedValue) {
+                var _formatted = '';
+                for (var _i = 0; _i < data.length; _i++) {
+                  if (_i > 0) {
+                    _formatted += ', ';
+                  }
+                  _formatted += data[_i];
+                  if (_formatted.length > MAX_PREVIEW_STRING_LENGTH) {
+                    // Prevent doing a lot of unnecessary iteration...
+                    break;
+                  }
+                }
+                return "".concat(shortName, " [").concat(truncateForDisplay(_formatted), "]");
+              } else {
+                return shortName;
+              }
+            case 'iterator':
+              var name = data.constructor.name;
+              if (showFormattedValue) {
+                // TRICKY
+                // Don't use [...spread] syntax for this purpose.
+                // This project uses @babel/plugin-transform-spread in "loose" mode which only works with Array values.
+                // Other types (e.g. typed arrays, Sets) will not spread correctly.
+                var array = Array.from(data);
+                var _formatted2 = '';
+                for (var _i2 = 0; _i2 < array.length; _i2++) {
+                  var entryOrEntries = array[_i2];
+                  if (_i2 > 0) {
+                    _formatted2 += ', ';
+                  } // TRICKY
+                  // Browsers display Maps and Sets differently.
+                  // To mimic their behavior, detect if we've been given an entries tuple.
+                  //   Map(2) {"abc" => 123, "def" => 123}
+                  //   Set(2) {"abc", 123}
+
+                  if (src_isArray(entryOrEntries)) {
+                    var key = formatDataForPreview(entryOrEntries[0], true);
+                    var value = formatDataForPreview(entryOrEntries[1], false);
+                    _formatted2 += "".concat(key, " => ").concat(value);
+                  } else {
+                    _formatted2 += formatDataForPreview(entryOrEntries, false);
+                  }
+                  if (_formatted2.length > MAX_PREVIEW_STRING_LENGTH) {
+                    // Prevent doing a lot of unnecessary iteration...
+                    break;
+                  }
+                }
+                return "".concat(name, "(").concat(data.size, ") {").concat(truncateForDisplay(_formatted2), "}");
+              } else {
+                return "".concat(name, "(").concat(data.size, ")");
+              }
+            case 'opaque_iterator':
+              {
+                return data[Symbol.toStringTag];
+              }
+            case 'date':
+              return data.toString();
+            case 'class_instance':
+              try {
+                var resolvedConstructorName = data.constructor.name;
+                if (typeof resolvedConstructorName === 'string') {
+                  return resolvedConstructorName;
+                }
+                resolvedConstructorName = Object.getPrototypeOf(data).constructor.name;
+                if (typeof resolvedConstructorName === 'string') {
+                  return resolvedConstructorName;
+                }
+                try {
+                  return truncateForDisplay(String(data));
+                } catch (error) {
+                  return 'unserializable';
+                }
+              } catch (error) {
+                return 'unserializable';
+              }
+            case 'thenable':
+              var displayName;
+              if (isPlainObject(data)) {
+                displayName = 'Thenable';
+              } else {
+                var _resolvedConstructorName = data.constructor.name;
+                if (typeof _resolvedConstructorName !== 'string') {
+                  _resolvedConstructorName = Object.getPrototypeOf(data).constructor.name;
+                }
+                if (typeof _resolvedConstructorName === 'string') {
+                  displayName = _resolvedConstructorName;
+                } else {
+                  displayName = 'Thenable';
+                }
+              }
+              switch (data.status) {
+                case 'pending':
+                  return "pending ".concat(displayName);
+                case 'fulfilled':
+                  if (showFormattedValue) {
+                    var _formatted3 = formatDataForPreview(data.value, false);
+                    return "fulfilled ".concat(displayName, " {").concat(truncateForDisplay(_formatted3), "}");
+                  } else {
+                    return "fulfilled ".concat(displayName, " {\u2026}");
+                  }
+                case 'rejected':
+                  if (showFormattedValue) {
+                    var _formatted4 = formatDataForPreview(data.reason, false);
+                    return "rejected ".concat(displayName, " {").concat(truncateForDisplay(_formatted4), "}");
+                  } else {
+                    return "rejected ".concat(displayName, " {\u2026}");
+                  }
+                default:
+                  return displayName;
+              }
+            case 'object':
+              if (showFormattedValue) {
+                var keys = Array.from(getAllEnumerableKeys(data)).sort(alphaSortKeys);
+                var _formatted5 = '';
+                for (var _i3 = 0; _i3 < keys.length; _i3++) {
+                  var _key = keys[_i3];
+                  if (_i3 > 0) {
+                    _formatted5 += ', ';
+                  }
+                  _formatted5 += "".concat(_key.toString(), ": ").concat(formatDataForPreview(data[_key], false));
+                  if (_formatted5.length > MAX_PREVIEW_STRING_LENGTH) {
+                    // Prevent doing a lot of unnecessary iteration...
+                    break;
+                  }
+                }
+                return "{".concat(truncateForDisplay(_formatted5), "}");
+              } else {
+                return '{…}';
+              }
+            case 'error':
+              return truncateForDisplay(String(data));
+            case 'boolean':
+            case 'number':
+            case 'infinity':
+            case 'nan':
+            case 'null':
+            case 'undefined':
+              return String(data);
+            default:
+              try {
+                return truncateForDisplay(String(data));
+              } catch (error) {
+                return 'unserializable';
+              }
+          }
+        } // Basically checking that the object only has Object in its prototype chain
+
+        var isPlainObject = function isPlainObject(object) {
+          var objectPrototype = Object.getPrototypeOf(object);
+          if (!objectPrototype) return true;
+          var objectParentPrototype = Object.getPrototypeOf(objectPrototype);
+          return !objectParentPrototype;
+        };
+        function backendToFrontendSerializedElementMapper(element) {
+          var _parseElementDisplayN2 = parseElementDisplayNameFromBackend(element.displayName, element.type),
+            formattedDisplayName = _parseElementDisplayN2.formattedDisplayName,
+            hocDisplayNames = _parseElementDisplayN2.hocDisplayNames,
+            compiledWithForget = _parseElementDisplayN2.compiledWithForget;
+          return _objectSpread(_objectSpread({}, element), {}, {
+            displayName: formattedDisplayName,
+            hocDisplayNames: hocDisplayNames,
+            compiledWithForget: compiledWithForget
+          });
+        }
+        /**
+         * Should be used when treating url as a Chrome Resource URL.
+         */
+
+        function normalizeUrlIfValid(url) {
+          try {
+            // TODO: Chrome will use the basepath to create a Resource URL.
+            return new URL(url).toString();
+          } catch (_unused) {
+            // Giving up if it's not a valid URL without basepath
+            return url;
+          }
+        }
+        function getIsReloadAndProfileSupported() {
+          // Notify the frontend if the backend supports the Storage API (e.g. localStorage).
+          // If not, features like reload-and-profile will not work correctly and must be disabled.
+          var isBackendStorageAPISupported = false;
+          try {
+            localStorage.getItem('test');
+            isBackendStorageAPISupported = true;
+          } catch (error) {}
+          return isBackendStorageAPISupported && isSynchronousXHRSupported();
+        } // Expected to be used only by browser extension and react-devtools-inline
+
+        function getIfReloadedAndProfiling() {
+          return sessionStorageGetItem(SESSION_STORAGE_RELOAD_AND_PROFILE_KEY) === 'true';
+        }
+        function getProfilingSettings() {
+          return {
+            recordChangeDescriptions: sessionStorageGetItem(SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY) === 'true',
+            recordTimeline: sessionStorageGetItem(SESSION_STORAGE_RECORD_TIMELINE_KEY) === 'true'
+          };
+        }
+        function onReloadAndProfile(recordChangeDescriptions, recordTimeline) {
+          sessionStorageSetItem(SESSION_STORAGE_RELOAD_AND_PROFILE_KEY, 'true');
+          sessionStorageSetItem(SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY, recordChangeDescriptions ? 'true' : 'false');
+          sessionStorageSetItem(SESSION_STORAGE_RECORD_TIMELINE_KEY, recordTimeline ? 'true' : 'false');
+        }
+        function onReloadAndProfileFlagsReset() {
+          sessionStorageRemoveItem(SESSION_STORAGE_RELOAD_AND_PROFILE_KEY);
+          sessionStorageRemoveItem(SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY);
+          sessionStorageRemoveItem(SESSION_STORAGE_RECORD_TIMELINE_KEY);
+        }
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/hydration.js
+        function hydration_ownKeys(object, enumerableOnly) {
+          var keys = Object.keys(object);
+          if (Object.getOwnPropertySymbols) {
+            var symbols = Object.getOwnPropertySymbols(object);
+            if (enumerableOnly) symbols = symbols.filter(function (sym) {
+              return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+            keys.push.apply(keys, symbols);
+          }
+          return keys;
+        }
+        function hydration_objectSpread(target) {
+          for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i] != null ? arguments[i] : {};
+            if (i % 2) {
+              hydration_ownKeys(Object(source), true).forEach(function (key) {
+                hydration_defineProperty(target, key, source[key]);
+              });
+            } else if (Object.getOwnPropertyDescriptors) {
+              Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+            } else {
+              hydration_ownKeys(Object(source)).forEach(function (key) {
+                Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+              });
+            }
+          }
+          return target;
+        }
+        function hydration_defineProperty(obj, key, value) {
+          if (key in obj) {
+            Object.defineProperty(obj, key, {
+              value: value,
+              enumerable: true,
+              configurable: true,
+              writable: true
+            });
+          } else {
+            obj[key] = value;
+          }
+          return obj;
+        }
+        function hydration_typeof(obj) {
+          "@babel/helpers - typeof";
+
+          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+            hydration_typeof = function _typeof(obj) {
+              return typeof obj;
+            };
+          } else {
+            hydration_typeof = function _typeof(obj) {
+              return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+            };
+          }
+          return hydration_typeof(obj);
+        }
+
+        /**
+         * 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.
+         *
+         * 
+         */
+
+        var meta = {
+          inspectable: Symbol('inspectable'),
+          inspected: Symbol('inspected'),
+          name: Symbol('name'),
+          preview_long: Symbol('preview_long'),
+          preview_short: Symbol('preview_short'),
+          readonly: Symbol('readonly'),
+          size: Symbol('size'),
+          type: Symbol('type'),
+          unserializable: Symbol('unserializable')
+        }; // Typed arrays, other complex iteratable objects (e.g. Map, Set, ImmutableJS) or Promises need special handling.
+        // These objects can't be serialized without losing type information,
+        // so a "Unserializable" type wrapper is used (with meta-data keys) to send nested values-
+        // while preserving the original type and name.
+
+        // This threshold determines the depth at which the bridge "dehydrates" nested data.
+        // Dehydration means that we don't serialize the data for e.g. postMessage or stringify,
+        // unless the frontend explicitly requests it (e.g. a user clicks to expand a props object).
+        //
+        // Reducing this threshold will improve the speed of initial component inspection,
+        // but may decrease the responsiveness of expanding objects/arrays to inspect further.
+        var LEVEL_THRESHOLD = 2;
+        /**
+         * Generate the dehydrated metadata for complex object instances
+         */
+
+        function createDehydrated(type, inspectable, data, cleaned, path) {
+          cleaned.push(path);
+          var dehydrated = {
+            inspectable: inspectable,
+            type: type,
+            preview_long: formatDataForPreview(data, true),
+            preview_short: formatDataForPreview(data, false),
+            name: typeof data.constructor !== 'function' || typeof data.constructor.name !== 'string' || data.constructor.name === 'Object' ? '' : data.constructor.name
+          };
+          if (type === 'array' || type === 'typed_array') {
+            dehydrated.size = data.length;
+          } else if (type === 'object') {
+            dehydrated.size = Object.keys(data).length;
+          }
+          if (type === 'iterator' || type === 'typed_array') {
+            dehydrated.readonly = true;
+          }
+          return dehydrated;
+        }
+        /**
+         * Strip out complex data (instances, functions, and data nested > LEVEL_THRESHOLD levels deep).
+         * The paths of the stripped out objects are appended to the `cleaned` list.
+         * On the other side of the barrier, the cleaned list is used to "re-hydrate" the cleaned representation into
+         * an object with symbols as attributes, so that a sanitized object can be distinguished from a normal object.
+         *
+         * Input: {"some": {"attr": fn()}, "other": AnInstance}
+         * Output: {
+         *   "some": {
+         *     "attr": {"name": the fn.name, type: "function"}
+         *   },
+         *   "other": {
+         *     "name": "AnInstance",
+         *     "type": "object",
+         *   },
+         * }
+         * and cleaned = [["some", "attr"], ["other"]]
+         */
+
+        function dehydrate(data, cleaned, unserializable, path, isPathAllowed) {
+          var level = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
+          var type = getDataType(data);
+          var isPathAllowedCheck;
+          switch (type) {
+            case 'html_element':
+              cleaned.push(path);
+              return {
+                inspectable: false,
+                preview_short: formatDataForPreview(data, false),
+                preview_long: formatDataForPreview(data, true),
+                name: data.tagName,
+                type: type
+              };
+            case 'function':
+              cleaned.push(path);
+              return {
+                inspectable: false,
+                preview_short: formatDataForPreview(data, false),
+                preview_long: formatDataForPreview(data, true),
+                name: typeof data.name === 'function' || !data.name ? 'function' : data.name,
+                type: type
+              };
+            case 'string':
+              isPathAllowedCheck = isPathAllowed(path);
+              if (isPathAllowedCheck) {
+                return data;
+              } else {
+                return data.length <= 500 ? data : data.slice(0, 500) + '...';
+              }
+            case 'bigint':
+              cleaned.push(path);
+              return {
+                inspectable: false,
+                preview_short: formatDataForPreview(data, false),
+                preview_long: formatDataForPreview(data, true),
+                name: data.toString(),
+                type: type
+              };
+            case 'symbol':
+              cleaned.push(path);
+              return {
+                inspectable: false,
+                preview_short: formatDataForPreview(data, false),
+                preview_long: formatDataForPreview(data, true),
+                name: data.toString(),
+                type: type
+              };
+            // React Elements aren't very inspector-friendly,
+            // and often contain private fields or circular references.
+
+            case 'react_element':
+              cleaned.push(path);
+              return {
+                inspectable: false,
+                preview_short: formatDataForPreview(data, false),
+                preview_long: formatDataForPreview(data, true),
+                name: getDisplayNameForReactElement(data) || 'Unknown',
+                type: type
+              };
+            // ArrayBuffers error if you try to inspect them.
+
+            case 'array_buffer':
+            case 'data_view':
+              cleaned.push(path);
+              return {
+                inspectable: false,
+                preview_short: formatDataForPreview(data, false),
+                preview_long: formatDataForPreview(data, true),
+                name: type === 'data_view' ? 'DataView' : 'ArrayBuffer',
+                size: data.byteLength,
+                type: type
+              };
+            case 'array':
+              isPathAllowedCheck = isPathAllowed(path);
+              if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
+                return createDehydrated(type, true, data, cleaned, path);
+              }
+              var arr = [];
+              for (var i = 0; i < data.length; i++) {
+                arr[i] = dehydrateKey(data, i, cleaned, unserializable, path.concat([i]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+              }
+              return arr;
+            case 'html_all_collection':
+            case 'typed_array':
+            case 'iterator':
+              isPathAllowedCheck = isPathAllowed(path);
+              if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
+                return createDehydrated(type, true, data, cleaned, path);
+              } else {
+                var unserializableValue = {
+                  unserializable: true,
+                  type: type,
+                  readonly: true,
+                  size: type === 'typed_array' ? data.length : undefined,
+                  preview_short: formatDataForPreview(data, false),
+                  preview_long: formatDataForPreview(data, true),
+                  name: typeof data.constructor !== 'function' || typeof data.constructor.name !== 'string' || data.constructor.name === 'Object' ? '' : data.constructor.name
+                }; // TRICKY
+                // Don't use [...spread] syntax for this purpose.
+                // This project uses @babel/plugin-transform-spread in "loose" mode which only works with Array values.
+                // Other types (e.g. typed arrays, Sets) will not spread correctly.
+
+                Array.from(data).forEach(function (item, i) {
+                  return unserializableValue[i] = dehydrate(item, cleaned, unserializable, path.concat([i]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                });
+                unserializable.push(path);
+                return unserializableValue;
+              }
+            case 'opaque_iterator':
+              cleaned.push(path);
+              return {
+                inspectable: false,
+                preview_short: formatDataForPreview(data, false),
+                preview_long: formatDataForPreview(data, true),
+                name: data[Symbol.toStringTag],
+                type: type
+              };
+            case 'date':
+              cleaned.push(path);
+              return {
+                inspectable: false,
+                preview_short: formatDataForPreview(data, false),
+                preview_long: formatDataForPreview(data, true),
+                name: data.toString(),
+                type: type
+              };
+            case 'regexp':
+              cleaned.push(path);
+              return {
+                inspectable: false,
+                preview_short: formatDataForPreview(data, false),
+                preview_long: formatDataForPreview(data, true),
+                name: data.toString(),
+                type: type
+              };
+            case 'thenable':
+              isPathAllowedCheck = isPathAllowed(path);
+              if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
+                return {
+                  inspectable: data.status === 'fulfilled' || data.status === 'rejected',
+                  preview_short: formatDataForPreview(data, false),
+                  preview_long: formatDataForPreview(data, true),
+                  name: data.toString(),
+                  type: type
+                };
+              }
+              switch (data.status) {
+                case 'fulfilled':
+                  {
+                    var _unserializableValue = {
+                      unserializable: true,
+                      type: type,
+                      preview_short: formatDataForPreview(data, false),
+                      preview_long: formatDataForPreview(data, true),
+                      name: 'fulfilled Thenable'
+                    };
+                    _unserializableValue.value = dehydrate(data.value, cleaned, unserializable, path.concat(['value']), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                    unserializable.push(path);
+                    return _unserializableValue;
+                  }
+                case 'rejected':
+                  {
+                    var _unserializableValue2 = {
+                      unserializable: true,
+                      type: type,
+                      preview_short: formatDataForPreview(data, false),
+                      preview_long: formatDataForPreview(data, true),
+                      name: 'rejected Thenable'
+                    };
+                    _unserializableValue2.reason = dehydrate(data.reason, cleaned, unserializable, path.concat(['reason']), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                    unserializable.push(path);
+                    return _unserializableValue2;
+                  }
+                default:
+                  cleaned.push(path);
+                  return {
+                    inspectable: false,
+                    preview_short: formatDataForPreview(data, false),
+                    preview_long: formatDataForPreview(data, true),
+                    name: data.toString(),
+                    type: type
+                  };
+              }
+            case 'object':
+              isPathAllowedCheck = isPathAllowed(path);
+              if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
+                return createDehydrated(type, true, data, cleaned, path);
+              } else {
+                var object = {};
+                getAllEnumerableKeys(data).forEach(function (key) {
+                  var name = key.toString();
+                  object[name] = dehydrateKey(data, key, cleaned, unserializable, path.concat([name]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                });
+                return object;
+              }
+            case 'class_instance':
+              {
+                isPathAllowedCheck = isPathAllowed(path);
+                if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
+                  return createDehydrated(type, true, data, cleaned, path);
+                }
+                var value = {
+                  unserializable: true,
+                  type: type,
+                  readonly: true,
+                  preview_short: formatDataForPreview(data, false),
+                  preview_long: formatDataForPreview(data, true),
+                  name: typeof data.constructor !== 'function' || typeof data.constructor.name !== 'string' ? '' : data.constructor.name
+                };
+                getAllEnumerableKeys(data).forEach(function (key) {
+                  var keyAsString = key.toString();
+                  value[keyAsString] = dehydrate(data[key], cleaned, unserializable, path.concat([keyAsString]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                });
+                unserializable.push(path);
+                return value;
+              }
+            case 'error':
+              {
+                isPathAllowedCheck = isPathAllowed(path);
+                if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
+                  return createDehydrated(type, true, data, cleaned, path);
+                }
+                var _value = {
+                  unserializable: true,
+                  type: type,
+                  readonly: true,
+                  preview_short: formatDataForPreview(data, false),
+                  preview_long: formatDataForPreview(data, true),
+                  name: data.name
+                }; // name, message, stack and cause are not enumerable yet still interesting.
+
+                _value.message = dehydrate(data.message, cleaned, unserializable, path.concat(['message']), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                _value.stack = dehydrate(data.stack, cleaned, unserializable, path.concat(['stack']), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                if ('cause' in data) {
+                  _value.cause = dehydrate(data.cause, cleaned, unserializable, path.concat(['cause']), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                }
+                getAllEnumerableKeys(data).forEach(function (key) {
+                  var keyAsString = key.toString();
+                  _value[keyAsString] = dehydrate(data[key], cleaned, unserializable, path.concat([keyAsString]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+                });
+                unserializable.push(path);
+                return _value;
+              }
+            case 'infinity':
+            case 'nan':
+            case 'undefined':
+              // Some values are lossy when sent through a WebSocket.
+              // We dehydrate+rehydrate them to preserve their type.
+              cleaned.push(path);
+              return {
+                type: type
+              };
+            default:
+              return data;
+          }
+        }
+        function dehydrateKey(parent, key, cleaned, unserializable, path, isPathAllowed) {
+          var level = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : 0;
+          try {
+            return dehydrate(parent[key], cleaned, unserializable, path, isPathAllowed, level);
+          } catch (error) {
+            var preview = '';
+            if (hydration_typeof(error) === 'object' && error !== null && typeof error.stack === 'string') {
+              preview = error.stack;
+            } else if (typeof error === 'string') {
+              preview = error;
+            }
+            cleaned.push(path);
+            return {
+              inspectable: false,
+              preview_short: '[Exception]',
+              preview_long: preview ? '[Exception: ' + preview + ']' : '[Exception]',
+              name: preview,
+              type: 'unknown'
+            };
+          }
+        }
+        function fillInPath(object, data, path, value) {
+          var target = getInObject(object, path);
+          if (target != null) {
+            if (!target[meta.unserializable]) {
+              delete target[meta.inspectable];
+              delete target[meta.inspected];
+              delete target[meta.name];
+              delete target[meta.preview_long];
+              delete target[meta.preview_short];
+              delete target[meta.readonly];
+              delete target[meta.size];
+              delete target[meta.type];
+            }
+          }
+          if (value !== null && data.unserializable.length > 0) {
+            var unserializablePath = data.unserializable[0];
+            var isMatch = unserializablePath.length === path.length;
+            for (var i = 0; i < path.length; i++) {
+              if (path[i] !== unserializablePath[i]) {
+                isMatch = false;
+                break;
+              }
+            }
+            if (isMatch) {
+              upgradeUnserializable(value, value);
+            }
+          }
+          setInObject(object, path, value);
+        }
+        function hydrate(object, cleaned, unserializable) {
+          cleaned.forEach(function (path) {
+            var length = path.length;
+            var last = path[length - 1];
+            var parent = getInObject(object, path.slice(0, length - 1));
+            if (!parent || !parent.hasOwnProperty(last)) {
+              return;
+            }
+            var value = parent[last];
+            if (!value) {
+              return;
+            } else if (value.type === 'infinity') {
+              parent[last] = Infinity;
+            } else if (value.type === 'nan') {
+              parent[last] = NaN;
+            } else if (value.type === 'undefined') {
+              parent[last] = undefined;
+            } else {
+              // Replace the string keys with Symbols so they're non-enumerable.
+              var replaced = {};
+              replaced[meta.inspectable] = !!value.inspectable;
+              replaced[meta.inspected] = false;
+              replaced[meta.name] = value.name;
+              replaced[meta.preview_long] = value.preview_long;
+              replaced[meta.preview_short] = value.preview_short;
+              replaced[meta.size] = value.size;
+              replaced[meta.readonly] = !!value.readonly;
+              replaced[meta.type] = value.type;
+              parent[last] = replaced;
+            }
+          });
+          unserializable.forEach(function (path) {
+            var length = path.length;
+            var last = path[length - 1];
+            var parent = getInObject(object, path.slice(0, length - 1));
+            if (!parent || !parent.hasOwnProperty(last)) {
+              return;
+            }
+            var node = parent[last];
+            var replacement = hydration_objectSpread({}, node);
+            upgradeUnserializable(replacement, node);
+            parent[last] = replacement;
+          });
+          return object;
+        }
+        function upgradeUnserializable(destination, source) {
+          var _Object$definePropert;
+          Object.defineProperties(destination, (_Object$definePropert = {}, hydration_defineProperty(_Object$definePropert, meta.inspected, {
+            configurable: true,
+            enumerable: false,
+            value: !!source.inspected
+          }), hydration_defineProperty(_Object$definePropert, meta.name, {
+            configurable: true,
+            enumerable: false,
+            value: source.name
+          }), hydration_defineProperty(_Object$definePropert, meta.preview_long, {
+            configurable: true,
+            enumerable: false,
+            value: source.preview_long
+          }), hydration_defineProperty(_Object$definePropert, meta.preview_short, {
+            configurable: true,
+            enumerable: false,
+            value: source.preview_short
+          }), hydration_defineProperty(_Object$definePropert, meta.size, {
+            configurable: true,
+            enumerable: false,
+            value: source.size
+          }), hydration_defineProperty(_Object$definePropert, meta.readonly, {
+            configurable: true,
+            enumerable: false,
+            value: !!source.readonly
+          }), hydration_defineProperty(_Object$definePropert, meta.type, {
+            configurable: true,
+            enumerable: false,
+            value: source.type
+          }), hydration_defineProperty(_Object$definePropert, meta.unserializable, {
+            configurable: true,
+            enumerable: false,
+            value: !!source.unserializable
+          }), _Object$definePropert));
+          delete destination.inspected;
+          delete destination.name;
+          delete destination.preview_long;
+          delete destination.preview_short;
+          delete destination.size;
+          delete destination.readonly;
+          delete destination.type;
+          delete destination.unserializable;
+        }
+        ; // CONCATENATED MODULE: ../shared/isArray.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.
+         *
+         * 
+         */
+        var isArrayImpl = Array.isArray;
+        function isArray_isArray(a) {
+          return isArrayImpl(a);
+        }
+
+        /* harmony default export */
+        var shared_isArray = isArray_isArray;
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/shared/DevToolsOwnerStack.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.
+         *
+         * 
+         */
+        // This is a DevTools fork of shared/ReactOwnerStackFrames.
+        function formatOwnerStack(error) {
+          var prevPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
+
+          Error.prepareStackTrace = undefined;
+          var stack = error.stack;
+          Error.prepareStackTrace = prevPrepareStackTrace;
+          return formatOwnerStackString(stack);
+        }
+        function formatOwnerStackString(stack) {
+          if (stack.startsWith('Error: react-stack-top-frame\n')) {
+            // V8's default formatting prefixes with the error message which we
+            // don't want/need.
+            stack = stack.slice(29);
+          }
+          var idx = stack.indexOf('\n');
+          if (idx !== -1) {
+            // Pop the JSX frame.
+            stack = stack.slice(idx + 1);
+          }
+          idx = stack.indexOf('react_stack_bottom_frame');
+          if (idx === -1) {
+            idx = stack.indexOf('react-stack-bottom-frame');
+          }
+          if (idx !== -1) {
+            idx = stack.lastIndexOf('\n', idx);
+          }
+          if (idx !== -1) {
+            // Cut off everything after the bottom frame since it'll be internals.
+            stack = stack.slice(0, idx);
+          } else {
+            // We didn't find any internal callsite out to user space.
+            // This means that this was called outside an owner or the owner is fully internal.
+            // To keep things light we exclude the entire trace in this case.
+            return '';
+          }
+          return stack;
+        }
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/utils/index.js
+        function _createForOfIteratorHelper(o, allowArrayLike) {
+          var it;
+          if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
+            if (Array.isArray(o) || (it = backend_utils_unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+              if (it) o = it;
+              var i = 0;
+              var F = function F() {};
+              return {
+                s: F,
+                n: function n() {
+                  if (i >= o.length) return {
+                    done: true
+                  };
+                  return {
+                    done: false,
+                    value: o[i++]
+                  };
+                },
+                e: function e(_e2) {
+                  throw _e2;
+                },
+                f: F
+              };
+            }
+            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 normalCompletion = true,
+            didErr = false,
+            err;
+          return {
+            s: function s() {
+              it = o[Symbol.iterator]();
+            },
+            n: function n() {
+              var step = it.next();
+              normalCompletion = step.done;
+              return step;
+            },
+            e: function e(_e3) {
+              didErr = true;
+              err = _e3;
+            },
+            f: function f() {
+              try {
+                if (!normalCompletion && it.return != null) it.return();
+              } finally {
+                if (didErr) throw err;
+              }
+            }
+          };
+        }
+        function utils_slicedToArray(arr, i) {
+          return utils_arrayWithHoles(arr) || utils_iterableToArrayLimit(arr, i) || backend_utils_unsupportedIterableToArray(arr, i) || utils_nonIterableRest();
+        }
+        function utils_nonIterableRest() {
+          throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+        }
+        function backend_utils_unsupportedIterableToArray(o, minLen) {
+          if (!o) return;
+          if (typeof o === "string") return backend_utils_arrayLikeToArray(o, minLen);
+          var n = Object.prototype.toString.call(o).slice(8, -1);
+          if (n === "Object" && o.constructor) n = o.constructor.name;
+          if (n === "Map" || n === "Set") return Array.from(o);
+          if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return backend_utils_arrayLikeToArray(o, minLen);
+        }
+        function backend_utils_arrayLikeToArray(arr, len) {
+          if (len == null || len > arr.length) len = arr.length;
+          for (var i = 0, arr2 = new Array(len); i < len; i++) {
+            arr2[i] = arr[i];
+          }
+          return arr2;
+        }
+        function utils_iterableToArrayLimit(arr, i) {
+          if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
+          var _arr = [];
+          var _n = true;
+          var _d = false;
+          var _e = undefined;
+          try {
+            for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+              _arr.push(_s.value);
+              if (i && _arr.length === i) break;
+            }
+          } catch (err) {
+            _d = true;
+            _e = err;
+          } finally {
+            try {
+              if (!_n && _i["return"] != null) _i["return"]();
+            } finally {
+              if (_d) throw _e;
+            }
+          }
+          return _arr;
+        }
+        function utils_arrayWithHoles(arr) {
+          if (Array.isArray(arr)) return arr;
+        }
+        function backend_utils_typeof(obj) {
+          "@babel/helpers - typeof";
+
+          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+            backend_utils_typeof = function _typeof(obj) {
+              return typeof obj;
+            };
+          } else {
+            backend_utils_typeof = function _typeof(obj) {
+              return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+            };
+          }
+          return backend_utils_typeof(obj);
+        }
+        function utils_ownKeys(object, enumerableOnly) {
+          var keys = Object.keys(object);
+          if (Object.getOwnPropertySymbols) {
+            var symbols = Object.getOwnPropertySymbols(object);
+            if (enumerableOnly) symbols = symbols.filter(function (sym) {
+              return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+            keys.push.apply(keys, symbols);
+          }
+          return keys;
+        }
+        function utils_objectSpread(target) {
+          for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i] != null ? arguments[i] : {};
+            if (i % 2) {
+              utils_ownKeys(Object(source), true).forEach(function (key) {
+                backend_utils_defineProperty(target, key, source[key]);
+              });
+            } else if (Object.getOwnPropertyDescriptors) {
+              Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+            } else {
+              utils_ownKeys(Object(source)).forEach(function (key) {
+                Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+              });
+            }
+          }
+          return target;
+        }
+        function backend_utils_defineProperty(obj, key, value) {
+          if (key in obj) {
+            Object.defineProperty(obj, key, {
+              value: value,
+              enumerable: true,
+              configurable: true,
+              writable: true
+            });
+          } else {
+            obj[key] = value;
+          }
+          return obj;
+        }
+
+        /**
+        /**
+         * 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.
+         *
+         * 
+         */
+
+        // TODO: update this to the first React version that has a corresponding DevTools backend
+
+        var FIRST_DEVTOOLS_BACKEND_LOCKSTEP_VER = '999.9.9';
+        function hasAssignedBackend(version) {
+          if (version == null || version === '') {
+            return false;
+          }
+          return gte(version, FIRST_DEVTOOLS_BACKEND_LOCKSTEP_VER);
+        }
+        function cleanForBridge(data, isPathAllowed) {
+          var path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+          if (data !== null) {
+            var cleanedPaths = [];
+            var unserializablePaths = [];
+            var cleanedData = dehydrate(data, cleanedPaths, unserializablePaths, path, isPathAllowed);
+            return {
+              data: cleanedData,
+              cleaned: cleanedPaths,
+              unserializable: unserializablePaths
+            };
+          } else {
+            return null;
+          }
+        }
+        function copyWithDelete(obj, path) {
+          var index = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+          var key = path[index];
+          var updated = shared_isArray(obj) ? obj.slice() : utils_objectSpread({}, obj);
+          if (index + 1 === path.length) {
+            if (shared_isArray(updated)) {
+              updated.splice(key, 1);
+            } else {
+              delete updated[key];
+            }
+          } else {
+            // $FlowFixMe[incompatible-use] number or string is fine here
+            updated[key] = copyWithDelete(obj[key], path, index + 1);
+          }
+          return updated;
+        } // This function expects paths to be the same except for the final value.
+        // e.g. ['path', 'to', 'foo'] and ['path', 'to', 'bar']
+
+        function copyWithRename(obj, oldPath, newPath) {
+          var index = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+          var oldKey = oldPath[index];
+          var updated = shared_isArray(obj) ? obj.slice() : utils_objectSpread({}, obj);
+          if (index + 1 === oldPath.length) {
+            var newKey = newPath[index]; // $FlowFixMe[incompatible-use] number or string is fine here
+
+            updated[newKey] = updated[oldKey];
+            if (shared_isArray(updated)) {
+              updated.splice(oldKey, 1);
+            } else {
+              delete updated[oldKey];
+            }
+          } else {
+            // $FlowFixMe[incompatible-use] number or string is fine here
+            updated[oldKey] = copyWithRename(obj[oldKey], oldPath, newPath, index + 1);
+          }
+          return updated;
+        }
+        function copyWithSet(obj, path, value) {
+          var index = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+          if (index >= path.length) {
+            return value;
+          }
+          var key = path[index];
+          var updated = shared_isArray(obj) ? obj.slice() : utils_objectSpread({}, obj); // $FlowFixMe[incompatible-use] number or string is fine here
+
+          updated[key] = copyWithSet(obj[key], path, value, index + 1);
+          return updated;
+        }
+        function getEffectDurations(root) {
+          // Profiling durations are only available for certain builds.
+          // If available, they'll be stored on the HostRoot.
+          var effectDuration = null;
+          var passiveEffectDuration = null;
+          var hostRoot = root.current;
+          if (hostRoot != null) {
+            var stateNode = hostRoot.stateNode;
+            if (stateNode != null) {
+              effectDuration = stateNode.effectDuration != null ? stateNode.effectDuration : null;
+              passiveEffectDuration = stateNode.passiveEffectDuration != null ? stateNode.passiveEffectDuration : null;
+            }
+          }
+          return {
+            effectDuration: effectDuration,
+            passiveEffectDuration: passiveEffectDuration
+          };
+        }
+        function serializeToString(data) {
+          if (data === undefined) {
+            return 'undefined';
+          }
+          if (typeof data === 'function') {
+            return data.toString();
+          }
+          var cache = new Set(); // Use a custom replacer function to protect against circular references.
+
+          return JSON.stringify(data, function (key, value) {
+            if (backend_utils_typeof(value) === 'object' && value !== null) {
+              if (cache.has(value)) {
+                return;
+              }
+              cache.add(value);
+            }
+            if (typeof value === 'bigint') {
+              return value.toString() + 'n';
+            }
+            return value;
+          }, 2);
+        }
+        function safeToString(val) {
+          try {
+            return String(val);
+          } catch (err) {
+            if (backend_utils_typeof(val) === 'object') {
+              // An object with no prototype and no `[Symbol.toPrimitive]()`, `toString()`, and `valueOf()` methods would throw.
+              // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#string_coercion
+              return '[object Object]';
+            }
+            throw err;
+          }
+        } // based on https://github.com/tmpfs/format-util/blob/0e62d430efb0a1c51448709abd3e2406c14d8401/format.js#L1
+        // based on https://developer.mozilla.org/en-US/docs/Web/API/console#Using_string_substitutions
+        // Implements s, d, i and f placeholders
+
+        function formatConsoleArgumentsToSingleString(maybeMessage) {
+          for (var _len = arguments.length, inputArgs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+            inputArgs[_key - 1] = arguments[_key];
+          }
+          var args = inputArgs.slice();
+          var formatted = safeToString(maybeMessage); // If the first argument is a string, check for substitutions.
+
+          if (typeof maybeMessage === 'string') {
+            if (args.length) {
+              var REGEXP = /(%?)(%([jds]))/g; // $FlowFixMe[incompatible-call]
+
+              formatted = formatted.replace(REGEXP, function (match, escaped, ptn, flag) {
+                var arg = args.shift();
+                switch (flag) {
+                  case 's':
+                    // $FlowFixMe[unsafe-addition]
+                    arg += '';
+                    break;
+                  case 'd':
+                  case 'i':
+                    arg = parseInt(arg, 10).toString();
+                    break;
+                  case 'f':
+                    arg = parseFloat(arg).toString();
+                    break;
+                }
+                if (!escaped) {
+                  return arg;
+                }
+                args.unshift(arg);
+                return match;
+              });
+            }
+          } // Arguments that remain after formatting.
+
+          if (args.length) {
+            for (var i = 0; i < args.length; i++) {
+              formatted += ' ' + safeToString(args[i]);
+            }
+          } // Update escaped %% values.
+
+          formatted = formatted.replace(/%{2,2}/g, '%');
+          return String(formatted);
+        }
+        function isSynchronousXHRSupported() {
+          return !!(window.document && window.document.featurePolicy && window.document.featurePolicy.allowsFeature('sync-xhr'));
+        }
+        function gt() {
+          var a = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+          var b = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+          return compareVersions(a, b) === 1;
+        }
+        function gte() {
+          var a = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+          var b = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+          return compareVersions(a, b) > -1;
+        }
+        var isReactNativeEnvironment = function isReactNativeEnvironment() {
+          // We've been relying on this for such a long time
+          // We should probably define the client for DevTools on the backend side and share it with the frontend
+          return window.document == null;
+        };
+        function extractLocation(url) {
+          if (url.indexOf(':') === -1) {
+            return null;
+          } // remove any parentheses from start and end
+
+          var withoutParentheses = url.replace(/^\(+/, '').replace(/\)+$/, '');
+          var locationParts = /(at )?(.+?)(?::(\d+))?(?::(\d+))?$/.exec(withoutParentheses);
+          if (locationParts == null) {
+            return null;
+          }
+          var _locationParts = utils_slicedToArray(locationParts, 5),
+            sourceURL = _locationParts[2],
+            line = _locationParts[3],
+            column = _locationParts[4];
+          return {
+            sourceURL: sourceURL,
+            line: line,
+            column: column
+          };
+        }
+        var CHROME_STACK_REGEXP = /^\s*at .*(\S+:\d+|\(native\))/m;
+        function parseSourceFromChromeStack(stack) {
+          var frames = stack.split('\n'); // eslint-disable-next-line no-for-of-loops/no-for-of-loops
+
+          var _iterator = _createForOfIteratorHelper(frames),
+            _step;
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var frame = _step.value;
+              var sanitizedFrame = frame.trim();
+              var locationInParenthesesMatch = sanitizedFrame.match(/ (\(.+\)$)/);
+              var possibleLocation = locationInParenthesesMatch ? locationInParenthesesMatch[1] : sanitizedFrame;
+              var location = extractLocation(possibleLocation); // Continue the search until at least sourceURL is found
+
+              if (location == null) {
+                continue;
+              }
+              var sourceURL = location.sourceURL,
+                _location$line = location.line,
+                line = _location$line === void 0 ? '1' : _location$line,
+                _location$column = location.column,
+                column = _location$column === void 0 ? '1' : _location$column;
+              return {
+                sourceURL: sourceURL,
+                line: parseInt(line, 10),
+                column: parseInt(column, 10)
+              };
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+          return null;
+        }
+        function parseSourceFromFirefoxStack(stack) {
+          var frames = stack.split('\n'); // eslint-disable-next-line no-for-of-loops/no-for-of-loops
+
+          var _iterator2 = _createForOfIteratorHelper(frames),
+            _step2;
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var frame = _step2.value;
+              var sanitizedFrame = frame.trim();
+              var frameWithoutFunctionName = sanitizedFrame.replace(/((.*".+"[^@]*)?[^@]*)(?:@)/, '');
+              var location = extractLocation(frameWithoutFunctionName); // Continue the search until at least sourceURL is found
+
+              if (location == null) {
+                continue;
+              }
+              var sourceURL = location.sourceURL,
+                _location$line2 = location.line,
+                line = _location$line2 === void 0 ? '1' : _location$line2,
+                _location$column2 = location.column,
+                column = _location$column2 === void 0 ? '1' : _location$column2;
+              return {
+                sourceURL: sourceURL,
+                line: parseInt(line, 10),
+                column: parseInt(column, 10)
+              };
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+          return null;
+        }
+        function parseSourceFromComponentStack(componentStack) {
+          if (componentStack.match(CHROME_STACK_REGEXP)) {
+            return parseSourceFromChromeStack(componentStack);
+          }
+          return parseSourceFromFirefoxStack(componentStack);
+        }
+        var collectedLocation = null;
+        function collectStackTrace(error, structuredStackTrace) {
+          var result = null; // Collect structured stack traces from the callsites.
+          // We mirror how V8 serializes stack frames and how we later parse them.
+
+          for (var i = 0; i < structuredStackTrace.length; i++) {
+            var callSite = structuredStackTrace[i];
+            var _name = callSite.getFunctionName();
+            if (_name != null && (_name.includes('react_stack_bottom_frame') || _name.includes('react-stack-bottom-frame'))) {
+              // We pick the last frame that matches before the bottom frame since
+              // that will be immediately inside the component as opposed to some helper.
+              // If we don't find a bottom frame then we bail to string parsing.
+              collectedLocation = result; // Skip everything after the bottom frame since it'll be internals.
+
+              break;
+            } else {
+              var sourceURL = callSite.getScriptNameOrSourceURL();
+              var line =
+              // $FlowFixMe[prop-missing]
+              typeof callSite.getEnclosingLineNumber === 'function' ? callSite.getEnclosingLineNumber() : callSite.getLineNumber();
+              var col =
+              // $FlowFixMe[prop-missing]
+              typeof callSite.getEnclosingColumnNumber === 'function' ? callSite.getEnclosingColumnNumber() : callSite.getColumnNumber();
+              if (!sourceURL || !line || !col) {
+                // Skip eval etc. without source url. They don't have location.
+                continue;
+              }
+              result = {
+                sourceURL: sourceURL,
+                line: line,
+                column: col
+              };
+            }
+          } // At the same time we generate a string stack trace just in case someone
+          // else reads it.
+
+          var name = error.name || 'Error';
+          var message = error.message || '';
+          var stack = name + ': ' + message;
+          for (var _i2 = 0; _i2 < structuredStackTrace.length; _i2++) {
+            stack += '\n    at ' + structuredStackTrace[_i2].toString();
+          }
+          return stack;
+        }
+        function parseSourceFromOwnerStack(error) {
+          // First attempt to collected the structured data using prepareStackTrace.
+          collectedLocation = null;
+          var previousPrepare = Error.prepareStackTrace;
+          Error.prepareStackTrace = collectStackTrace;
+          var stack;
+          try {
+            stack = error.stack;
+          } catch (e) {
+            // $FlowFixMe[incompatible-type] It does accept undefined.
+            Error.prepareStackTrace = undefined;
+            stack = error.stack;
+          } finally {
+            Error.prepareStackTrace = previousPrepare;
+          }
+          if (collectedLocation !== null) {
+            return collectedLocation;
+          }
+          if (stack == null) {
+            return null;
+          } // Fallback to parsing the string form.
+
+          var componentStack = formatOwnerStackString(stack);
+          return parseSourceFromComponentStack(componentStack);
+        } // 0.123456789 => 0.123
+        // Expects high-resolution timestamp in milliseconds, like from performance.now()
+        // Mainly used for optimizing the size of serialized profiling payload
+
+        function formatDurationToMicrosecondsGranularity(duration) {
+          return Math.round(duration * 1000) / 1000;
+        }
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/views/utils.js
+        function views_utils_slicedToArray(arr, i) {
+          return views_utils_arrayWithHoles(arr) || views_utils_iterableToArrayLimit(arr, i) || views_utils_unsupportedIterableToArray(arr, i) || views_utils_nonIterableRest();
+        }
+        function views_utils_nonIterableRest() {
+          throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+        }
+        function views_utils_unsupportedIterableToArray(o, minLen) {
+          if (!o) return;
+          if (typeof o === "string") return views_utils_arrayLikeToArray(o, minLen);
+          var n = Object.prototype.toString.call(o).slice(8, -1);
+          if (n === "Object" && o.constructor) n = o.constructor.name;
+          if (n === "Map" || n === "Set") return Array.from(o);
+          if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return views_utils_arrayLikeToArray(o, minLen);
+        }
+        function views_utils_arrayLikeToArray(arr, len) {
+          if (len == null || len > arr.length) len = arr.length;
+          for (var i = 0, arr2 = new Array(len); i < len; i++) {
+            arr2[i] = arr[i];
+          }
+          return arr2;
+        }
+        function views_utils_iterableToArrayLimit(arr, i) {
+          if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
+          var _arr = [];
+          var _n = true;
+          var _d = false;
+          var _e = undefined;
+          try {
+            for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+              _arr.push(_s.value);
+              if (i && _arr.length === i) break;
+            }
+          } catch (err) {
+            _d = true;
+            _e = err;
+          } finally {
+            try {
+              if (!_n && _i["return"] != null) _i["return"]();
+            } finally {
+              if (_d) throw _e;
+            }
+          }
+          return _arr;
+        }
+        function views_utils_arrayWithHoles(arr) {
+          if (Array.isArray(arr)) return arr;
+        }
+
+        /**
+         * 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.
+         *
+         * 
+         */
+        // Get the window object for the document that a node belongs to,
+        // or return null if it cannot be found (node not attached to DOM,
+        // etc).
+        function getOwnerWindow(node) {
+          if (!node.ownerDocument) {
+            return null;
+          }
+          return node.ownerDocument.defaultView;
+        } // Get the iframe containing a node, or return null if it cannot
+        // be found (node not within iframe, etc).
+
+        function getOwnerIframe(node) {
+          var nodeWindow = getOwnerWindow(node);
+          if (nodeWindow) {
+            return nodeWindow.frameElement;
+          }
+          return null;
+        } // Get a bounding client rect for a node, with an
+        // offset added to compensate for its border.
+
+        function getBoundingClientRectWithBorderOffset(node) {
+          var dimensions = getElementDimensions(node);
+          return mergeRectOffsets([node.getBoundingClientRect(), {
+            top: dimensions.borderTop,
+            left: dimensions.borderLeft,
+            bottom: dimensions.borderBottom,
+            right: dimensions.borderRight,
+            // This width and height won't get used by mergeRectOffsets (since this
+            // is not the first rect in the array), but we set them so that this
+            // object type checks as a ClientRect.
+            width: 0,
+            height: 0
+          }]);
+        } // Add together the top, left, bottom, and right properties of
+        // each ClientRect, but keep the width and height of the first one.
+
+        function mergeRectOffsets(rects) {
+          return rects.reduce(function (previousRect, rect) {
+            if (previousRect == null) {
+              return rect;
+            }
+            return {
+              top: previousRect.top + rect.top,
+              left: previousRect.left + rect.left,
+              width: previousRect.width,
+              height: previousRect.height,
+              bottom: previousRect.bottom + rect.bottom,
+              right: previousRect.right + rect.right
+            };
+          });
+        } // Calculate a boundingClientRect for a node relative to boundaryWindow,
+        // taking into account any offsets caused by intermediate iframes.
+
+        function getNestedBoundingClientRect(node, boundaryWindow) {
+          var ownerIframe = getOwnerIframe(node);
+          if (ownerIframe && ownerIframe !== boundaryWindow) {
+            var rects = [node.getBoundingClientRect()];
+            var currentIframe = ownerIframe;
+            var onlyOneMore = false;
+            while (currentIframe) {
+              var rect = getBoundingClientRectWithBorderOffset(currentIframe);
+              rects.push(rect);
+              currentIframe = getOwnerIframe(currentIframe);
+              if (onlyOneMore) {
+                break;
+              } // We don't want to calculate iframe offsets upwards beyond
+              // the iframe containing the boundaryWindow, but we
+              // need to calculate the offset relative to the boundaryWindow.
+
+              if (currentIframe && getOwnerWindow(currentIframe) === boundaryWindow) {
+                onlyOneMore = true;
+              }
+            }
+            return mergeRectOffsets(rects);
+          } else {
+            return node.getBoundingClientRect();
+          }
+        }
+        function getElementDimensions(domElement) {
+          var calculatedStyle = window.getComputedStyle(domElement);
+          return {
+            borderLeft: parseInt(calculatedStyle.borderLeftWidth, 10),
+            borderRight: parseInt(calculatedStyle.borderRightWidth, 10),
+            borderTop: parseInt(calculatedStyle.borderTopWidth, 10),
+            borderBottom: parseInt(calculatedStyle.borderBottomWidth, 10),
+            marginLeft: parseInt(calculatedStyle.marginLeft, 10),
+            marginRight: parseInt(calculatedStyle.marginRight, 10),
+            marginTop: parseInt(calculatedStyle.marginTop, 10),
+            marginBottom: parseInt(calculatedStyle.marginBottom, 10),
+            paddingLeft: parseInt(calculatedStyle.paddingLeft, 10),
+            paddingRight: parseInt(calculatedStyle.paddingRight, 10),
+            paddingTop: parseInt(calculatedStyle.paddingTop, 10),
+            paddingBottom: parseInt(calculatedStyle.paddingBottom, 10)
+          };
+        }
+        function extractHOCNames(displayName) {
+          if (!displayName) return {
+            baseComponentName: '',
+            hocNames: []
+          };
+          var hocRegex = /([A-Z][a-zA-Z0-9]*?)\((.*)\)/g;
+          var hocNames = [];
+          var baseComponentName = displayName;
+          var match;
+          while ((match = hocRegex.exec(baseComponentName)) != null) {
+            if (Array.isArray(match)) {
+              var _match = match,
+                _match2 = views_utils_slicedToArray(_match, 3),
+                hocName = _match2[1],
+                inner = _match2[2];
+              hocNames.push(hocName);
+              baseComponentName = inner;
+            }
+          }
+          return {
+            baseComponentName: baseComponentName,
+            hocNames: hocNames
+          };
+        }
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/views/Highlighter/Overlay.js
+        function Overlay_classCallCheck(instance, Constructor) {
+          if (!(instance instanceof Constructor)) {
+            throw new TypeError("Cannot call a class as a function");
+          }
+        }
+        function Overlay_defineProperties(target, props) {
+          for (var i = 0; i < props.length; i++) {
+            var descriptor = props[i];
+            descriptor.enumerable = descriptor.enumerable || false;
+            descriptor.configurable = true;
+            if ("value" in descriptor) descriptor.writable = true;
+            Object.defineProperty(target, descriptor.key, descriptor);
+          }
+        }
+        function Overlay_createClass(Constructor, protoProps, staticProps) {
+          if (protoProps) Overlay_defineProperties(Constructor.prototype, protoProps);
+          if (staticProps) Overlay_defineProperties(Constructor, staticProps);
+          return Constructor;
+        }
+
+        /**
+         * 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.
+         *
+         * 
+         */
+
+        var Overlay_assign = Object.assign; // Note that the Overlay components are not affected by the active Theme,
+        // because they highlight elements in the main Chrome window (outside of devtools).
+        // The colors below were chosen to roughly match those used by Chrome devtools.
+
+        var OverlayRect = /*#__PURE__*/function () {
+          function OverlayRect(doc, container) {
+            Overlay_classCallCheck(this, OverlayRect);
+            this.node = doc.createElement('div');
+            this.border = doc.createElement('div');
+            this.padding = doc.createElement('div');
+            this.content = doc.createElement('div');
+            this.border.style.borderColor = overlayStyles.border;
+            this.padding.style.borderColor = overlayStyles.padding;
+            this.content.style.backgroundColor = overlayStyles.background;
+            Overlay_assign(this.node.style, {
+              borderColor: overlayStyles.margin,
+              pointerEvents: 'none',
+              position: 'fixed'
+            });
+            this.node.style.zIndex = '10000000';
+            this.node.appendChild(this.border);
+            this.border.appendChild(this.padding);
+            this.padding.appendChild(this.content);
+            container.appendChild(this.node);
+          }
+          return Overlay_createClass(OverlayRect, [{
+            key: "remove",
+            value: function remove() {
+              if (this.node.parentNode) {
+                this.node.parentNode.removeChild(this.node);
+              }
+            }
+          }, {
+            key: "update",
+            value: function update(box, dims) {
+              boxWrap(dims, 'margin', this.node);
+              boxWrap(dims, 'border', this.border);
+              boxWrap(dims, 'padding', this.padding);
+              Overlay_assign(this.content.style, {
+                height: box.height - dims.borderTop - dims.borderBottom - dims.paddingTop - dims.paddingBottom + 'px',
+                width: box.width - dims.borderLeft - dims.borderRight - dims.paddingLeft - dims.paddingRight + 'px'
+              });
+              Overlay_assign(this.node.style, {
+                top: box.top - dims.marginTop + 'px',
+                left: box.left - dims.marginLeft + 'px'
+              });
+            }
+          }]);
+        }();
+        var OverlayTip = /*#__PURE__*/function () {
+          function OverlayTip(doc, container) {
+            Overlay_classCallCheck(this, OverlayTip);
+            this.tip = doc.createElement('div');
+            Overlay_assign(this.tip.style, {
+              display: 'flex',
+              flexFlow: 'row nowrap',
+              backgroundColor: '#333740',
+              borderRadius: '2px',
+              fontFamily: '"SFMono-Regular", Consolas, "Liberation Mono", Menlo, Courier, monospace',
+              fontWeight: 'bold',
+              padding: '3px 5px',
+              pointerEvents: 'none',
+              position: 'fixed',
+              fontSize: '12px',
+              whiteSpace: 'nowrap'
+            });
+            this.nameSpan = doc.createElement('span');
+            this.tip.appendChild(this.nameSpan);
+            Overlay_assign(this.nameSpan.style, {
+              color: '#ee78e6',
+              borderRight: '1px solid #aaaaaa',
+              paddingRight: '0.5rem',
+              marginRight: '0.5rem'
+            });
+            this.dimSpan = doc.createElement('span');
+            this.tip.appendChild(this.dimSpan);
+            Overlay_assign(this.dimSpan.style, {
+              color: '#d7d7d7'
+            });
+            this.tip.style.zIndex = '10000000';
+            container.appendChild(this.tip);
+          }
+          return Overlay_createClass(OverlayTip, [{
+            key: "remove",
+            value: function remove() {
+              if (this.tip.parentNode) {
+                this.tip.parentNode.removeChild(this.tip);
+              }
+            }
+          }, {
+            key: "updateText",
+            value: function updateText(name, width, height) {
+              this.nameSpan.textContent = name;
+              this.dimSpan.textContent = Math.round(width) + 'px × ' + Math.round(height) + 'px';
+            }
+          }, {
+            key: "updatePosition",
+            value: function updatePosition(dims, bounds) {
+              var tipRect = this.tip.getBoundingClientRect();
+              var tipPos = findTipPos(dims, bounds, {
+                width: tipRect.width,
+                height: tipRect.height
+              });
+              Overlay_assign(this.tip.style, tipPos.style);
+            }
+          }]);
+        }();
+        var Overlay = /*#__PURE__*/function () {
+          function Overlay(agent) {
+            Overlay_classCallCheck(this, Overlay);
+
+            // Find the root window, because overlays are positioned relative to it.
+            var currentWindow = window.__REACT_DEVTOOLS_TARGET_WINDOW__ || window;
+            this.window = currentWindow; // When opened in shells/dev, the tooltip should be bound by the app iframe, not by the topmost window.
+
+            var tipBoundsWindow = window.__REACT_DEVTOOLS_TARGET_WINDOW__ || window;
+            this.tipBoundsWindow = tipBoundsWindow;
+            var doc = currentWindow.document;
+            this.container = doc.createElement('div');
+            this.container.style.zIndex = '10000000';
+            this.tip = new OverlayTip(doc, this.container);
+            this.rects = [];
+            this.agent = agent;
+            doc.body.appendChild(this.container);
+          }
+          return Overlay_createClass(Overlay, [{
+            key: "remove",
+            value: function remove() {
+              this.tip.remove();
+              this.rects.forEach(function (rect) {
+                rect.remove();
+              });
+              this.rects.length = 0;
+              if (this.container.parentNode) {
+                this.container.parentNode.removeChild(this.container);
+              }
+            }
+          }, {
+            key: "inspect",
+            value: function inspect(nodes, name) {
+              var _this = this;
+
+              // We can't get the size of text nodes or comment nodes. React as of v15
+              // heavily uses comment nodes to delimit text.
+              var elements = nodes.filter(function (node) {
+                return node.nodeType === Node.ELEMENT_NODE;
+              });
+              while (this.rects.length > elements.length) {
+                var rect = this.rects.pop(); // $FlowFixMe[incompatible-use]
+
+                rect.remove();
+              }
+              if (elements.length === 0) {
+                return;
+              }
+              while (this.rects.length < elements.length) {
+                this.rects.push(new OverlayRect(this.window.document, this.container));
+              }
+              var outerBox = {
+                top: Number.POSITIVE_INFINITY,
+                right: Number.NEGATIVE_INFINITY,
+                bottom: Number.NEGATIVE_INFINITY,
+                left: Number.POSITIVE_INFINITY
+              };
+              elements.forEach(function (element, index) {
+                var box = getNestedBoundingClientRect(element, _this.window);
+                var dims = getElementDimensions(element);
+                outerBox.top = Math.min(outerBox.top, box.top - dims.marginTop);
+                outerBox.right = Math.max(outerBox.right, box.left + box.width + dims.marginRight);
+                outerBox.bottom = Math.max(outerBox.bottom, box.top + box.height + dims.marginBottom);
+                outerBox.left = Math.min(outerBox.left, box.left - dims.marginLeft);
+                var rect = _this.rects[index];
+                rect.update(box, dims);
+              });
+              if (!name) {
+                name = elements[0].nodeName.toLowerCase();
+                var node = elements[0];
+                var ownerName = this.agent.getComponentNameForHostInstance(node);
+                if (ownerName) {
+                  name += ' (in ' + ownerName + ')';
+                }
+              }
+              this.tip.updateText(name, outerBox.right - outerBox.left, outerBox.bottom - outerBox.top);
+              var tipBounds = getNestedBoundingClientRect(this.tipBoundsWindow.document.documentElement, this.window);
+              this.tip.updatePosition({
+                top: outerBox.top,
+                left: outerBox.left,
+                height: outerBox.bottom - outerBox.top,
+                width: outerBox.right - outerBox.left
+              }, {
+                top: tipBounds.top + this.tipBoundsWindow.scrollY,
+                left: tipBounds.left + this.tipBoundsWindow.scrollX,
+                height: this.tipBoundsWindow.innerHeight,
+                width: this.tipBoundsWindow.innerWidth
+              });
+            }
+          }]);
+        }();
+        function findTipPos(dims, bounds, tipSize) {
+          var tipHeight = Math.max(tipSize.height, 20);
+          var tipWidth = Math.max(tipSize.width, 60);
+          var margin = 5;
+          var top;
+          if (dims.top + dims.height + tipHeight <= bounds.top + bounds.height) {
+            if (dims.top + dims.height < bounds.top + 0) {
+              top = bounds.top + margin;
+            } else {
+              top = dims.top + dims.height + margin;
+            }
+          } else if (dims.top - tipHeight <= bounds.top + bounds.height) {
+            if (dims.top - tipHeight - margin < bounds.top + margin) {
+              top = bounds.top + margin;
+            } else {
+              top = dims.top - tipHeight - margin;
+            }
+          } else {
+            top = bounds.top + bounds.height - tipHeight - margin;
+          }
+          var left = dims.left + margin;
+          if (dims.left < bounds.left) {
+            left = bounds.left + margin;
+          }
+          if (dims.left + tipWidth > bounds.left + bounds.width) {
+            left = bounds.left + bounds.width - tipWidth - margin;
+          }
+          top += 'px';
+          left += 'px';
+          return {
+            style: {
+              top: top,
+              left: left
+            }
+          };
+        }
+        function boxWrap(dims, what, node) {
+          Overlay_assign(node.style, {
+            borderTopWidth: dims[what + 'Top'] + 'px',
+            borderLeftWidth: dims[what + 'Left'] + 'px',
+            borderRightWidth: dims[what + 'Right'] + 'px',
+            borderBottomWidth: dims[what + 'Bottom'] + 'px',
+            borderStyle: 'solid'
+          });
+        }
+        var overlayStyles = {
+          background: 'rgba(120, 170, 210, 0.7)',
+          padding: 'rgba(77, 200, 0, 0.3)',
+          margin: 'rgba(255, 155, 0, 0.3)',
+          border: 'rgba(255, 200, 50, 0.3)'
+        };
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/views/Highlighter/Highlighter.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.
+         *
+         * 
+         */
+
+        var SHOW_DURATION = 2000;
+        var timeoutID = null;
+        var overlay = null;
+        function hideOverlayNative(agent) {
+          agent.emit('hideNativeHighlight');
+        }
+        function hideOverlayWeb() {
+          timeoutID = null;
+          if (overlay !== null) {
+            overlay.remove();
+            overlay = null;
+          }
+        }
+        function hideOverlay(agent) {
+          return isReactNativeEnvironment() ? hideOverlayNative(agent) : hideOverlayWeb();
+        }
+        function showOverlayNative(elements, agent) {
+          agent.emit('showNativeHighlight', elements);
+        }
+        function showOverlayWeb(elements, componentName, agent, hideAfterTimeout) {
+          if (timeoutID !== null) {
+            clearTimeout(timeoutID);
+          }
+          if (overlay === null) {
+            overlay = new Overlay(agent);
+          }
+          overlay.inspect(elements, componentName);
+          if (hideAfterTimeout) {
+            timeoutID = setTimeout(function () {
+              return hideOverlay(agent);
+            }, SHOW_DURATION);
+          }
+        }
+        function showOverlay(elements, componentName, agent, hideAfterTimeout) {
+          return isReactNativeEnvironment() ? showOverlayNative(elements, agent) : showOverlayWeb(elements, componentName, agent, hideAfterTimeout);
+        }
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/views/Highlighter/index.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.
+         *
+         * 
+         */
+
+        // This plug-in provides in-page highlighting of the selected element.
+        // It is used by the browser extension and the standalone DevTools shell (when connected to a browser).
+        // It is not currently the mechanism used to highlight React Native views.
+        // That is done by the React Native Inspector component.
+        var iframesListeningTo = new Set();
+        function setupHighlighter(bridge, agent) {
+          bridge.addListener('clearHostInstanceHighlight', clearHostInstanceHighlight);
+          bridge.addListener('highlightHostInstance', highlightHostInstance);
+          bridge.addListener('shutdown', stopInspectingHost);
+          bridge.addListener('startInspectingHost', startInspectingHost);
+          bridge.addListener('stopInspectingHost', stopInspectingHost);
+          function startInspectingHost() {
+            registerListenersOnWindow(window);
+          }
+          function registerListenersOnWindow(window) {
+            // This plug-in may run in non-DOM environments (e.g. React Native).
+            if (window && typeof window.addEventListener === 'function') {
+              window.addEventListener('click', onClick, true);
+              window.addEventListener('mousedown', onMouseEvent, true);
+              window.addEventListener('mouseover', onMouseEvent, true);
+              window.addEventListener('mouseup', onMouseEvent, true);
+              window.addEventListener('pointerdown', onPointerDown, true);
+              window.addEventListener('pointermove', onPointerMove, true);
+              window.addEventListener('pointerup', onPointerUp, true);
+            } else {
+              agent.emit('startInspectingNative');
+            }
+          }
+          function stopInspectingHost() {
+            hideOverlay(agent);
+            removeListenersOnWindow(window);
+            iframesListeningTo.forEach(function (frame) {
+              try {
+                removeListenersOnWindow(frame.contentWindow);
+              } catch (error) {// This can error when the iframe is on a cross-origin.
+              }
+            });
+            iframesListeningTo = new Set();
+          }
+          function removeListenersOnWindow(window) {
+            // This plug-in may run in non-DOM environments (e.g. React Native).
+            if (window && typeof window.removeEventListener === 'function') {
+              window.removeEventListener('click', onClick, true);
+              window.removeEventListener('mousedown', onMouseEvent, true);
+              window.removeEventListener('mouseover', onMouseEvent, true);
+              window.removeEventListener('mouseup', onMouseEvent, true);
+              window.removeEventListener('pointerdown', onPointerDown, true);
+              window.removeEventListener('pointermove', onPointerMove, true);
+              window.removeEventListener('pointerup', onPointerUp, true);
+            } else {
+              agent.emit('stopInspectingNative');
+            }
+          }
+          function clearHostInstanceHighlight() {
+            hideOverlay(agent);
+          }
+          function highlightHostInstance(_ref) {
+            var displayName = _ref.displayName,
+              hideAfterTimeout = _ref.hideAfterTimeout,
+              id = _ref.id,
+              openBuiltinElementsPanel = _ref.openBuiltinElementsPanel,
+              rendererID = _ref.rendererID,
+              scrollIntoView = _ref.scrollIntoView;
+            var renderer = agent.rendererInterfaces[rendererID];
+            if (renderer == null) {
+              console.warn("Invalid renderer id \"".concat(rendererID, "\" for element \"").concat(id, "\""));
+              hideOverlay(agent);
+              return;
+            } // In some cases fiber may already be unmounted
+
+            if (!renderer.hasElementWithId(id)) {
+              hideOverlay(agent);
+              return;
+            }
+            var nodes = renderer.findHostInstancesForElementID(id);
+            if (nodes != null && nodes[0] != null) {
+              var node = nodes[0]; // $FlowFixMe[method-unbinding]
+
+              if (scrollIntoView && typeof node.scrollIntoView === 'function') {
+                // If the node isn't visible show it before highlighting it.
+                // We may want to reconsider this; it might be a little disruptive.
+                node.scrollIntoView({
+                  block: 'nearest',
+                  inline: 'nearest'
+                });
+              }
+              showOverlay(nodes, displayName, agent, hideAfterTimeout);
+              if (openBuiltinElementsPanel) {
+                window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$0 = node;
+                bridge.send('syncSelectionToBuiltinElementsPanel');
+              }
+            } else {
+              hideOverlay(agent);
+            }
+          }
+          function onClick(event) {
+            event.preventDefault();
+            event.stopPropagation();
+            stopInspectingHost();
+            bridge.send('stopInspectingHost', true);
+          }
+          function onMouseEvent(event) {
+            event.preventDefault();
+            event.stopPropagation();
+          }
+          function onPointerDown(event) {
+            event.preventDefault();
+            event.stopPropagation();
+            selectElementForNode(getEventTarget(event));
+          }
+          var lastHoveredNode = null;
+          function onPointerMove(event) {
+            event.preventDefault();
+            event.stopPropagation();
+            var target = getEventTarget(event);
+            if (lastHoveredNode === target) return;
+            lastHoveredNode = target;
+            if (target.tagName === 'IFRAME') {
+              var iframe = target;
+              try {
+                if (!iframesListeningTo.has(iframe)) {
+                  var _window = iframe.contentWindow;
+                  registerListenersOnWindow(_window);
+                  iframesListeningTo.add(iframe);
+                }
+              } catch (error) {// This can error when the iframe is on a cross-origin.
+              }
+            } // Don't pass the name explicitly.
+            // It will be inferred from DOM tag and Fiber owner.
+
+            showOverlay([target], null, agent, false);
+            selectElementForNode(target);
+          }
+          function onPointerUp(event) {
+            event.preventDefault();
+            event.stopPropagation();
+          }
+          var selectElementForNode = function selectElementForNode(node) {
+            var id = agent.getIDForHostInstance(node);
+            if (id !== null) {
+              bridge.send('selectElement', id);
+            }
+          };
+          function getEventTarget(event) {
+            if (event.composed) {
+              return event.composedPath()[0];
+            }
+            return event.target;
+          }
+        }
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/views/TraceUpdates/canvas.js
+        function canvas_toConsumableArray(arr) {
+          return canvas_arrayWithoutHoles(arr) || canvas_iterableToArray(arr) || canvas_unsupportedIterableToArray(arr) || canvas_nonIterableSpread();
+        }
+        function canvas_nonIterableSpread() {
+          throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+        }
+        function canvas_unsupportedIterableToArray(o, minLen) {
+          if (!o) return;
+          if (typeof o === "string") return canvas_arrayLikeToArray(o, minLen);
+          var n = Object.prototype.toString.call(o).slice(8, -1);
+          if (n === "Object" && o.constructor) n = o.constructor.name;
+          if (n === "Map" || n === "Set") return Array.from(o);
+          if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return canvas_arrayLikeToArray(o, minLen);
+        }
+        function canvas_iterableToArray(iter) {
+          if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
+        }
+        function canvas_arrayWithoutHoles(arr) {
+          if (Array.isArray(arr)) return canvas_arrayLikeToArray(arr);
+        }
+        function canvas_arrayLikeToArray(arr, len) {
+          if (len == null || len > arr.length) len = arr.length;
+          for (var i = 0, arr2 = new Array(len); i < len; i++) {
+            arr2[i] = arr[i];
+          }
+          return arr2;
+        }
+
+        /**
+         * 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.
+         *
+         * 
+         */
+        // Note these colors are in sync with DevTools Profiler chart colors.
+
+        var COLORS = ['#37afa9', '#63b19e', '#80b393', '#97b488', '#abb67d', '#beb771', '#cfb965', '#dfba57', '#efbb49', '#febc38'];
+        var canvas = null;
+        function drawNative(nodeToData, agent) {
+          var nodesToDraw = [];
+          iterateNodes(nodeToData, function (_ref) {
+            var color = _ref.color,
+              node = _ref.node;
+            nodesToDraw.push({
+              node: node,
+              color: color
+            });
+          });
+          agent.emit('drawTraceUpdates', nodesToDraw);
+          var mergedNodes = groupAndSortNodes(nodeToData);
+          agent.emit('drawGroupedTraceUpdatesWithNames', mergedNodes);
+        }
+        function drawWeb(nodeToData) {
+          if (canvas === null) {
+            initialize();
+          }
+          var dpr = window.devicePixelRatio || 1;
+          var canvasFlow = canvas;
+          canvasFlow.width = window.innerWidth * dpr;
+          canvasFlow.height = window.innerHeight * dpr;
+          canvasFlow.style.width = "".concat(window.innerWidth, "px");
+          canvasFlow.style.height = "".concat(window.innerHeight, "px");
+          var context = canvasFlow.getContext('2d');
+          context.scale(dpr, dpr);
+          context.clearRect(0, 0, canvasFlow.width / dpr, canvasFlow.height / dpr);
+          var mergedNodes = groupAndSortNodes(nodeToData);
+          mergedNodes.forEach(function (group) {
+            drawGroupBorders(context, group);
+            drawGroupLabel(context, group);
+          });
+          if (canvas !== null) {
+            if (nodeToData.size === 0 && canvas.matches(':popover-open')) {
+              // $FlowFixMe[prop-missing]: Flow doesn't recognize Popover API
+              // $FlowFixMe[incompatible-use]: Flow doesn't recognize Popover API
+              canvas.hidePopover();
+              return;
+            } // $FlowFixMe[incompatible-use]: Flow doesn't recognize Popover API
+
+            if (canvas.matches(':popover-open')) {
+              // $FlowFixMe[prop-missing]: Flow doesn't recognize Popover API
+              // $FlowFixMe[incompatible-use]: Flow doesn't recognize Popover API
+              canvas.hidePopover();
+            } // $FlowFixMe[prop-missing]: Flow doesn't recognize Popover API
+            // $FlowFixMe[incompatible-use]: Flow doesn't recognize Popover API
+
+            canvas.showPopover();
+          }
+        }
+        function groupAndSortNodes(nodeToData) {
+          var positionGroups = new Map();
+          iterateNodes(nodeToData, function (_ref2) {
+            var _positionGroups$get;
+            var rect = _ref2.rect,
+              color = _ref2.color,
+              displayName = _ref2.displayName,
+              count = _ref2.count;
+            if (!rect) return;
+            var key = "".concat(rect.left, ",").concat(rect.top);
+            if (!positionGroups.has(key)) positionGroups.set(key, []);
+            (_positionGroups$get = positionGroups.get(key)) === null || _positionGroups$get === void 0 ? void 0 : _positionGroups$get.push({
+              rect: rect,
+              color: color,
+              displayName: displayName,
+              count: count
+            });
+          });
+          return Array.from(positionGroups.values()).sort(function (groupA, groupB) {
+            var maxCountA = Math.max.apply(Math, canvas_toConsumableArray(groupA.map(function (item) {
+              return item.count;
+            })));
+            var maxCountB = Math.max.apply(Math, canvas_toConsumableArray(groupB.map(function (item) {
+              return item.count;
+            })));
+            return maxCountA - maxCountB;
+          });
+        }
+        function drawGroupBorders(context, group) {
+          group.forEach(function (_ref3) {
+            var color = _ref3.color,
+              rect = _ref3.rect;
+            context.beginPath();
+            context.strokeStyle = color;
+            context.rect(rect.left, rect.top, rect.width - 1, rect.height - 1);
+            context.stroke();
+          });
+        }
+        function drawGroupLabel(context, group) {
+          var mergedName = group.map(function (_ref4) {
+            var displayName = _ref4.displayName,
+              count = _ref4.count;
+            return displayName ? "".concat(displayName).concat(count > 1 ? " x".concat(count) : '') : '';
+          }).filter(Boolean).join(', ');
+          if (mergedName) {
+            drawLabel(context, group[0].rect, mergedName, group[0].color);
+          }
+        }
+        function draw(nodeToData, agent) {
+          return isReactNativeEnvironment() ? drawNative(nodeToData, agent) : drawWeb(nodeToData);
+        }
+        function iterateNodes(nodeToData, execute) {
+          nodeToData.forEach(function (data, node) {
+            var colorIndex = Math.min(COLORS.length - 1, data.count - 1);
+            var color = COLORS[colorIndex];
+            execute({
+              color: color,
+              node: node,
+              count: data.count,
+              displayName: data.displayName,
+              expirationTime: data.expirationTime,
+              lastMeasuredAt: data.lastMeasuredAt,
+              rect: data.rect
+            });
+          });
+        }
+        function drawLabel(context, rect, text, color) {
+          var left = rect.left,
+            top = rect.top;
+          context.font = '10px monospace';
+          context.textBaseline = 'middle';
+          context.textAlign = 'center';
+          var padding = 2;
+          var textHeight = 14;
+          var metrics = context.measureText(text);
+          var backgroundWidth = metrics.width + padding * 2;
+          var backgroundHeight = textHeight;
+          var labelX = left;
+          var labelY = top - backgroundHeight;
+          context.fillStyle = color;
+          context.fillRect(labelX, labelY, backgroundWidth, backgroundHeight);
+          context.fillStyle = '#000000';
+          context.fillText(text, labelX + backgroundWidth / 2, labelY + backgroundHeight / 2);
+        }
+        function destroyNative(agent) {
+          agent.emit('disableTraceUpdates');
+        }
+        function destroyWeb() {
+          if (canvas !== null) {
+            if (canvas.matches(':popover-open')) {
+              // $FlowFixMe[prop-missing]: Flow doesn't recognize Popover API
+              // $FlowFixMe[incompatible-use]: Flow doesn't recognize Popover API
+              canvas.hidePopover();
+            } // $FlowFixMe[incompatible-use]: Flow doesn't recognize Popover API and loses canvas nullability tracking
+
+            if (canvas.parentNode != null) {
+              // $FlowFixMe[incompatible-call]: Flow doesn't track that canvas is non-null here
+              canvas.parentNode.removeChild(canvas);
+            }
+            canvas = null;
+          }
+        }
+        function destroy(agent) {
+          return isReactNativeEnvironment() ? destroyNative(agent) : destroyWeb();
+        }
+        function initialize() {
+          canvas = window.document.createElement('canvas');
+          canvas.setAttribute('popover', 'manual'); // $FlowFixMe[incompatible-use]: Flow doesn't recognize Popover API
+
+          canvas.style.cssText = "\n    xx-background-color: red;\n    xx-opacity: 0.5;\n    bottom: 0;\n    left: 0;\n    pointer-events: none;\n    position: fixed;\n    right: 0;\n    top: 0;\n    background-color: transparent;\n    outline: none;\n    box-shadow: none;\n    border: none;\n  ";
+          var root = window.document.documentElement;
+          root.insertBefore(canvas, root.firstChild);
+        }
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/views/TraceUpdates/index.js
+        function TraceUpdates_typeof(obj) {
+          "@babel/helpers - typeof";
+
+          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+            TraceUpdates_typeof = function _typeof(obj) {
+              return typeof obj;
+            };
+          } else {
+            TraceUpdates_typeof = function _typeof(obj) {
+              return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+            };
+          }
+          return TraceUpdates_typeof(obj);
+        }
+
+        /**
+         * 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.
+         *
+         * 
+         */
+
+        // How long the rect should be shown for?
+        var DISPLAY_DURATION = 250; // What's the longest we are willing to show the overlay for?
+        // This can be important if we're getting a flurry of events (e.g. scroll update).
+
+        var MAX_DISPLAY_DURATION = 3000; // How long should a rect be considered valid for?
+
+        var REMEASUREMENT_AFTER_DURATION = 250; // Markers for different types of HOCs
+
+        var HOC_MARKERS = new Map([['Forget', '✨'], ['Memo', '🧠']]); // Some environments (e.g. React Native / Hermes) don't support the performance API yet.
+
+        var getCurrentTime =
+        // $FlowFixMe[method-unbinding]
+        (typeof performance === "undefined" ? "undefined" : TraceUpdates_typeof(performance)) === 'object' && typeof performance.now === 'function' ? function () {
+          return performance.now();
+        } : function () {
+          return Date.now();
+        };
+        var nodeToData = new Map();
+        var agent = null;
+        var drawAnimationFrameID = null;
+        var isEnabled = false;
+        var redrawTimeoutID = null;
+        function TraceUpdates_initialize(injectedAgent) {
+          agent = injectedAgent;
+          agent.addListener('traceUpdates', traceUpdates);
+        }
+        function toggleEnabled(value) {
+          isEnabled = value;
+          if (!isEnabled) {
+            nodeToData.clear();
+            if (drawAnimationFrameID !== null) {
+              cancelAnimationFrame(drawAnimationFrameID);
+              drawAnimationFrameID = null;
+            }
+            if (redrawTimeoutID !== null) {
+              clearTimeout(redrawTimeoutID);
+              redrawTimeoutID = null;
+            }
+            destroy(agent);
+          }
+        }
+        function traceUpdates(nodes) {
+          if (!isEnabled) return;
+          nodes.forEach(function (node) {
+            var data = nodeToData.get(node);
+            var now = getCurrentTime();
+            var lastMeasuredAt = data != null ? data.lastMeasuredAt : 0;
+            var rect = data != null ? data.rect : null;
+            if (rect === null || lastMeasuredAt + REMEASUREMENT_AFTER_DURATION < now) {
+              lastMeasuredAt = now;
+              rect = measureNode(node);
+            }
+            var displayName = agent.getComponentNameForHostInstance(node);
+            if (displayName) {
+              var _extractHOCNames = extractHOCNames(displayName),
+                baseComponentName = _extractHOCNames.baseComponentName,
+                hocNames = _extractHOCNames.hocNames;
+              var markers = hocNames.map(function (hoc) {
+                return HOC_MARKERS.get(hoc) || '';
+              }).join('');
+              var enhancedDisplayName = markers ? "".concat(markers).concat(baseComponentName) : baseComponentName;
+              displayName = enhancedDisplayName;
+            }
+            nodeToData.set(node, {
+              count: data != null ? data.count + 1 : 1,
+              expirationTime: data != null ? Math.min(now + MAX_DISPLAY_DURATION, data.expirationTime + DISPLAY_DURATION) : now + DISPLAY_DURATION,
+              lastMeasuredAt: lastMeasuredAt,
+              rect: rect,
+              displayName: displayName
+            });
+          });
+          if (redrawTimeoutID !== null) {
+            clearTimeout(redrawTimeoutID);
+            redrawTimeoutID = null;
+          }
+          if (drawAnimationFrameID === null) {
+            drawAnimationFrameID = requestAnimationFrame(prepareToDraw);
+          }
+        }
+        function prepareToDraw() {
+          drawAnimationFrameID = null;
+          redrawTimeoutID = null;
+          var now = getCurrentTime();
+          var earliestExpiration = Number.MAX_VALUE; // Remove any items that have already expired.
+
+          nodeToData.forEach(function (data, node) {
+            if (data.expirationTime < now) {
+              nodeToData.delete(node);
+            } else {
+              earliestExpiration = Math.min(earliestExpiration, data.expirationTime);
+            }
+          });
+          draw(nodeToData, agent);
+          if (earliestExpiration !== Number.MAX_VALUE) {
+            redrawTimeoutID = setTimeout(prepareToDraw, earliestExpiration - now);
+          }
+        }
+        function measureNode(node) {
+          if (!node || typeof node.getBoundingClientRect !== 'function') {
+            return null;
+          }
+          var currentWindow = window.__REACT_DEVTOOLS_TARGET_WINDOW__ || window;
+          return getNestedBoundingClientRect(node, currentWindow);
+        }
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/bridge.js
+        function bridge_typeof(obj) {
+          "@babel/helpers - typeof";
+
+          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+            bridge_typeof = function _typeof(obj) {
+              return typeof obj;
+            };
+          } else {
+            bridge_typeof = function _typeof(obj) {
+              return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+            };
+          }
+          return bridge_typeof(obj);
+        }
+        function bridge_toConsumableArray(arr) {
+          return bridge_arrayWithoutHoles(arr) || bridge_iterableToArray(arr) || bridge_unsupportedIterableToArray(arr) || bridge_nonIterableSpread();
+        }
+        function bridge_nonIterableSpread() {
+          throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+        }
+        function bridge_unsupportedIterableToArray(o, minLen) {
+          if (!o) return;
+          if (typeof o === "string") return bridge_arrayLikeToArray(o, minLen);
+          var n = Object.prototype.toString.call(o).slice(8, -1);
+          if (n === "Object" && o.constructor) n = o.constructor.name;
+          if (n === "Map" || n === "Set") return Array.from(o);
+          if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return bridge_arrayLikeToArray(o, minLen);
+        }
+        function bridge_iterableToArray(iter) {
+          if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
+        }
+        function bridge_arrayWithoutHoles(arr) {
+          if (Array.isArray(arr)) return bridge_arrayLikeToArray(arr);
+        }
+        function bridge_arrayLikeToArray(arr, len) {
+          if (len == null || len > arr.length) len = arr.length;
+          for (var i = 0, arr2 = new Array(len); i < len; i++) {
+            arr2[i] = arr[i];
+          }
+          return arr2;
+        }
+        function bridge_classCallCheck(instance, Constructor) {
+          if (!(instance instanceof Constructor)) {
+            throw new TypeError("Cannot call a class as a function");
+          }
+        }
+        function bridge_defineProperties(target, props) {
+          for (var i = 0; i < props.length; i++) {
+            var descriptor = props[i];
+            descriptor.enumerable = descriptor.enumerable || false;
+            descriptor.configurable = true;
+            if ("value" in descriptor) descriptor.writable = true;
+            Object.defineProperty(target, descriptor.key, descriptor);
+          }
+        }
+        function bridge_createClass(Constructor, protoProps, staticProps) {
+          if (protoProps) bridge_defineProperties(Constructor.prototype, protoProps);
+          if (staticProps) bridge_defineProperties(Constructor, staticProps);
+          return Constructor;
+        }
+        function _callSuper(_this, derived, args) {
+          function isNativeReflectConstruct() {
+            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+            if (Reflect.construct.sham) return false;
+            if (typeof Proxy === "function") return true;
+            try {
+              return !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+            } catch (e) {
+              return false;
+            }
+          }
+          derived = _getPrototypeOf(derived);
+          return _possibleConstructorReturn(_this, isNativeReflectConstruct() ? Reflect.construct(derived, args || [], _getPrototypeOf(_this).constructor) : derived.apply(_this, args));
+        }
+        function _possibleConstructorReturn(self, call) {
+          if (call && (bridge_typeof(call) === "object" || typeof call === "function")) {
+            return call;
+          }
+          return _assertThisInitialized(self);
+        }
+        function _assertThisInitialized(self) {
+          if (self === void 0) {
+            throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+          }
+          return self;
+        }
+        function _getPrototypeOf(o) {
+          _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+            return o.__proto__ || Object.getPrototypeOf(o);
+          };
+          return _getPrototypeOf(o);
+        }
+        function _inherits(subClass, superClass) {
+          if (typeof superClass !== "function" && superClass !== null) {
+            throw new TypeError("Super expression must either be null or a function");
+          }
+          subClass.prototype = Object.create(superClass && superClass.prototype, {
+            constructor: {
+              value: subClass,
+              writable: true,
+              configurable: true
+            }
+          });
+          if (superClass) _setPrototypeOf(subClass, superClass);
+        }
+        function _setPrototypeOf(o, p) {
+          _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+            o.__proto__ = p;
+            return o;
+          };
+          return _setPrototypeOf(o, p);
+        }
+        function bridge_defineProperty(obj, key, value) {
+          if (key in obj) {
+            Object.defineProperty(obj, key, {
+              value: value,
+              enumerable: true,
+              configurable: true,
+              writable: true
+            });
+          } else {
+            obj[key] = value;
+          }
+          return obj;
+        }
+
+        /**
+         * 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.
+         *
+         * 
+         */
+        // This message specifies the version of the DevTools protocol currently supported by the backend,
+        // as well as the earliest NPM version (e.g. "4.13.0") that protocol is supported by on the frontend.
+        // This enables an older frontend to display an upgrade message to users for a newer, unsupported backend.
+
+        // Bump protocol version whenever a backwards breaking change is made
+        // in the messages sent between BackendBridge and FrontendBridge.
+        // This mapping is embedded in both frontend and backend builds.
+        //
+        // The backend protocol will always be the latest entry in the BRIDGE_PROTOCOL array.
+        //
+        // When an older frontend connects to a newer backend,
+        // the backend can send the minNpmVersion and the frontend can display an NPM upgrade prompt.
+        //
+        // When a newer frontend connects with an older protocol version,
+        // the frontend can use the embedded minNpmVersion/maxNpmVersion values to display a downgrade prompt.
+        var BRIDGE_PROTOCOL = [
+        // This version technically never existed,
+        // but a backwards breaking change was added in 4.11,
+        // so the safest guess to downgrade the frontend would be to version 4.10.
+        {
+          version: 0,
+          minNpmVersion: '"<4.11.0"',
+          maxNpmVersion: '"<4.11.0"'
+        },
+        // Versions 4.11.x – 4.12.x contained the backwards breaking change,
+        // but we didn't add the "fix" of checking the protocol version until 4.13,
+        // so we don't recommend downgrading to 4.11 or 4.12.
+        {
+          version: 1,
+          minNpmVersion: '4.13.0',
+          maxNpmVersion: '4.21.0'
+        },
+        // Version 2 adds a StrictMode-enabled and supports-StrictMode bits to add-root operation.
+        {
+          version: 2,
+          minNpmVersion: '4.22.0',
+          maxNpmVersion: null
+        }];
+        var currentBridgeProtocol = BRIDGE_PROTOCOL[BRIDGE_PROTOCOL.length - 1];
+        var Bridge = /*#__PURE__*/function (_EventEmitter) {
+          function Bridge(wall) {
+            var _this2;
+            bridge_classCallCheck(this, Bridge);
+            _this2 = _callSuper(this, Bridge);
+            bridge_defineProperty(_this2, "_isShutdown", false);
+            bridge_defineProperty(_this2, "_messageQueue", []);
+            bridge_defineProperty(_this2, "_scheduledFlush", false);
+            bridge_defineProperty(_this2, "_wallUnlisten", null);
+            bridge_defineProperty(_this2, "_flush", function () {
+              // This method is used after the bridge is marked as destroyed in shutdown sequence,
+              // so we do not bail out if the bridge marked as destroyed.
+              // It is a private method that the bridge ensures is only called at the right times.
+              try {
+                if (_this2._messageQueue.length) {
+                  for (var i = 0; i < _this2._messageQueue.length; i += 2) {
+                    var _this2$_wall;
+                    (_this2$_wall = _this2._wall).send.apply(_this2$_wall, [_this2._messageQueue[i]].concat(bridge_toConsumableArray(_this2._messageQueue[i + 1])));
+                  }
+                  _this2._messageQueue.length = 0;
+                }
+              } finally {
+                // We set this at the end in case new messages are added synchronously above.
+                // They're already handled so they shouldn't queue more flushes.
+                _this2._scheduledFlush = false;
+              }
+            });
+            bridge_defineProperty(_this2, "overrideValueAtPath", function (_ref) {
+              var id = _ref.id,
+                path = _ref.path,
+                rendererID = _ref.rendererID,
+                type = _ref.type,
+                value = _ref.value;
+              switch (type) {
+                case 'context':
+                  _this2.send('overrideContext', {
+                    id: id,
+                    path: path,
+                    rendererID: rendererID,
+                    wasForwarded: true,
+                    value: value
+                  });
+                  break;
+                case 'hooks':
+                  _this2.send('overrideHookState', {
+                    id: id,
+                    path: path,
+                    rendererID: rendererID,
+                    wasForwarded: true,
+                    value: value
+                  });
+                  break;
+                case 'props':
+                  _this2.send('overrideProps', {
+                    id: id,
+                    path: path,
+                    rendererID: rendererID,
+                    wasForwarded: true,
+                    value: value
+                  });
+                  break;
+                case 'state':
+                  _this2.send('overrideState', {
+                    id: id,
+                    path: path,
+                    rendererID: rendererID,
+                    wasForwarded: true,
+                    value: value
+                  });
+                  break;
+              }
+            });
+            _this2._wall = wall;
+            _this2._wallUnlisten = wall.listen(function (message) {
+              if (message && message.event) {
+                _this2.emit(message.event, message.payload);
+              }
+            }) || null; // Temporarily support older standalone front-ends sending commands to newer embedded backends.
+            // We do this because React Native embeds the React DevTools backend,
+            // but cannot control which version of the frontend users use.
+
+            _this2.addListener('overrideValueAtPath', _this2.overrideValueAtPath);
+            return _this2;
+          } // Listening directly to the wall isn't advised.
+          // It can be used to listen for legacy (v3) messages (since they use a different format).
+
+          _inherits(Bridge, _EventEmitter);
+          return bridge_createClass(Bridge, [{
+            key: "wall",
+            get: function get() {
+              return this._wall;
+            }
+          }, {
+            key: "send",
+            value: function send(event) {
+              if (this._isShutdown) {
+                console.warn("Cannot send message \"".concat(event, "\" through a Bridge that has been shutdown."));
+                return;
+              } // When we receive a message:
+              // - we add it to our queue of messages to be sent
+              // - if there hasn't been a message recently, we set a timer for 0 ms in
+              //   the future, allowing all messages created in the same tick to be sent
+              //   together
+              // - if there *has* been a message flushed in the last BATCH_DURATION ms
+              //   (or we're waiting for our setTimeout-0 to fire), then _timeoutID will
+              //   be set, and we'll simply add to the queue and wait for that
+
+              for (var _len = arguments.length, payload = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+                payload[_key - 1] = arguments[_key];
+              }
+              this._messageQueue.push(event, payload);
+              if (!this._scheduledFlush) {
+                this._scheduledFlush = true; // $FlowFixMe
+
+                if (typeof devtoolsJestTestScheduler === 'function') {
+                  // This exists just for our own jest tests.
+                  // They're written in such a way that we can neither mock queueMicrotask
+                  // because then we break React DOM and we can't not mock it because then
+                  // we can't synchronously flush it. So they need to be rewritten.
+                  // $FlowFixMe
+                  devtoolsJestTestScheduler(this._flush); // eslint-disable-line no-undef
+                } else {
+                  queueMicrotask(this._flush);
+                }
+              }
+            }
+          }, {
+            key: "shutdown",
+            value: function shutdown() {
+              if (this._isShutdown) {
+                console.warn('Bridge was already shutdown.');
+                return;
+              } // Queue the shutdown outgoing message for subscribers.
+
+              this.emit('shutdown');
+              this.send('shutdown'); // Mark this bridge as destroyed, i.e. disable its public API.
+
+              this._isShutdown = true; // Disable the API inherited from EventEmitter that can add more listeners and send more messages.
+              // $FlowFixMe[cannot-write] This property is not writable.
+
+              this.addListener = function () {}; // $FlowFixMe[cannot-write] This property is not writable.
+
+              this.emit = function () {}; // NOTE: There's also EventEmitter API like `on` and `prependListener` that we didn't add to our Flow type of EventEmitter.
+              // Unsubscribe this bridge incoming message listeners to be sure, and so they don't have to do that.
+
+              this.removeAllListeners(); // Stop accepting and emitting incoming messages from the wall.
+
+              var wallUnlisten = this._wallUnlisten;
+              if (wallUnlisten) {
+                wallUnlisten();
+              } // Synchronously flush all queued outgoing messages.
+              // At this step the subscribers' code may run in this call stack.
+
+              do {
+                this._flush();
+              } while (this._messageQueue.length);
+            } // Temporarily support older standalone backends by forwarding "overrideValueAtPath" commands
+            // to the older message types they may be listening to.
+          }]);
+        }(EventEmitter);
+
+        /* harmony default export */
+        var src_bridge = Bridge;
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/storage.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.
+         *
+         * 
+         */
+        function storage_localStorageGetItem(key) {
+          try {
+            return localStorage.getItem(key);
+          } catch (error) {
+            return null;
+          }
+        }
+        function localStorageRemoveItem(key) {
+          try {
+            localStorage.removeItem(key);
+          } catch (error) {}
+        }
+        function storage_localStorageSetItem(key, value) {
+          try {
+            return localStorage.setItem(key, value);
+          } catch (error) {}
+        }
+        function storage_sessionStorageGetItem(key) {
+          try {
+            return sessionStorage.getItem(key);
+          } catch (error) {
+            return null;
+          }
+        }
+        function storage_sessionStorageRemoveItem(key) {
+          try {
+            sessionStorage.removeItem(key);
+          } catch (error) {}
+        }
+        function storage_sessionStorageSetItem(key, value) {
+          try {
+            return sessionStorage.setItem(key, value);
+          } catch (error) {}
+        }
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/agent.js
+        function agent_typeof(obj) {
+          "@babel/helpers - typeof";
+
+          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+            agent_typeof = function _typeof(obj) {
+              return typeof obj;
+            };
+          } else {
+            agent_typeof = function _typeof(obj) {
+              return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+            };
+          }
+          return agent_typeof(obj);
+        }
+        function agent_classCallCheck(instance, Constructor) {
+          if (!(instance instanceof Constructor)) {
+            throw new TypeError("Cannot call a class as a function");
+          }
+        }
+        function agent_defineProperties(target, props) {
+          for (var i = 0; i < props.length; i++) {
+            var descriptor = props[i];
+            descriptor.enumerable = descriptor.enumerable || false;
+            descriptor.configurable = true;
+            if ("value" in descriptor) descriptor.writable = true;
+            Object.defineProperty(target, descriptor.key, descriptor);
+          }
+        }
+        function agent_createClass(Constructor, protoProps, staticProps) {
+          if (protoProps) agent_defineProperties(Constructor.prototype, protoProps);
+          if (staticProps) agent_defineProperties(Constructor, staticProps);
+          return Constructor;
+        }
+        function agent_callSuper(_this, derived, args) {
+          function isNativeReflectConstruct() {
+            if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+            if (Reflect.construct.sham) return false;
+            if (typeof Proxy === "function") return true;
+            try {
+              return !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+            } catch (e) {
+              return false;
+            }
+          }
+          derived = agent_getPrototypeOf(derived);
+          return agent_possibleConstructorReturn(_this, isNativeReflectConstruct() ? Reflect.construct(derived, args || [], agent_getPrototypeOf(_this).constructor) : derived.apply(_this, args));
+        }
+        function agent_possibleConstructorReturn(self, call) {
+          if (call && (agent_typeof(call) === "object" || typeof call === "function")) {
+            return call;
+          }
+          return agent_assertThisInitialized(self);
+        }
+        function agent_assertThisInitialized(self) {
+          if (self === void 0) {
+            throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+          }
+          return self;
+        }
+        function agent_getPrototypeOf(o) {
+          agent_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+            return o.__proto__ || Object.getPrototypeOf(o);
+          };
+          return agent_getPrototypeOf(o);
+        }
+        function agent_inherits(subClass, superClass) {
+          if (typeof superClass !== "function" && superClass !== null) {
+            throw new TypeError("Super expression must either be null or a function");
+          }
+          subClass.prototype = Object.create(superClass && superClass.prototype, {
+            constructor: {
+              value: subClass,
+              writable: true,
+              configurable: true
+            }
+          });
+          if (superClass) agent_setPrototypeOf(subClass, superClass);
+        }
+        function agent_setPrototypeOf(o, p) {
+          agent_setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+            o.__proto__ = p;
+            return o;
+          };
+          return agent_setPrototypeOf(o, p);
+        }
+        function agent_defineProperty(obj, key, value) {
+          if (key in obj) {
+            Object.defineProperty(obj, key, {
+              value: value,
+              enumerable: true,
+              configurable: true,
+              writable: true
+            });
+          } else {
+            obj[key] = value;
+          }
+          return obj;
+        }
+
+        /**
+         * 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.
+         *
+         * 
+         */
+
+        var debug = function debug(methodName) {
+          if (__DEBUG__) {
+            var _console;
+            for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+              args[_key - 1] = arguments[_key];
+            }
+            (_console = console).log.apply(_console, ["%cAgent %c".concat(methodName), 'color: purple; font-weight: bold;', 'font-weight: bold;'].concat(args));
+          }
+        };
+        var Agent = /*#__PURE__*/function (_EventEmitter) {
+          function Agent(bridge) {
+            var _this2;
+            var isProfiling = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+            var onReloadAndProfile = arguments.length > 2 ? arguments[2] : undefined;
+            agent_classCallCheck(this, Agent);
+            _this2 = agent_callSuper(this, Agent);
+            agent_defineProperty(_this2, "_isProfiling", false);
+            agent_defineProperty(_this2, "_rendererInterfaces", {});
+            agent_defineProperty(_this2, "_persistedSelection", null);
+            agent_defineProperty(_this2, "_persistedSelectionMatch", null);
+            agent_defineProperty(_this2, "_traceUpdatesEnabled", false);
+            agent_defineProperty(_this2, "clearErrorsAndWarnings", function (_ref) {
+              var rendererID = _ref.rendererID;
+              var renderer = _this2._rendererInterfaces[rendererID];
+              if (renderer == null) {
+                console.warn("Invalid renderer id \"".concat(rendererID, "\""));
+              } else {
+                renderer.clearErrorsAndWarnings();
+              }
+            });
+            agent_defineProperty(_this2, "clearErrorsForElementID", function (_ref2) {
+              var id = _ref2.id,
+                rendererID = _ref2.rendererID;
+              var renderer = _this2._rendererInterfaces[rendererID];
+              if (renderer == null) {
+                console.warn("Invalid renderer id \"".concat(rendererID, "\""));
+              } else {
+                renderer.clearErrorsForElementID(id);
+              }
+            });
+            agent_defineProperty(_this2, "clearWarningsForElementID", function (_ref3) {
+              var id = _ref3.id,
+                rendererID = _ref3.rendererID;
+              var renderer = _this2._rendererInterfaces[rendererID];
+              if (renderer == null) {
+                console.warn("Invalid renderer id \"".concat(rendererID, "\""));
+              } else {
+                renderer.clearWarningsForElementID(id);
+              }
+            });
+            agent_defineProperty(_this2, "copyElementPath", function (_ref4) {
+              var id = _ref4.id,
+                path = _ref4.path,
+                rendererID = _ref4.rendererID;
+              var renderer = _this2._rendererInterfaces[rendererID];
+              if (renderer == null) {
+                console.warn("Invalid renderer id \"".concat(rendererID, "\" for element \"").concat(id, "\""));
+              } else {
+                var value = renderer.getSerializedElementValueByPath(id, path);
+                if (value != null) {
+                  _this2._bridge.send('saveToClipboard', value);
+                } else {
+                  console.warn("Unable to obtain serialized value for element \"".concat(id, "\""));
+                }
+              }
+            });
+            agent_defineProperty(_this2, "deletePath", function (_ref5) {
+              var hookID = _ref5.hookID,
+                id = _ref5.id,
+                path = _ref5.path,
+                rendererID = _ref5.rendererID,
+                type = _ref5.type;
+              var renderer = _this2._rendererInterfaces[rendererID];
+              if (renderer == null) {
+                console.warn("Invalid renderer id \"".concat(rendererID, "\" for element \"").concat(id, "\""));
+              } else {
+                renderer.deletePath(type, id, hookID, path);
+              }
+            });
+            agent_defineProperty(_this2, "getBackendVersion", function () {
+              var version = "6.1.5-5d87cd2244";
+              if (version) {
+                _this2._bridge.send('backendVersion', version);
+              }
+            });
+            agent_defineProperty(_this2, "getBridgeProtocol", function () {
+              _this2._bridge.send('bridgeProtocol', currentBridgeProtocol);
+            });
+            agent_defineProperty(_this2, "getProfilingData", function (_ref6) {
+              var rendererID = _ref6.rendererID;
+              var renderer = _this2._rendererInterfaces[rendererID];
+              if (renderer == null) {
+                console.warn("Invalid renderer id \"".concat(rendererID, "\""));
+              }
+              _this2._bridge.send('profilingData', renderer.getProfilingData());
+            });
+            agent_defineProperty(_this2, "getProfilingStatus", function () {
+              _this2._bridge.send('profilingStatus', _this2._isProfiling);
+            });
+            agent_defineProperty(_this2, "getOwnersList", function (_ref7) {
+              var id = _ref7.id,
+                rendererID = _ref7.rendererID;
+              var renderer = _this2._rendererInterfaces[rendererID];
+              if (renderer == null) {
+                console.warn("Invalid renderer id \"".concat(rendererID, "\" for element \"").concat(id, "\""));
+              } else {
+                var owners = renderer.getOwnersList(id);
+                _this2._bridge.send('ownersList', {
+                  id: id,
+                  owners: owners
+                });
+              }
+            });
+            agent_defineProperty(_this2, "inspectElement", function (_ref8) {
+              var forceFullData = _ref8.forceFullData,
+                id = _ref8.id,
+                path = _ref8.path,
+                rendererID = _ref8.rendererID,
+                requestID = _ref8.requestID;
+              var renderer = _this2._rendererInterfaces[rendererID];
+              if (renderer == null) {
+                console.warn("Invalid renderer id \"".concat(rendererID, "\" for element \"").concat(id, "\""));
+              } else {
+                _this2._bridge.send('inspectedElement', renderer.inspectElement(requestID, id, path, forceFullData)); // When user selects an element, stop trying to restore the selection,
+                // and instead remember the current selection for the next reload.
+
+                if (_this2._persistedSelectionMatch === null || _this2._persistedSelectionMatch.id !== id) {
+                  _this2._persistedSelection = null;
+                  _this2._persistedSelectionMatch = null;
+                  renderer.setTrackedPath(null); // Throttle persisting the selection.
+
+                  _this2._lastSelectedElementID = id;
+                  _this2._lastSelectedRendererID = rendererID;
+                  if (!_this2._persistSelectionTimerScheduled) {
+                    _this2._persistSelectionTimerScheduled = true;
+                    setTimeout(_this2._persistSelection, 1000);
+                  }
+                } // TODO: If there was a way to change the selected DOM element
+                // in built-in Elements tab without forcing a switch to it, we'd do it here.
+                // For now, it doesn't seem like there is a way to do that:
+                // https://github.com/bvaughn/react-devtools-experimental/issues/102
+                // (Setting $0 doesn't work, and calling inspect() switches the tab.)
+              }
+            });
+            agent_defineProperty(_this2, "logElementToConsole", function (_ref9) {
+              var id = _ref9.id,
+                rendererID = _ref9.rendererID;
+              var renderer = _this2._rendererInterfaces[rendererID];
+              if (renderer == null) {
+                console.warn("Invalid renderer id \"".concat(rendererID, "\" for element \"").concat(id, "\""));
+              } else {
+                renderer.logElementToConsole(id);
+              }
+            });
+            agent_defineProperty(_this2, "overrideError", function (_ref10) {
+              var id = _ref10.id,
+                rendererID = _ref10.rendererID,
+                forceError = _ref10.forceError;
+              var renderer = _this2._rendererInterfaces[rendererID];
+              if (renderer == null) {
+                console.warn("Invalid renderer id \"".concat(rendererID, "\" for element \"").concat(id, "\""));
+              } else {
+                renderer.overrideError(id, forceError);
+              }
+            });
+            agent_defineProperty(_this2, "overrideSuspense", function (_ref11) {
+              var id = _ref11.id,
+                rendererID = _ref11.rendererID,
+                forceFallback = _ref11.forceFallback;
+              var renderer = _this2._rendererInterfaces[rendererID];
+              if (renderer == null) {
+                console.warn("Invalid renderer id \"".concat(rendererID, "\" for element \"").concat(id, "\""));
+              } else {
+                renderer.overrideSuspense(id, forceFallback);
+              }
+            });
+            agent_defineProperty(_this2, "overrideValueAtPath", function (_ref12) {
+              var hookID = _ref12.hookID,
+                id = _ref12.id,
+                path = _ref12.path,
+                rendererID = _ref12.rendererID,
+                type = _ref12.type,
+                value = _ref12.value;
+              var renderer = _this2._rendererInterfaces[rendererID];
+              if (renderer == null) {
+                console.warn("Invalid renderer id \"".concat(rendererID, "\" for element \"").concat(id, "\""));
+              } else {
+                renderer.overrideValueAtPath(type, id, hookID, path, value);
+              }
+            });
+            agent_defineProperty(_this2, "overrideContext", function (_ref13) {
+              var id = _ref13.id,
+                path = _ref13.path,
+                rendererID = _ref13.rendererID,
+                wasForwarded = _ref13.wasForwarded,
+                value = _ref13.value;
+
+              // Don't forward a message that's already been forwarded by the front-end Bridge.
+              // We only need to process the override command once!
+              if (!wasForwarded) {
+                _this2.overrideValueAtPath({
+                  id: id,
+                  path: path,
+                  rendererID: rendererID,
+                  type: 'context',
+                  value: value
+                });
+              }
+            });
+            agent_defineProperty(_this2, "overrideHookState", function (_ref14) {
+              var id = _ref14.id,
+                hookID = _ref14.hookID,
+                path = _ref14.path,
+                rendererID = _ref14.rendererID,
+                wasForwarded = _ref14.wasForwarded,
+                value = _ref14.value;
+
+              // Don't forward a message that's already been forwarded by the front-end Bridge.
+              // We only need to process the override command once!
+              if (!wasForwarded) {
+                _this2.overrideValueAtPath({
+                  id: id,
+                  path: path,
+                  rendererID: rendererID,
+                  type: 'hooks',
+                  value: value
+                });
+              }
+            });
+            agent_defineProperty(_this2, "overrideProps", function (_ref15) {
+              var id = _ref15.id,
+                path = _ref15.path,
+                rendererID = _ref15.rendererID,
+                wasForwarded = _ref15.wasForwarded,
+                value = _ref15.value;
+
+              // Don't forward a message that's already been forwarded by the front-end Bridge.
+              // We only need to process the override command once!
+              if (!wasForwarded) {
+                _this2.overrideValueAtPath({
+                  id: id,
+                  path: path,
+                  rendererID: rendererID,
+                  type: 'props',
+                  value: value
+                });
+              }
+            });
+            agent_defineProperty(_this2, "overrideState", function (_ref16) {
+              var id = _ref16.id,
+                path = _ref16.path,
+                rendererID = _ref16.rendererID,
+                wasForwarded = _ref16.wasForwarded,
+                value = _ref16.value;
+
+              // Don't forward a message that's already been forwarded by the front-end Bridge.
+              // We only need to process the override command once!
+              if (!wasForwarded) {
+                _this2.overrideValueAtPath({
+                  id: id,
+                  path: path,
+                  rendererID: rendererID,
+                  type: 'state',
+                  value: value
+                });
+              }
+            });
+            agent_defineProperty(_this2, "onReloadAndProfileSupportedByHost", function () {
+              _this2._bridge.send('isReloadAndProfileSupportedByBackend', true);
+            });
+            agent_defineProperty(_this2, "reloadAndProfile", function (_ref17) {
+              var recordChangeDescriptions = _ref17.recordChangeDescriptions,
+                recordTimeline = _ref17.recordTimeline;
+              if (typeof _this2._onReloadAndProfile === 'function') {
+                _this2._onReloadAndProfile(recordChangeDescriptions, recordTimeline);
+              } // This code path should only be hit if the shell has explicitly told the Store that it supports profiling.
+              // In that case, the shell must also listen for this specific message to know when it needs to reload the app.
+              // The agent can't do this in a way that is renderer agnostic.
+
+              _this2._bridge.send('reloadAppForProfiling');
+            });
+            agent_defineProperty(_this2, "renamePath", function (_ref18) {
+              var hookID = _ref18.hookID,
+                id = _ref18.id,
+                newPath = _ref18.newPath,
+                oldPath = _ref18.oldPath,
+                rendererID = _ref18.rendererID,
+                type = _ref18.type;
+              var renderer = _this2._rendererInterfaces[rendererID];
+              if (renderer == null) {
+                console.warn("Invalid renderer id \"".concat(rendererID, "\" for element \"").concat(id, "\""));
+              } else {
+                renderer.renamePath(type, id, hookID, oldPath, newPath);
+              }
+            });
+            agent_defineProperty(_this2, "setTraceUpdatesEnabled", function (traceUpdatesEnabled) {
+              _this2._traceUpdatesEnabled = traceUpdatesEnabled;
+              toggleEnabled(traceUpdatesEnabled);
+              for (var rendererID in _this2._rendererInterfaces) {
+                var renderer = _this2._rendererInterfaces[rendererID];
+                renderer.setTraceUpdatesEnabled(traceUpdatesEnabled);
+              }
+            });
+            agent_defineProperty(_this2, "syncSelectionFromBuiltinElementsPanel", function () {
+              var target = window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$0;
+              if (target == null) {
+                return;
+              }
+              _this2.selectNode(target);
+            });
+            agent_defineProperty(_this2, "shutdown", function () {
+              // Clean up the overlay if visible, and associated events.
+              _this2.emit('shutdown');
+              _this2._bridge.removeAllListeners();
+              _this2.removeAllListeners();
+            });
+            agent_defineProperty(_this2, "startProfiling", function (_ref19) {
+              var recordChangeDescriptions = _ref19.recordChangeDescriptions,
+                recordTimeline = _ref19.recordTimeline;
+              _this2._isProfiling = true;
+              for (var rendererID in _this2._rendererInterfaces) {
+                var renderer = _this2._rendererInterfaces[rendererID];
+                renderer.startProfiling(recordChangeDescriptions, recordTimeline);
+              }
+              _this2._bridge.send('profilingStatus', _this2._isProfiling);
+            });
+            agent_defineProperty(_this2, "stopProfiling", function () {
+              _this2._isProfiling = false;
+              for (var rendererID in _this2._rendererInterfaces) {
+                var renderer = _this2._rendererInterfaces[rendererID];
+                renderer.stopProfiling();
+              }
+              _this2._bridge.send('profilingStatus', _this2._isProfiling);
+            });
+            agent_defineProperty(_this2, "stopInspectingNative", function (selected) {
+              _this2._bridge.send('stopInspectingHost', selected);
+            });
+            agent_defineProperty(_this2, "storeAsGlobal", function (_ref20) {
+              var count = _ref20.count,
+                id = _ref20.id,
+                path = _ref20.path,
+                rendererID = _ref20.rendererID;
+              var renderer = _this2._rendererInterfaces[rendererID];
+              if (renderer == null) {
+                console.warn("Invalid renderer id \"".concat(rendererID, "\" for element \"").concat(id, "\""));
+              } else {
+                renderer.storeAsGlobal(id, path, count);
+              }
+            });
+            agent_defineProperty(_this2, "updateHookSettings", function (settings) {
+              // Propagate the settings, so Backend can subscribe to it and modify hook
+              _this2.emit('updateHookSettings', settings);
+            });
+            agent_defineProperty(_this2, "getHookSettings", function () {
+              _this2.emit('getHookSettings');
+            });
+            agent_defineProperty(_this2, "onHookSettings", function (settings) {
+              _this2._bridge.send('hookSettings', settings);
+            });
+            agent_defineProperty(_this2, "updateComponentFilters", function (componentFilters) {
+              for (var rendererIDString in _this2._rendererInterfaces) {
+                var rendererID = +rendererIDString;
+                var renderer = _this2._rendererInterfaces[rendererID];
+                if (_this2._lastSelectedRendererID === rendererID) {
+                  // Changing component filters will unmount and remount the DevTools tree.
+                  // Track the last selection's path so we can restore the selection.
+                  var path = renderer.getPathForElement(_this2._lastSelectedElementID);
+                  if (path !== null) {
+                    renderer.setTrackedPath(path);
+                    _this2._persistedSelection = {
+                      rendererID: rendererID,
+                      path: path
+                    };
+                  }
+                }
+                renderer.updateComponentFilters(componentFilters);
+              }
+            });
+            agent_defineProperty(_this2, "getEnvironmentNames", function () {
+              var accumulatedNames = null;
+              for (var rendererID in _this2._rendererInterfaces) {
+                var renderer = _this2._rendererInterfaces[+rendererID];
+                var names = renderer.getEnvironmentNames();
+                if (accumulatedNames === null) {
+                  accumulatedNames = names;
+                } else {
+                  for (var i = 0; i < names.length; i++) {
+                    if (accumulatedNames.indexOf(names[i]) === -1) {
+                      accumulatedNames.push(names[i]);
+                    }
+                  }
+                }
+              }
+              _this2._bridge.send('environmentNames', accumulatedNames || []);
+            });
+            agent_defineProperty(_this2, "onTraceUpdates", function (nodes) {
+              _this2.emit('traceUpdates', nodes);
+            });
+            agent_defineProperty(_this2, "onFastRefreshScheduled", function () {
+              if (__DEBUG__) {
+                debug('onFastRefreshScheduled');
+              }
+              _this2._bridge.send('fastRefreshScheduled');
+            });
+            agent_defineProperty(_this2, "onHookOperations", function (operations) {
+              if (__DEBUG__) {
+                debug('onHookOperations', "(".concat(operations.length, ") [").concat(operations.join(', '), "]"));
+              } // TODO:
+              // The chrome.runtime does not currently support transferables; it forces JSON serialization.
+              // See bug https://bugs.chromium.org/p/chromium/issues/detail?id=927134
+              //
+              // Regarding transferables, the postMessage doc states:
+              // If the ownership of an object is transferred, it becomes unusable (neutered)
+              // in the context it was sent from and becomes available only to the worker it was sent to.
+              //
+              // Even though Chrome is eventually JSON serializing the array buffer,
+              // using the transferable approach also sometimes causes it to throw:
+              //   DOMException: Failed to execute 'postMessage' on 'Window': ArrayBuffer at index 0 is already neutered.
+              //
+              // See bug https://github.com/bvaughn/react-devtools-experimental/issues/25
+              //
+              // The Store has a fallback in place that parses the message as JSON if the type isn't an array.
+              // For now the simplest fix seems to be to not transfer the array.
+              // This will negatively impact performance on Firefox so it's unfortunate,
+              // but until we're able to fix the Chrome error mentioned above, it seems necessary.
+              //
+              // this._bridge.send('operations', operations, [operations.buffer]);
+
+              _this2._bridge.send('operations', operations);
+              if (_this2._persistedSelection !== null) {
+                var rendererID = operations[0];
+                if (_this2._persistedSelection.rendererID === rendererID) {
+                  // Check if we can select a deeper match for the persisted selection.
+                  var renderer = _this2._rendererInterfaces[rendererID];
+                  if (renderer == null) {
+                    console.warn("Invalid renderer id \"".concat(rendererID, "\""));
+                  } else {
+                    var prevMatch = _this2._persistedSelectionMatch;
+                    var nextMatch = renderer.getBestMatchForTrackedPath();
+                    _this2._persistedSelectionMatch = nextMatch;
+                    var prevMatchID = prevMatch !== null ? prevMatch.id : null;
+                    var nextMatchID = nextMatch !== null ? nextMatch.id : null;
+                    if (prevMatchID !== nextMatchID) {
+                      if (nextMatchID !== null) {
+                        // We moved forward, unlocking a deeper node.
+                        _this2._bridge.send('selectElement', nextMatchID);
+                      }
+                    }
+                    if (nextMatch !== null && nextMatch.isFullMatch) {
+                      // We've just unlocked the innermost selected node.
+                      // There's no point tracking it further.
+                      _this2._persistedSelection = null;
+                      _this2._persistedSelectionMatch = null;
+                      renderer.setTrackedPath(null);
+                    }
+                  }
+                }
+              }
+            });
+            agent_defineProperty(_this2, "getIfHasUnsupportedRendererVersion", function () {
+              _this2.emit('getIfHasUnsupportedRendererVersion');
+            });
+            agent_defineProperty(_this2, "_persistSelectionTimerScheduled", false);
+            agent_defineProperty(_this2, "_lastSelectedRendererID", -1);
+            agent_defineProperty(_this2, "_lastSelectedElementID", -1);
+            agent_defineProperty(_this2, "_persistSelection", function () {
+              _this2._persistSelectionTimerScheduled = false;
+              var rendererID = _this2._lastSelectedRendererID;
+              var id = _this2._lastSelectedElementID; // This is throttled, so both renderer and selected ID
+              // might not be available by the time we read them.
+              // This is why we need the defensive checks here.
+
+              var renderer = _this2._rendererInterfaces[rendererID];
+              var path = renderer != null ? renderer.getPathForElement(id) : null;
+              if (path !== null) {
+                storage_sessionStorageSetItem(SESSION_STORAGE_LAST_SELECTION_KEY, JSON.stringify({
+                  rendererID: rendererID,
+                  path: path
+                }));
+              } else {
+                storage_sessionStorageRemoveItem(SESSION_STORAGE_LAST_SELECTION_KEY);
+              }
+            });
+            _this2._isProfiling = isProfiling;
+            _this2._onReloadAndProfile = onReloadAndProfile;
+            var persistedSelectionString = storage_sessionStorageGetItem(SESSION_STORAGE_LAST_SELECTION_KEY);
+            if (persistedSelectionString != null) {
+              _this2._persistedSelection = JSON.parse(persistedSelectionString);
+            }
+            _this2._bridge = bridge;
+            bridge.addListener('clearErrorsAndWarnings', _this2.clearErrorsAndWarnings);
+            bridge.addListener('clearErrorsForElementID', _this2.clearErrorsForElementID);
+            bridge.addListener('clearWarningsForElementID', _this2.clearWarningsForElementID);
+            bridge.addListener('copyElementPath', _this2.copyElementPath);
+            bridge.addListener('deletePath', _this2.deletePath);
+            bridge.addListener('getBackendVersion', _this2.getBackendVersion);
+            bridge.addListener('getBridgeProtocol', _this2.getBridgeProtocol);
+            bridge.addListener('getProfilingData', _this2.getProfilingData);
+            bridge.addListener('getProfilingStatus', _this2.getProfilingStatus);
+            bridge.addListener('getOwnersList', _this2.getOwnersList);
+            bridge.addListener('inspectElement', _this2.inspectElement);
+            bridge.addListener('logElementToConsole', _this2.logElementToConsole);
+            bridge.addListener('overrideError', _this2.overrideError);
+            bridge.addListener('overrideSuspense', _this2.overrideSuspense);
+            bridge.addListener('overrideValueAtPath', _this2.overrideValueAtPath);
+            bridge.addListener('reloadAndProfile', _this2.reloadAndProfile);
+            bridge.addListener('renamePath', _this2.renamePath);
+            bridge.addListener('setTraceUpdatesEnabled', _this2.setTraceUpdatesEnabled);
+            bridge.addListener('startProfiling', _this2.startProfiling);
+            bridge.addListener('stopProfiling', _this2.stopProfiling);
+            bridge.addListener('storeAsGlobal', _this2.storeAsGlobal);
+            bridge.addListener('syncSelectionFromBuiltinElementsPanel', _this2.syncSelectionFromBuiltinElementsPanel);
+            bridge.addListener('shutdown', _this2.shutdown);
+            bridge.addListener('updateHookSettings', _this2.updateHookSettings);
+            bridge.addListener('getHookSettings', _this2.getHookSettings);
+            bridge.addListener('updateComponentFilters', _this2.updateComponentFilters);
+            bridge.addListener('getEnvironmentNames', _this2.getEnvironmentNames);
+            bridge.addListener('getIfHasUnsupportedRendererVersion', _this2.getIfHasUnsupportedRendererVersion); // Temporarily support older standalone front-ends sending commands to newer embedded backends.
+            // We do this because React Native embeds the React DevTools backend,
+            // but cannot control which version of the frontend users use.
+
+            bridge.addListener('overrideContext', _this2.overrideContext);
+            bridge.addListener('overrideHookState', _this2.overrideHookState);
+            bridge.addListener('overrideProps', _this2.overrideProps);
+            bridge.addListener('overrideState', _this2.overrideState);
+            setupHighlighter(bridge, _this2);
+            TraceUpdates_initialize(_this2); // By this time, Store should already be initialized and intercept events
+
+            bridge.send('backendInitialized');
+            if (_this2._isProfiling) {
+              bridge.send('profilingStatus', true);
+            }
+            return _this2;
+          }
+          agent_inherits(Agent, _EventEmitter);
+          return agent_createClass(Agent, [{
+            key: "rendererInterfaces",
+            get: function get() {
+              return this._rendererInterfaces;
+            }
+          }, {
+            key: "getInstanceAndStyle",
+            value: function getInstanceAndStyle(_ref21) {
+              var id = _ref21.id,
+                rendererID = _ref21.rendererID;
+              var renderer = this._rendererInterfaces[rendererID];
+              if (renderer == null) {
+                console.warn("Invalid renderer id \"".concat(rendererID, "\""));
+                return null;
+              }
+              return renderer.getInstanceAndStyle(id);
+            }
+          }, {
+            key: "getIDForHostInstance",
+            value: function getIDForHostInstance(target) {
+              if (isReactNativeEnvironment() || typeof target.nodeType !== 'number') {
+                // In React Native or non-DOM we simply pick any renderer that has a match.
+                for (var rendererID in this._rendererInterfaces) {
+                  var renderer = this._rendererInterfaces[rendererID];
+                  try {
+                    var match = renderer.getElementIDForHostInstance(target);
+                    if (match != null) {
+                      return match;
+                    }
+                  } catch (error) {// Some old React versions might throw if they can't find a match.
+                    // If so we should ignore it...
+                  }
+                }
+                return null;
+              } else {
+                // In the DOM we use a smarter mechanism to find the deepest a DOM node
+                // that is registered if there isn't an exact match.
+                var bestMatch = null;
+                var bestRenderer = null; // Find the nearest ancestor which is mounted by a React.
+
+                for (var _rendererID in this._rendererInterfaces) {
+                  var _renderer = this._rendererInterfaces[_rendererID];
+                  var nearestNode = _renderer.getNearestMountedDOMNode(target);
+                  if (nearestNode !== null) {
+                    if (nearestNode === target) {
+                      // Exact match we can exit early.
+                      bestMatch = nearestNode;
+                      bestRenderer = _renderer;
+                      break;
+                    }
+                    if (bestMatch === null || bestMatch.contains(nearestNode)) {
+                      // If this is the first match or the previous match contains the new match,
+                      // so the new match is a deeper and therefore better match.
+                      bestMatch = nearestNode;
+                      bestRenderer = _renderer;
+                    }
+                  }
+                }
+                if (bestRenderer != null && bestMatch != null) {
+                  try {
+                    return bestRenderer.getElementIDForHostInstance(bestMatch);
+                  } catch (error) {// Some old React versions might throw if they can't find a match.
+                    // If so we should ignore it...
+                  }
+                }
+                return null;
+              }
+            }
+          }, {
+            key: "getComponentNameForHostInstance",
+            value: function getComponentNameForHostInstance(target) {
+              // We duplicate this code from getIDForHostInstance to avoid an object allocation.
+              if (isReactNativeEnvironment() || typeof target.nodeType !== 'number') {
+                // In React Native or non-DOM we simply pick any renderer that has a match.
+                for (var rendererID in this._rendererInterfaces) {
+                  var renderer = this._rendererInterfaces[rendererID];
+                  try {
+                    var id = renderer.getElementIDForHostInstance(target);
+                    if (id) {
+                      return renderer.getDisplayNameForElementID(id);
+                    }
+                  } catch (error) {// Some old React versions might throw if they can't find a match.
+                    // If so we should ignore it...
+                  }
+                }
+                return null;
+              } else {
+                // In the DOM we use a smarter mechanism to find the deepest a DOM node
+                // that is registered if there isn't an exact match.
+                var bestMatch = null;
+                var bestRenderer = null; // Find the nearest ancestor which is mounted by a React.
+
+                for (var _rendererID2 in this._rendererInterfaces) {
+                  var _renderer2 = this._rendererInterfaces[_rendererID2];
+                  var nearestNode = _renderer2.getNearestMountedDOMNode(target);
+                  if (nearestNode !== null) {
+                    if (nearestNode === target) {
+                      // Exact match we can exit early.
+                      bestMatch = nearestNode;
+                      bestRenderer = _renderer2;
+                      break;
+                    }
+                    if (bestMatch === null || bestMatch.contains(nearestNode)) {
+                      // If this is the first match or the previous match contains the new match,
+                      // so the new match is a deeper and therefore better match.
+                      bestMatch = nearestNode;
+                      bestRenderer = _renderer2;
+                    }
+                  }
+                }
+                if (bestRenderer != null && bestMatch != null) {
+                  try {
+                    var _id = bestRenderer.getElementIDForHostInstance(bestMatch);
+                    if (_id) {
+                      return bestRenderer.getDisplayNameForElementID(_id);
+                    }
+                  } catch (error) {// Some old React versions might throw if they can't find a match.
+                    // If so we should ignore it...
+                  }
+                }
+                return null;
+              }
+            } // Temporarily support older standalone front-ends by forwarding the older message types
+            // to the new "overrideValueAtPath" command the backend is now listening to.
+            // Temporarily support older standalone front-ends by forwarding the older message types
+            // to the new "overrideValueAtPath" command the backend is now listening to.
+            // Temporarily support older standalone front-ends by forwarding the older message types
+            // to the new "overrideValueAtPath" command the backend is now listening to.
+            // Temporarily support older standalone front-ends by forwarding the older message types
+            // to the new "overrideValueAtPath" command the backend is now listening to.
+          }, {
+            key: "selectNode",
+            value: function selectNode(target) {
+              var id = this.getIDForHostInstance(target);
+              if (id !== null) {
+                this._bridge.send('selectElement', id);
+              }
+            }
+          }, {
+            key: "registerRendererInterface",
+            value: function registerRendererInterface(rendererID, rendererInterface) {
+              this._rendererInterfaces[rendererID] = rendererInterface;
+              rendererInterface.setTraceUpdatesEnabled(this._traceUpdatesEnabled); // When the renderer is attached, we need to tell it whether
+              // we remember the previous selection that we'd like to restore.
+              // It'll start tracking mounts for matches to the last selection path.
+
+              var selection = this._persistedSelection;
+              if (selection !== null && selection.rendererID === rendererID) {
+                rendererInterface.setTrackedPath(selection.path);
+              }
+            }
+          }, {
+            key: "onUnsupportedRenderer",
+            value: function onUnsupportedRenderer() {
+              this._bridge.send('unsupportedRendererVersion');
+            }
+          }]);
+        }(EventEmitter);
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/shared/DevToolsConsolePatching.js
+        function DevToolsConsolePatching_ownKeys(object, enumerableOnly) {
+          var keys = Object.keys(object);
+          if (Object.getOwnPropertySymbols) {
+            var symbols = Object.getOwnPropertySymbols(object);
+            if (enumerableOnly) symbols = symbols.filter(function (sym) {
+              return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+            keys.push.apply(keys, symbols);
+          }
+          return keys;
+        }
+        function DevToolsConsolePatching_objectSpread(target) {
+          for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i] != null ? arguments[i] : {};
+            if (i % 2) {
+              DevToolsConsolePatching_ownKeys(Object(source), true).forEach(function (key) {
+                DevToolsConsolePatching_defineProperty(target, key, source[key]);
+              });
+            } else if (Object.getOwnPropertyDescriptors) {
+              Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+            } else {
+              DevToolsConsolePatching_ownKeys(Object(source)).forEach(function (key) {
+                Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+              });
+            }
+          }
+          return target;
+        }
+        function DevToolsConsolePatching_defineProperty(obj, key, value) {
+          if (key in obj) {
+            Object.defineProperty(obj, key, {
+              value: value,
+              enumerable: true,
+              configurable: true,
+              writable: true
+            });
+          } else {
+            obj[key] = value;
+          }
+          return obj;
+        }
+
+        /**
+         * 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.
+         *
+         * 
+         */
+        // This is a DevTools fork of shared/ConsolePatchingDev.
+        // The shared console patching code is DEV-only.
+        // We can't use it since DevTools only ships production builds.
+        // Helpers to patch console.logs to avoid logging during side-effect free
+        // replaying on render function. This currently only patches the object
+        // lazily which won't cover if the log function was extracted eagerly.
+        // We could also eagerly patch the method.
+        var disabledDepth = 0;
+        var prevLog;
+        var prevInfo;
+        var prevWarn;
+        var prevError;
+        var prevGroup;
+        var prevGroupCollapsed;
+        var prevGroupEnd;
+        function disabledLog() {}
+        disabledLog.__reactDisabledLog = true;
+        function disableLogs() {
+          if (disabledDepth === 0) {
+            prevLog = console.log;
+            prevInfo = console.info;
+            prevWarn = console.warn;
+            prevError = console.error;
+            prevGroup = console.group;
+            prevGroupCollapsed = console.groupCollapsed;
+            prevGroupEnd = console.groupEnd; // https://github.com/facebook/react/issues/19099
+
+            var props = {
+              configurable: true,
+              enumerable: true,
+              value: disabledLog,
+              writable: true
+            }; // $FlowFixMe[cannot-write] Flow thinks console is immutable.
+
+            Object.defineProperties(console, {
+              info: props,
+              log: props,
+              warn: props,
+              error: props,
+              group: props,
+              groupCollapsed: props,
+              groupEnd: props
+            });
+            /* eslint-enable react-internal/no-production-logging */
+          }
+          disabledDepth++;
+        }
+        function reenableLogs() {
+          disabledDepth--;
+          if (disabledDepth === 0) {
+            var props = {
+              configurable: true,
+              enumerable: true,
+              writable: true
+            }; // $FlowFixMe[cannot-write] Flow thinks console is immutable.
+
+            Object.defineProperties(console, {
+              log: DevToolsConsolePatching_objectSpread(DevToolsConsolePatching_objectSpread({}, props), {}, {
+                value: prevLog
+              }),
+              info: DevToolsConsolePatching_objectSpread(DevToolsConsolePatching_objectSpread({}, props), {}, {
+                value: prevInfo
+              }),
+              warn: DevToolsConsolePatching_objectSpread(DevToolsConsolePatching_objectSpread({}, props), {}, {
+                value: prevWarn
+              }),
+              error: DevToolsConsolePatching_objectSpread(DevToolsConsolePatching_objectSpread({}, props), {}, {
+                value: prevError
+              }),
+              group: DevToolsConsolePatching_objectSpread(DevToolsConsolePatching_objectSpread({}, props), {}, {
+                value: prevGroup
+              }),
+              groupCollapsed: DevToolsConsolePatching_objectSpread(DevToolsConsolePatching_objectSpread({}, props), {}, {
+                value: prevGroupCollapsed
+              }),
+              groupEnd: DevToolsConsolePatching_objectSpread(DevToolsConsolePatching_objectSpread({}, props), {}, {
+                value: prevGroupEnd
+              })
+            });
+            /* eslint-enable react-internal/no-production-logging */
+          }
+          if (disabledDepth < 0) {
+            console.error('disabledDepth fell below zero. ' + 'This is a bug in React. Please file an issue.');
+          }
+        }
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/shared/DevToolsComponentStackFrame.js
+        function DevToolsComponentStackFrame_slicedToArray(arr, i) {
+          return DevToolsComponentStackFrame_arrayWithHoles(arr) || DevToolsComponentStackFrame_iterableToArrayLimit(arr, i) || DevToolsComponentStackFrame_unsupportedIterableToArray(arr, i) || DevToolsComponentStackFrame_nonIterableRest();
+        }
+        function DevToolsComponentStackFrame_nonIterableRest() {
+          throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+        }
+        function DevToolsComponentStackFrame_unsupportedIterableToArray(o, minLen) {
+          if (!o) return;
+          if (typeof o === "string") return DevToolsComponentStackFrame_arrayLikeToArray(o, minLen);
+          var n = Object.prototype.toString.call(o).slice(8, -1);
+          if (n === "Object" && o.constructor) n = o.constructor.name;
+          if (n === "Map" || n === "Set") return Array.from(o);
+          if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return DevToolsComponentStackFrame_arrayLikeToArray(o, minLen);
+        }
+        function DevToolsComponentStackFrame_arrayLikeToArray(arr, len) {
+          if (len == null || len > arr.length) len = arr.length;
+          for (var i = 0, arr2 = new Array(len); i < len; i++) {
+            arr2[i] = arr[i];
+          }
+          return arr2;
+        }
+        function DevToolsComponentStackFrame_iterableToArrayLimit(arr, i) {
+          if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
+          var _arr = [];
+          var _n = true;
+          var _d = false;
+          var _e = undefined;
+          try {
+            for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+              _arr.push(_s.value);
+              if (i && _arr.length === i) break;
+            }
+          } catch (err) {
+            _d = true;
+            _e = err;
+          } finally {
+            try {
+              if (!_n && _i["return"] != null) _i["return"]();
+            } finally {
+              if (_d) throw _e;
+            }
+          }
+          return _arr;
+        }
+        function DevToolsComponentStackFrame_arrayWithHoles(arr) {
+          if (Array.isArray(arr)) return arr;
+        }
+        function DevToolsComponentStackFrame_typeof(obj) {
+          "@babel/helpers - typeof";
+
+          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+            DevToolsComponentStackFrame_typeof = function _typeof(obj) {
+              return typeof obj;
+            };
+          } else {
+            DevToolsComponentStackFrame_typeof = function _typeof(obj) {
+              return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+            };
+          }
+          return DevToolsComponentStackFrame_typeof(obj);
+        }
+
+        /**
+         * 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.
+         *
+         * 
+         */
+        // This is a DevTools fork of ReactComponentStackFrame.
+        // This fork enables DevTools to use the same "native" component stack format,
+        // while still maintaining support for multiple renderer versions
+        // (which use different values for ReactTypeOfWork).
+        // The shared console patching code is DEV-only.
+        // We can't use it since DevTools only ships production builds.
+
+        var prefix;
+        function describeBuiltInComponentFrame(name) {
+          if (prefix === undefined) {
+            // Extract the VM specific prefix used by each line.
+            try {
+              throw Error();
+            } catch (x) {
+              var match = x.stack.trim().match(/\n( *(at )?)/);
+              prefix = match && match[1] || '';
+            }
+          }
+          var suffix = '';
+          if (true) {
+            suffix = ' (<anonymous>)';
+          } else {} // We use the prefix to ensure our stacks line up with native stack frames.
+          // We use a suffix to ensure it gets parsed natively.
+
+          return '\n' + prefix + name + suffix;
+        }
+        function describeDebugInfoFrame(name, env) {
+          return describeBuiltInComponentFrame(name + (env ? ' [' + env + ']' : ''));
+        }
+        var reentry = false;
+        var componentFrameCache;
+        if (false) {
+          var PossiblyWeakMap;
+        }
+        function describeNativeComponentFrame(fn, construct, currentDispatcherRef) {
+          // If something asked for a stack inside a fake render, it should get ignored.
+          if (!fn || reentry) {
+            return '';
+          }
+          if (false) {
+            var frame;
+          }
+          var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe[incompatible-type] It does accept undefined.
+
+          Error.prepareStackTrace = undefined;
+          reentry = true; // Override the dispatcher so effects scheduled by this shallow render are thrown away.
+          //
+          // Note that unlike the code this was forked from (in ReactComponentStackFrame)
+          // DevTools should override the dispatcher even when DevTools is compiled in production mode,
+          // because the app itself may be in development mode and log errors/warnings.
+
+          var previousDispatcher = currentDispatcherRef.H;
+          currentDispatcherRef.H = null;
+          disableLogs();
+          try {
+            // NOTE: keep in sync with the implementation in ReactComponentStackFrame
+
+            /**
+             * 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 DetermineComponentFrameRoot() {
+                var control;
+                try {
+                  // This should throw.
+                  if (construct) {
+                    // Something should be setting the props in the constructor.
+                    var Fake = function Fake() {
+                      throw Error();
+                    }; // $FlowFixMe[prop-missing]
+
+                    Object.defineProperty(Fake.prototype, 'props', {
+                      set: function set() {
+                        // 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 === "undefined" ? "undefined" : DevToolsComponentStackFrame_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
+
+                    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 () {});
+                    }
+                  }
+                } 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';
+            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 _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+              _RunInRootFrame$Deter2 = DevToolsComponentStackFrame_slicedToArray(_RunInRootFrame$Deter, 2),
+              sampleStack = _RunInRootFrame$Deter2[0],
+              controlStack = _RunInRootFrame$Deter2[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 = 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--) {
+                // 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.
+                        var _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;
+            currentDispatcherRef.H = previousDispatcher;
+            reenableLogs();
+          } // Fallback to just using the name if we couldn't make it throw.
+
+          var name = fn ? fn.displayName || fn.name : '';
+          var syntheticFrame = name ? describeBuiltInComponentFrame(name) : '';
+          if (false) {}
+          return syntheticFrame;
+        }
+        function describeClassComponentFrame(ctor, currentDispatcherRef) {
+          return describeNativeComponentFrame(ctor, true, currentDispatcherRef);
+        }
+        function describeFunctionComponentFrame(fn, currentDispatcherRef) {
+          return describeNativeComponentFrame(fn, false, currentDispatcherRef);
+        }
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/flight/DevToolsComponentInfoStack.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.
+         *
+         * 
+         */
+        // This is a DevTools fork of ReactComponentInfoStack.
+        // This fork enables DevTools to use the same "native" component stack format,
+        // while still maintaining support for multiple renderer versions
+        // (which use different values for ReactTypeOfWork).
+
+        function getOwnerStackByComponentInfoInDev(componentInfo) {
+          try {
+            var info = ''; // The owner stack of the current component will be where it was created, i.e. inside its owner.
+            // There's no actual name of the currently executing component. Instead, that is available
+            // on the regular stack that's currently executing. However, if there is no owner at all, then
+            // there's no stack frame so we add the name of the root component to the stack to know which
+            // component is currently executing.
+
+            if (!componentInfo.owner && typeof componentInfo.name === 'string') {
+              return describeBuiltInComponentFrame(componentInfo.name);
+            }
+            var owner = componentInfo;
+            while (owner) {
+              var ownerStack = owner.debugStack;
+              if (ownerStack != null) {
+                // Server Component
+                owner = owner.owner;
+                if (owner) {
+                  // TODO: Should we stash this somewhere for caching purposes?
+                  info += '\n' + formatOwnerStack(ownerStack);
+                }
+              } else {
+                break;
+              }
+            }
+            return info;
+          } catch (x) {
+            return '\nError generating stack: ' + x.message + '\n' + x.stack;
+          }
+        }
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/shared/DevToolsServerComponentLogs.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.
+         *
+         * 
+         */
+        // This keeps track of Server Component logs which may come from.
+        // This is in a shared module because Server Component logs don't come from a specific renderer
+        // but can become associated with a Virtual Instance of any renderer.
+        // This keeps it around as long as the ComponentInfo is alive which
+        // lets the Fiber get reparented/remounted and still observe the previous errors/warnings.
+        // Unless we explicitly clear the logs from a Fiber.
+        var componentInfoToComponentLogsMap = new WeakMap();
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/flight/renderer.js
+        function renderer_toConsumableArray(arr) {
+          return renderer_arrayWithoutHoles(arr) || renderer_iterableToArray(arr) || renderer_unsupportedIterableToArray(arr) || renderer_nonIterableSpread();
+        }
+        function renderer_nonIterableSpread() {
+          throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+        }
+        function renderer_unsupportedIterableToArray(o, minLen) {
+          if (!o) return;
+          if (typeof o === "string") return renderer_arrayLikeToArray(o, minLen);
+          var n = Object.prototype.toString.call(o).slice(8, -1);
+          if (n === "Object" && o.constructor) n = o.constructor.name;
+          if (n === "Map" || n === "Set") return Array.from(o);
+          if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return renderer_arrayLikeToArray(o, minLen);
+        }
+        function renderer_iterableToArray(iter) {
+          if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
+        }
+        function renderer_arrayWithoutHoles(arr) {
+          if (Array.isArray(arr)) return renderer_arrayLikeToArray(arr);
+        }
+        function renderer_arrayLikeToArray(arr, len) {
+          if (len == null || len > arr.length) len = arr.length;
+          for (var i = 0, arr2 = new Array(len); i < len; i++) {
+            arr2[i] = arr[i];
+          }
+          return arr2;
+        }
+
+        /**
+         * 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.
+         *
+         * 
+         */
+
+        function supportsConsoleTasks(componentInfo) {
+          // If this ReactComponentInfo supports native console.createTask then we are already running
+          // inside a native async stack trace if it's active - meaning the DevTools is open.
+          // Ideally we'd detect if this task was created while the DevTools was open or not.
+          return !!componentInfo.debugTask;
+        }
+        function attach(hook, rendererID, renderer, global) {
+          var getCurrentComponentInfo = renderer.getCurrentComponentInfo;
+          function getComponentStack(topFrame) {
+            if (getCurrentComponentInfo === undefined) {
+              // Expected this to be part of the renderer. Ignore.
+              return null;
+            }
+            var current = getCurrentComponentInfo();
+            if (current === null) {
+              // Outside of our render scope.
+              return null;
+            }
+            if (supportsConsoleTasks(current)) {
+              // This will be handled natively by console.createTask. No need for
+              // DevTools to add it.
+              return null;
+            }
+            var enableOwnerStacks = current.debugStack != null;
+            var componentStack = '';
+            if (enableOwnerStacks) {
+              // Prefix the owner stack with the current stack. I.e. what called
+              // console.error. While this will also be part of the native stack,
+              // it is hidden and not presented alongside this argument so we print
+              // them all together.
+              var topStackFrames = formatOwnerStack(topFrame);
+              if (topStackFrames) {
+                componentStack += '\n' + topStackFrames;
+              }
+              componentStack += getOwnerStackByComponentInfoInDev(current);
+            }
+            return {
+              enableOwnerStacks: enableOwnerStacks,
+              componentStack: componentStack
+            };
+          } // Called when an error or warning is logged during render, commit, or passive (including unmount functions).
+
+          function onErrorOrWarning(type, args) {
+            if (getCurrentComponentInfo === undefined) {
+              // Expected this to be part of the renderer. Ignore.
+              return;
+            }
+            var componentInfo = getCurrentComponentInfo();
+            if (componentInfo === null) {
+              // Outside of our render scope.
+              return;
+            }
+            if (args.length > 3 && typeof args[0] === 'string' && args[0].startsWith('%c%s%c ') && typeof args[1] === 'string' && typeof args[2] === 'string' && typeof args[3] === 'string') {
+              // This looks like the badge we prefixed to the log. Our UI doesn't support formatted logs.
+              // We remove the formatting. If the environment of the log is the same as the environment of
+              // the component (the common case) we remove the badge completely otherwise leave it plain
+              var format = args[0].slice(7);
+              var env = args[2].trim();
+              args = args.slice(4);
+              if (env !== componentInfo.env) {
+                args.unshift('[' + env + '] ' + format);
+              } else {
+                args.unshift(format);
+              }
+            } // We can't really use this message as a unique key, since we can't distinguish
+            // different objects in this implementation. We have to delegate displaying of the objects
+            // to the environment, the browser console, for example, so this is why this should be kept
+            // as an array of arguments, instead of the plain string.
+            // [Warning: %o, {...}] and [Warning: %o, {...}] will be considered as the same message,
+            // even if objects are different
+
+            var message = formatConsoleArgumentsToSingleString.apply(void 0, renderer_toConsumableArray(args)); // Track the warning/error for later.
+
+            var componentLogsEntry = componentInfoToComponentLogsMap.get(componentInfo);
+            if (componentLogsEntry === undefined) {
+              componentLogsEntry = {
+                errors: new Map(),
+                errorsCount: 0,
+                warnings: new Map(),
+                warningsCount: 0
+              };
+              componentInfoToComponentLogsMap.set(componentInfo, componentLogsEntry);
+            }
+            var messageMap = type === 'error' ? componentLogsEntry.errors : componentLogsEntry.warnings;
+            var count = messageMap.get(message) || 0;
+            messageMap.set(message, count + 1);
+            if (type === 'error') {
+              componentLogsEntry.errorsCount++;
+            } else {
+              componentLogsEntry.warningsCount++;
+            } // The changes will be flushed later when we commit this tree to Fiber.
+          }
+          return {
+            cleanup: function cleanup() {},
+            clearErrorsAndWarnings: function clearErrorsAndWarnings() {},
+            clearErrorsForElementID: function clearErrorsForElementID() {},
+            clearWarningsForElementID: function clearWarningsForElementID() {},
+            getSerializedElementValueByPath: function getSerializedElementValueByPath() {},
+            deletePath: function deletePath() {},
+            findHostInstancesForElementID: function findHostInstancesForElementID() {
+              return null;
+            },
+            flushInitialOperations: function flushInitialOperations() {},
+            getBestMatchForTrackedPath: function getBestMatchForTrackedPath() {
+              return null;
+            },
+            getComponentStack: getComponentStack,
+            getDisplayNameForElementID: function getDisplayNameForElementID() {
+              return null;
+            },
+            getNearestMountedDOMNode: function getNearestMountedDOMNode() {
+              return null;
+            },
+            getElementIDForHostInstance: function getElementIDForHostInstance() {
+              return null;
+            },
+            getInstanceAndStyle: function getInstanceAndStyle() {
+              return {
+                instance: null,
+                style: null
+              };
+            },
+            getOwnersList: function getOwnersList() {
+              return null;
+            },
+            getPathForElement: function getPathForElement() {
+              return null;
+            },
+            getProfilingData: function getProfilingData() {
+              throw new Error('getProfilingData not supported by this renderer');
+            },
+            handleCommitFiberRoot: function handleCommitFiberRoot() {},
+            handleCommitFiberUnmount: function handleCommitFiberUnmount() {},
+            handlePostCommitFiberRoot: function handlePostCommitFiberRoot() {},
+            hasElementWithId: function hasElementWithId() {
+              return false;
+            },
+            inspectElement: function inspectElement(requestID, id, path) {
+              return {
+                id: id,
+                responseID: requestID,
+                type: 'not-found'
+              };
+            },
+            logElementToConsole: function logElementToConsole() {},
+            getElementAttributeByPath: function getElementAttributeByPath() {},
+            getElementSourceFunctionById: function getElementSourceFunctionById() {},
+            onErrorOrWarning: onErrorOrWarning,
+            overrideError: function overrideError() {},
+            overrideSuspense: function overrideSuspense() {},
+            overrideValueAtPath: function overrideValueAtPath() {},
+            renamePath: function renamePath() {},
+            renderer: renderer,
+            setTraceUpdatesEnabled: function setTraceUpdatesEnabled() {},
+            setTrackedPath: function setTrackedPath() {},
+            startProfiling: function startProfiling() {},
+            stopProfiling: function stopProfiling() {},
+            storeAsGlobal: function storeAsGlobal() {},
+            updateComponentFilters: function updateComponentFilters() {},
+            getEnvironmentNames: function getEnvironmentNames() {
+              return [];
+            }
+          };
+        }
+        // EXTERNAL MODULE: ../../build/oss-experimental/react-debug-tools/index.js
+        var react_debug_tools = __webpack_require__(987);
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/shared/ReactSymbols.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.
+         *
+         * 
+         */
+        // This list should be kept updated to reflect additions to 'shared/ReactSymbols'.
+        // DevTools can't import symbols from 'shared/ReactSymbols' directly for two reasons:
+        // 1. DevTools requires symbols which may have been deleted in more recent versions (e.g. concurrent mode)
+        // 2. DevTools must support both Symbol and numeric forms of each symbol;
+        //    Since e.g. standalone DevTools runs in a separate process, it can't rely on its own ES capabilities.
+        var CONCURRENT_MODE_NUMBER = 0xeacf;
+        var CONCURRENT_MODE_SYMBOL_STRING = 'Symbol(react.concurrent_mode)';
+        var CONTEXT_NUMBER = 0xeace;
+        var CONTEXT_SYMBOL_STRING = 'Symbol(react.context)';
+        var SERVER_CONTEXT_SYMBOL_STRING = 'Symbol(react.server_context)';
+        var DEPRECATED_ASYNC_MODE_SYMBOL_STRING = 'Symbol(react.async_mode)';
+        var ELEMENT_SYMBOL_STRING = 'Symbol(react.transitional.element)';
+        var LEGACY_ELEMENT_NUMBER = 0xeac7;
+        var LEGACY_ELEMENT_SYMBOL_STRING = 'Symbol(react.element)';
+        var DEBUG_TRACING_MODE_NUMBER = 0xeae1;
+        var DEBUG_TRACING_MODE_SYMBOL_STRING = 'Symbol(react.debug_trace_mode)';
+        var FORWARD_REF_NUMBER = 0xead0;
+        var FORWARD_REF_SYMBOL_STRING = 'Symbol(react.forward_ref)';
+        var FRAGMENT_NUMBER = 0xeacb;
+        var FRAGMENT_SYMBOL_STRING = 'Symbol(react.fragment)';
+        var LAZY_NUMBER = 0xead4;
+        var LAZY_SYMBOL_STRING = 'Symbol(react.lazy)';
+        var MEMO_NUMBER = 0xead3;
+        var MEMO_SYMBOL_STRING = 'Symbol(react.memo)';
+        var PORTAL_NUMBER = 0xeaca;
+        var PORTAL_SYMBOL_STRING = 'Symbol(react.portal)';
+        var PROFILER_NUMBER = 0xead2;
+        var PROFILER_SYMBOL_STRING = 'Symbol(react.profiler)';
+        var PROVIDER_NUMBER = 0xeacd;
+        var PROVIDER_SYMBOL_STRING = 'Symbol(react.provider)';
+        var CONSUMER_SYMBOL_STRING = 'Symbol(react.consumer)';
+        var SCOPE_NUMBER = 0xead7;
+        var SCOPE_SYMBOL_STRING = 'Symbol(react.scope)';
+        var STRICT_MODE_NUMBER = 0xeacc;
+        var STRICT_MODE_SYMBOL_STRING = 'Symbol(react.strict_mode)';
+        var SUSPENSE_NUMBER = 0xead1;
+        var SUSPENSE_SYMBOL_STRING = 'Symbol(react.suspense)';
+        var SUSPENSE_LIST_NUMBER = 0xead8;
+        var SUSPENSE_LIST_SYMBOL_STRING = 'Symbol(react.suspense_list)';
+        var SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED_SYMBOL_STRING = 'Symbol(react.server_context.defaultValue)';
+        var ReactSymbols_REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel');
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/config/DevToolsFeatureFlags.core-oss.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.
+         *
+         * 
+         */
+
+        /************************************************************************
+         * This file is forked between different DevTools implementations.
+         * It should never be imported directly!
+         * It should always be imported from "react-devtools-feature-flags".
+         ************************************************************************/
+        var enableLogger = false;
+        var enableStyleXFeatures = false;
+        var isInternalFacebookBuild = false;
+        /************************************************************************
+         * Do not edit the code below.
+         * It ensures this fork exports the same types as the default flags file.
+         ************************************************************************/
+
+        // Flow magic to verify the exports of this file match the original version.
+        null;
+        ; // CONCATENATED MODULE: ../shared/objectIs.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.
+         *
+         * 
+         */
+
+        /**
+         * inlined Object.is polyfill to avoid requiring consumers ship their own
+         * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+         */
+        function is(x, y) {
+          return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+          ;
+        }
+        var objectIs =
+        // $FlowFixMe[method-unbinding]
+        typeof Object.is === 'function' ? Object.is : is;
+        /* harmony default export */
+        var shared_objectIs = objectIs;
+        ; // CONCATENATED MODULE: ../shared/hasOwnProperty.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.
+         *
+         * 
+         */
+        // $FlowFixMe[method-unbinding]
+        var hasOwnProperty_hasOwnProperty = Object.prototype.hasOwnProperty;
+        /* harmony default export */
+        var shared_hasOwnProperty = hasOwnProperty_hasOwnProperty;
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/fiber/DevToolsFiberComponentStack.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.
+         *
+         * 
+         */
+        // This is a DevTools fork of ReactFiberComponentStack.
+        // This fork enables DevTools to use the same "native" component stack format,
+        // while still maintaining support for multiple renderer versions
+        // (which use different values for ReactTypeOfWork).
+
+        function describeFiber(workTagMap, workInProgress, currentDispatcherRef) {
+          var HostHoistable = workTagMap.HostHoistable,
+            HostSingleton = workTagMap.HostSingleton,
+            HostComponent = workTagMap.HostComponent,
+            LazyComponent = workTagMap.LazyComponent,
+            SuspenseComponent = workTagMap.SuspenseComponent,
+            SuspenseListComponent = workTagMap.SuspenseListComponent,
+            FunctionComponent = workTagMap.FunctionComponent,
+            IndeterminateComponent = workTagMap.IndeterminateComponent,
+            SimpleMemoComponent = workTagMap.SimpleMemoComponent,
+            ForwardRef = workTagMap.ForwardRef,
+            ClassComponent = workTagMap.ClassComponent,
+            ViewTransitionComponent = workTagMap.ViewTransitionComponent,
+            ActivityComponent = workTagMap.ActivityComponent;
+          switch (workInProgress.tag) {
+            case HostHoistable:
+            case HostSingleton:
+            case HostComponent:
+              return describeBuiltInComponentFrame(workInProgress.type);
+            case LazyComponent:
+              // TODO: When we support Thenables as component types we should rename this.
+              return describeBuiltInComponentFrame('Lazy');
+            case SuspenseComponent:
+              return describeBuiltInComponentFrame('Suspense');
+            case SuspenseListComponent:
+              return describeBuiltInComponentFrame('SuspenseList');
+            case ViewTransitionComponent:
+              return describeBuiltInComponentFrame('ViewTransition');
+            case ActivityComponent:
+              return describeBuiltInComponentFrame('Activity');
+            case FunctionComponent:
+            case IndeterminateComponent:
+            case SimpleMemoComponent:
+              return describeFunctionComponentFrame(workInProgress.type, currentDispatcherRef);
+            case ForwardRef:
+              return describeFunctionComponentFrame(workInProgress.type.render, currentDispatcherRef);
+            case ClassComponent:
+              return describeClassComponentFrame(workInProgress.type, currentDispatcherRef);
+            default:
+              return '';
+          }
+        }
+        function getStackByFiberInDevAndProd(workTagMap, workInProgress, currentDispatcherRef) {
+          try {
+            var info = '';
+            var node = workInProgress;
+            do {
+              info += describeFiber(workTagMap, node, currentDispatcherRef); // Add any Server Component stack frames in reverse order.
+
+              var debugInfo = node._debugInfo;
+              if (debugInfo) {
+                for (var i = debugInfo.length - 1; i >= 0; i--) {
+                  var entry = debugInfo[i];
+                  if (typeof entry.name === 'string') {
+                    info += describeDebugInfoFrame(entry.name, entry.env);
+                  }
+                }
+              } // $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 getSourceLocationByFiber(workTagMap, fiber, currentDispatcherRef) {
+          // This is like getStackByFiberInDevAndProd but just the first stack frame.
+          try {
+            var info = describeFiber(workTagMap, fiber, currentDispatcherRef);
+            if (info !== '') {
+              return info.slice(1); // skip the leading newline
+            }
+          } catch (x) {
+            console.error(x);
+          }
+          return null;
+        }
+        function DevToolsFiberComponentStack_supportsConsoleTasks(fiber) {
+          // If this Fiber supports native console.createTask then we are already running
+          // inside a native async stack trace if it's active - meaning the DevTools is open.
+          // Ideally we'd detect if this task was created while the DevTools was open or not.
+          return !!fiber._debugTask;
+        }
+        function supportsOwnerStacks(fiber) {
+          // If this Fiber supports owner stacks then it'll have the _debugStack field.
+          // It might be null but that still means we should use the owner stack logic.
+          return fiber._debugStack !== undefined;
+        }
+        function getOwnerStackByFiberInDev(workTagMap, workInProgress, currentDispatcherRef) {
+          var HostHoistable = workTagMap.HostHoistable,
+            HostSingleton = workTagMap.HostSingleton,
+            HostText = workTagMap.HostText,
+            HostComponent = workTagMap.HostComponent,
+            SuspenseComponent = workTagMap.SuspenseComponent,
+            SuspenseListComponent = workTagMap.SuspenseListComponent,
+            ViewTransitionComponent = workTagMap.ViewTransitionComponent,
+            ActivityComponent = workTagMap.ActivityComponent;
+          try {
+            var info = '';
+            if (workInProgress.tag === HostText) {
+              // Text nodes never have an owner/stack because they're not created through JSX.
+              // We use the parent since text nodes are always created through a host parent.
+              workInProgress = workInProgress.return;
+            } // The owner stack of the current fiber will be where it was created, i.e. inside its owner.
+            // There's no actual name of the currently executing component. Instead, that is available
+            // on the regular stack that's currently executing. However, for built-ins there is no such
+            // named stack frame and it would be ignored as being internal anyway. Therefore we add
+            // add one extra frame just to describe the "current" built-in component by name.
+
+            switch (workInProgress.tag) {
+              case HostHoistable:
+              case HostSingleton:
+              case HostComponent:
+                info += describeBuiltInComponentFrame(workInProgress.type);
+                break;
+              case SuspenseComponent:
+                info += describeBuiltInComponentFrame('Suspense');
+                break;
+              case SuspenseListComponent:
+                info += describeBuiltInComponentFrame('SuspenseList');
+                break;
+              case ViewTransitionComponent:
+                info += describeBuiltInComponentFrame('ViewTransition');
+                break;
+              case ActivityComponent:
+                info += describeBuiltInComponentFrame('Activity');
+                break;
+            }
+            var owner = workInProgress;
+            while (owner) {
+              if (typeof owner.tag === 'number') {
+                var fiber = owner;
+                owner = fiber._debugOwner;
+                var debugStack = fiber._debugStack; // If we don't actually print the stack if there is no owner of this JSX element.
+                // In a real app it's typically not useful since the root app is always controlled
+                // by the framework. These also tend to have noisy stacks because they're not rooted
+                // in a React render but in some imperative bootstrapping code. It could be useful
+                // if the element was created in module scope. E.g. hoisted. We could add a a single
+                // stack frame for context for example but it doesn't say much if that's a wrapper.
+
+                if (owner && debugStack) {
+                  if (typeof debugStack !== 'string') {
+                    debugStack = formatOwnerStack(debugStack);
+                  }
+                  if (debugStack !== '') {
+                    info += '\n' + debugStack;
+                  }
+                }
+              } else if (owner.debugStack != null) {
+                // Server Component
+                var ownerStack = owner.debugStack;
+                owner = owner.owner;
+                if (owner && ownerStack) {
+                  info += '\n' + formatOwnerStack(ownerStack);
+                }
+              } else {
+                break;
+              }
+            }
+            return info;
+          } catch (x) {
+            return '\nError generating stack: ' + x.message + '\n' + x.stack;
+          }
+        }
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/StyleX/utils.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.
+         *
+         * 
+         */
+
+        var cachedStyleNameToValueMap = new Map();
+        function getStyleXData(data) {
+          var sources = new Set();
+          var resolvedStyles = {};
+          crawlData(data, sources, resolvedStyles);
+          return {
+            sources: Array.from(sources).sort(),
+            resolvedStyles: resolvedStyles
+          };
+        }
+        function crawlData(data, sources, resolvedStyles) {
+          if (data == null) {
+            return;
+          }
+          if (src_isArray(data)) {
+            data.forEach(function (entry) {
+              if (entry == null) {
+                return;
+              }
+              if (src_isArray(entry)) {
+                crawlData(entry, sources, resolvedStyles);
+              } else {
+                crawlObjectProperties(entry, sources, resolvedStyles);
+              }
+            });
+          } else {
+            crawlObjectProperties(data, sources, resolvedStyles);
+          }
+          resolvedStyles = Object.fromEntries(Object.entries(resolvedStyles).sort());
+        }
+        function crawlObjectProperties(entry, sources, resolvedStyles) {
+          var keys = Object.keys(entry);
+          keys.forEach(function (key) {
+            var value = entry[key];
+            if (typeof value === 'string') {
+              if (key === value) {
+                // Special case; this key is the name of the style's source/file/module.
+                sources.add(key);
+              } else {
+                var propertyValue = getPropertyValueForStyleName(value);
+                if (propertyValue != null) {
+                  resolvedStyles[key] = propertyValue;
+                }
+              }
+            } else {
+              var nestedStyle = {};
+              resolvedStyles[key] = nestedStyle;
+              crawlData([value], sources, nestedStyle);
+            }
+          });
+        }
+        function getPropertyValueForStyleName(styleName) {
+          if (cachedStyleNameToValueMap.has(styleName)) {
+            return cachedStyleNameToValueMap.get(styleName);
+          }
+          for (var styleSheetIndex = 0; styleSheetIndex < document.styleSheets.length; styleSheetIndex++) {
+            var styleSheet = document.styleSheets[styleSheetIndex];
+            var rules = null; // this might throw if CORS rules are enforced https://www.w3.org/TR/cssom-1/#the-cssstylesheet-interface
+
+            try {
+              rules = styleSheet.cssRules;
+            } catch (_e) {
+              continue;
+            }
+            for (var ruleIndex = 0; ruleIndex < rules.length; ruleIndex++) {
+              if (!(rules[ruleIndex] instanceof CSSStyleRule)) {
+                continue;
+              }
+              var rule = rules[ruleIndex];
+              var cssText = rule.cssText,
+                selectorText = rule.selectorText,
+                style = rule.style;
+              if (selectorText != null) {
+                if (selectorText.startsWith(".".concat(styleName))) {
+                  var match = cssText.match(/{ *([a-z\-]+):/);
+                  if (match !== null) {
+                    var property = match[1];
+                    var value = style.getPropertyValue(property);
+                    cachedStyleNameToValueMap.set(styleName, value);
+                    return value;
+                  } else {
+                    return null;
+                  }
+                }
+              }
+            }
+          }
+          return null;
+        }
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/devtools/constants.js
+        var CHANGE_LOG_URL = 'https://github.com/facebook/react/blob/main/packages/react-devtools/CHANGELOG.md';
+        var UNSUPPORTED_VERSION_URL = 'https://reactjs.org/blog/2019/08/15/new-react-devtools.html#how-do-i-get-the-old-version-back';
+        var REACT_DEVTOOLS_WORKPLACE_URL = 'https://fburl.com/react-devtools-workplace-group';
+        var THEME_STYLES = {
+          light: {
+            '--color-attribute-name': '#ef6632',
+            '--color-attribute-name-not-editable': '#23272f',
+            '--color-attribute-name-inverted': 'rgba(255, 255, 255, 0.7)',
+            '--color-attribute-value': '#1a1aa6',
+            '--color-attribute-value-inverted': '#ffffff',
+            '--color-attribute-editable-value': '#1a1aa6',
+            '--color-background': '#ffffff',
+            '--color-background-hover': 'rgba(0, 136, 250, 0.1)',
+            '--color-background-inactive': '#e5e5e5',
+            '--color-background-invalid': '#fff0f0',
+            '--color-background-selected': '#0088fa',
+            '--color-button-background': '#ffffff',
+            '--color-button-background-focus': '#ededed',
+            '--color-button-background-hover': 'rgba(0, 0, 0, 0.2)',
+            '--color-button': '#5f6673',
+            '--color-button-disabled': '#cfd1d5',
+            '--color-button-active': '#0088fa',
+            '--color-button-focus': '#23272f',
+            '--color-button-hover': '#23272f',
+            '--color-border': '#eeeeee',
+            '--color-commit-did-not-render-fill': '#cfd1d5',
+            '--color-commit-did-not-render-fill-text': '#000000',
+            '--color-commit-did-not-render-pattern': '#cfd1d5',
+            '--color-commit-did-not-render-pattern-text': '#333333',
+            '--color-commit-gradient-0': '#37afa9',
+            '--color-commit-gradient-1': '#63b19e',
+            '--color-commit-gradient-2': '#80b393',
+            '--color-commit-gradient-3': '#97b488',
+            '--color-commit-gradient-4': '#abb67d',
+            '--color-commit-gradient-5': '#beb771',
+            '--color-commit-gradient-6': '#cfb965',
+            '--color-commit-gradient-7': '#dfba57',
+            '--color-commit-gradient-8': '#efbb49',
+            '--color-commit-gradient-9': '#febc38',
+            '--color-commit-gradient-text': '#000000',
+            '--color-component-name': '#6a51b2',
+            '--color-component-name-inverted': '#ffffff',
+            '--color-component-badge-background': '#e6e6e6',
+            '--color-component-badge-background-inverted': 'rgba(255, 255, 255, 0.25)',
+            '--color-component-badge-count': '#777d88',
+            '--color-component-badge-count-inverted': 'rgba(255, 255, 255, 0.7)',
+            '--color-console-error-badge-text': '#ffffff',
+            '--color-console-error-background': '#fff0f0',
+            '--color-console-error-border': '#ffd6d6',
+            '--color-console-error-icon': '#eb3941',
+            '--color-console-error-text': '#fe2e31',
+            '--color-console-warning-badge-text': '#000000',
+            '--color-console-warning-background': '#fffbe5',
+            '--color-console-warning-border': '#fff5c1',
+            '--color-console-warning-icon': '#f4bd00',
+            '--color-console-warning-text': '#64460c',
+            '--color-context-background': 'rgba(0,0,0,.9)',
+            '--color-context-background-hover': 'rgba(255, 255, 255, 0.1)',
+            '--color-context-background-selected': '#178fb9',
+            '--color-context-border': '#3d424a',
+            '--color-context-text': '#ffffff',
+            '--color-context-text-selected': '#ffffff',
+            '--color-dim': '#777d88',
+            '--color-dimmer': '#cfd1d5',
+            '--color-dimmest': '#eff0f1',
+            '--color-error-background': 'hsl(0, 100%, 97%)',
+            '--color-error-border': 'hsl(0, 100%, 92%)',
+            '--color-error-text': '#ff0000',
+            '--color-expand-collapse-toggle': '#777d88',
+            '--color-forget-badge-background': '#2683e2',
+            '--color-forget-badge-background-inverted': '#1a6bbc',
+            '--color-forget-text': '#fff',
+            '--color-link': '#0000ff',
+            '--color-modal-background': 'rgba(255, 255, 255, 0.75)',
+            '--color-bridge-version-npm-background': '#eff0f1',
+            '--color-bridge-version-npm-text': '#000000',
+            '--color-bridge-version-number': '#0088fa',
+            '--color-primitive-hook-badge-background': '#e5e5e5',
+            '--color-primitive-hook-badge-text': '#5f6673',
+            '--color-record-active': '#fc3a4b',
+            '--color-record-hover': '#3578e5',
+            '--color-record-inactive': '#0088fa',
+            '--color-resize-bar': '#eeeeee',
+            '--color-resize-bar-active': '#dcdcdc',
+            '--color-resize-bar-border': '#d1d1d1',
+            '--color-resize-bar-dot': '#333333',
+            '--color-timeline-internal-module': '#d1d1d1',
+            '--color-timeline-internal-module-hover': '#c9c9c9',
+            '--color-timeline-internal-module-text': '#444',
+            '--color-timeline-native-event': '#ccc',
+            '--color-timeline-native-event-hover': '#aaa',
+            '--color-timeline-network-primary': '#fcf3dc',
+            '--color-timeline-network-primary-hover': '#f0e7d1',
+            '--color-timeline-network-secondary': '#efc457',
+            '--color-timeline-network-secondary-hover': '#e3ba52',
+            '--color-timeline-priority-background': '#f6f6f6',
+            '--color-timeline-priority-border': '#eeeeee',
+            '--color-timeline-user-timing': '#c9cacd',
+            '--color-timeline-user-timing-hover': '#93959a',
+            '--color-timeline-react-idle': '#d3e5f6',
+            '--color-timeline-react-idle-hover': '#c3d9ef',
+            '--color-timeline-react-render': '#9fc3f3',
+            '--color-timeline-react-render-hover': '#83afe9',
+            '--color-timeline-react-render-text': '#11365e',
+            '--color-timeline-react-commit': '#c88ff0',
+            '--color-timeline-react-commit-hover': '#b281d6',
+            '--color-timeline-react-commit-text': '#3e2c4a',
+            '--color-timeline-react-layout-effects': '#b281d6',
+            '--color-timeline-react-layout-effects-hover': '#9d71bd',
+            '--color-timeline-react-layout-effects-text': '#3e2c4a',
+            '--color-timeline-react-passive-effects': '#b281d6',
+            '--color-timeline-react-passive-effects-hover': '#9d71bd',
+            '--color-timeline-react-passive-effects-text': '#3e2c4a',
+            '--color-timeline-react-schedule': '#9fc3f3',
+            '--color-timeline-react-schedule-hover': '#2683E2',
+            '--color-timeline-react-suspense-rejected': '#f1cc14',
+            '--color-timeline-react-suspense-rejected-hover': '#ffdf37',
+            '--color-timeline-react-suspense-resolved': '#a6e59f',
+            '--color-timeline-react-suspense-resolved-hover': '#89d281',
+            '--color-timeline-react-suspense-unresolved': '#c9cacd',
+            '--color-timeline-react-suspense-unresolved-hover': '#93959a',
+            '--color-timeline-thrown-error': '#ee1638',
+            '--color-timeline-thrown-error-hover': '#da1030',
+            '--color-timeline-text-color': '#000000',
+            '--color-timeline-text-dim-color': '#ccc',
+            '--color-timeline-react-work-border': '#eeeeee',
+            '--color-search-match': 'yellow',
+            '--color-search-match-current': '#f7923b',
+            '--color-selected-tree-highlight-active': 'rgba(0, 136, 250, 0.1)',
+            '--color-selected-tree-highlight-inactive': 'rgba(0, 0, 0, 0.05)',
+            '--color-scroll-caret': 'rgba(150, 150, 150, 0.5)',
+            '--color-tab-selected-border': '#0088fa',
+            '--color-text': '#000000',
+            '--color-text-invalid': '#ff0000',
+            '--color-text-selected': '#ffffff',
+            '--color-toggle-background-invalid': '#fc3a4b',
+            '--color-toggle-background-on': '#0088fa',
+            '--color-toggle-background-off': '#cfd1d5',
+            '--color-toggle-text': '#ffffff',
+            '--color-warning-background': '#fb3655',
+            '--color-warning-background-hover': '#f82042',
+            '--color-warning-text-color': '#ffffff',
+            '--color-warning-text-color-inverted': '#fd4d69',
+            // The styles below should be kept in sync with 'root.css'
+            // They are repeated there because they're used by e.g. tooltips or context menus
+            // which get rendered outside of the DOM subtree (where normal theme/styles are written).
+            '--color-scroll-thumb': '#c2c2c2',
+            '--color-scroll-track': '#fafafa',
+            '--color-tooltip-background': 'rgba(0, 0, 0, 0.9)',
+            '--color-tooltip-text': '#ffffff'
+          },
+          dark: {
+            '--color-attribute-name': '#9d87d2',
+            '--color-attribute-name-not-editable': '#ededed',
+            '--color-attribute-name-inverted': '#282828',
+            '--color-attribute-value': '#cedae0',
+            '--color-attribute-value-inverted': '#ffffff',
+            '--color-attribute-editable-value': 'yellow',
+            '--color-background': '#282c34',
+            '--color-background-hover': 'rgba(255, 255, 255, 0.1)',
+            '--color-background-inactive': '#3d424a',
+            '--color-background-invalid': '#5c0000',
+            '--color-background-selected': '#178fb9',
+            '--color-button-background': '#282c34',
+            '--color-button-background-focus': '#3d424a',
+            '--color-button-background-hover': 'rgba(255, 255, 255, 0.2)',
+            '--color-button': '#afb3b9',
+            '--color-button-active': '#61dafb',
+            '--color-button-disabled': '#4f5766',
+            '--color-button-focus': '#a2e9fc',
+            '--color-button-hover': '#ededed',
+            '--color-border': '#3d424a',
+            '--color-commit-did-not-render-fill': '#777d88',
+            '--color-commit-did-not-render-fill-text': '#000000',
+            '--color-commit-did-not-render-pattern': '#666c77',
+            '--color-commit-did-not-render-pattern-text': '#ffffff',
+            '--color-commit-gradient-0': '#37afa9',
+            '--color-commit-gradient-1': '#63b19e',
+            '--color-commit-gradient-2': '#80b393',
+            '--color-commit-gradient-3': '#97b488',
+            '--color-commit-gradient-4': '#abb67d',
+            '--color-commit-gradient-5': '#beb771',
+            '--color-commit-gradient-6': '#cfb965',
+            '--color-commit-gradient-7': '#dfba57',
+            '--color-commit-gradient-8': '#efbb49',
+            '--color-commit-gradient-9': '#febc38',
+            '--color-commit-gradient-text': '#000000',
+            '--color-component-name': '#61dafb',
+            '--color-component-name-inverted': '#282828',
+            '--color-component-badge-background': '#5e6167',
+            '--color-component-badge-background-inverted': '#46494e',
+            '--color-component-badge-count': '#8f949d',
+            '--color-component-badge-count-inverted': 'rgba(255, 255, 255, 0.85)',
+            '--color-console-error-badge-text': '#000000',
+            '--color-console-error-background': '#290000',
+            '--color-console-error-border': '#5c0000',
+            '--color-console-error-icon': '#eb3941',
+            '--color-console-error-text': '#fc7f7f',
+            '--color-console-warning-badge-text': '#000000',
+            '--color-console-warning-background': '#332b00',
+            '--color-console-warning-border': '#665500',
+            '--color-console-warning-icon': '#f4bd00',
+            '--color-console-warning-text': '#f5f2ed',
+            '--color-context-background': 'rgba(255,255,255,.95)',
+            '--color-context-background-hover': 'rgba(0, 136, 250, 0.1)',
+            '--color-context-background-selected': '#0088fa',
+            '--color-context-border': '#eeeeee',
+            '--color-context-text': '#000000',
+            '--color-context-text-selected': '#ffffff',
+            '--color-dim': '#8f949d',
+            '--color-dimmer': '#777d88',
+            '--color-dimmest': '#4f5766',
+            '--color-error-background': '#200',
+            '--color-error-border': '#900',
+            '--color-error-text': '#f55',
+            '--color-expand-collapse-toggle': '#8f949d',
+            '--color-forget-badge-background': '#2683e2',
+            '--color-forget-badge-background-inverted': '#1a6bbc',
+            '--color-forget-text': '#fff',
+            '--color-link': '#61dafb',
+            '--color-modal-background': 'rgba(0, 0, 0, 0.75)',
+            '--color-bridge-version-npm-background': 'rgba(0, 0, 0, 0.25)',
+            '--color-bridge-version-npm-text': '#ffffff',
+            '--color-bridge-version-number': 'yellow',
+            '--color-primitive-hook-badge-background': 'rgba(0, 0, 0, 0.25)',
+            '--color-primitive-hook-badge-text': 'rgba(255, 255, 255, 0.7)',
+            '--color-record-active': '#fc3a4b',
+            '--color-record-hover': '#a2e9fc',
+            '--color-record-inactive': '#61dafb',
+            '--color-resize-bar': '#282c34',
+            '--color-resize-bar-active': '#31363f',
+            '--color-resize-bar-border': '#3d424a',
+            '--color-resize-bar-dot': '#cfd1d5',
+            '--color-timeline-internal-module': '#303542',
+            '--color-timeline-internal-module-hover': '#363b4a',
+            '--color-timeline-internal-module-text': '#7f8899',
+            '--color-timeline-native-event': '#b2b2b2',
+            '--color-timeline-native-event-hover': '#949494',
+            '--color-timeline-network-primary': '#fcf3dc',
+            '--color-timeline-network-primary-hover': '#e3dbc5',
+            '--color-timeline-network-secondary': '#efc457',
+            '--color-timeline-network-secondary-hover': '#d6af4d',
+            '--color-timeline-priority-background': '#1d2129',
+            '--color-timeline-priority-border': '#282c34',
+            '--color-timeline-user-timing': '#c9cacd',
+            '--color-timeline-user-timing-hover': '#93959a',
+            '--color-timeline-react-idle': '#3d485b',
+            '--color-timeline-react-idle-hover': '#465269',
+            '--color-timeline-react-render': '#2683E2',
+            '--color-timeline-react-render-hover': '#1a76d4',
+            '--color-timeline-react-render-text': '#11365e',
+            '--color-timeline-react-commit': '#731fad',
+            '--color-timeline-react-commit-hover': '#611b94',
+            '--color-timeline-react-commit-text': '#e5c1ff',
+            '--color-timeline-react-layout-effects': '#611b94',
+            '--color-timeline-react-layout-effects-hover': '#51167a',
+            '--color-timeline-react-layout-effects-text': '#e5c1ff',
+            '--color-timeline-react-passive-effects': '#611b94',
+            '--color-timeline-react-passive-effects-hover': '#51167a',
+            '--color-timeline-react-passive-effects-text': '#e5c1ff',
+            '--color-timeline-react-schedule': '#2683E2',
+            '--color-timeline-react-schedule-hover': '#1a76d4',
+            '--color-timeline-react-suspense-rejected': '#f1cc14',
+            '--color-timeline-react-suspense-rejected-hover': '#e4c00f',
+            '--color-timeline-react-suspense-resolved': '#a6e59f',
+            '--color-timeline-react-suspense-resolved-hover': '#89d281',
+            '--color-timeline-react-suspense-unresolved': '#c9cacd',
+            '--color-timeline-react-suspense-unresolved-hover': '#93959a',
+            '--color-timeline-thrown-error': '#fb3655',
+            '--color-timeline-thrown-error-hover': '#f82042',
+            '--color-timeline-text-color': '#282c34',
+            '--color-timeline-text-dim-color': '#555b66',
+            '--color-timeline-react-work-border': '#3d424a',
+            '--color-search-match': 'yellow',
+            '--color-search-match-current': '#f7923b',
+            '--color-selected-tree-highlight-active': 'rgba(23, 143, 185, 0.15)',
+            '--color-selected-tree-highlight-inactive': 'rgba(255, 255, 255, 0.05)',
+            '--color-scroll-caret': '#4f5766',
+            '--color-shadow': 'rgba(0, 0, 0, 0.5)',
+            '--color-tab-selected-border': '#178fb9',
+            '--color-text': '#ffffff',
+            '--color-text-invalid': '#ff8080',
+            '--color-text-selected': '#ffffff',
+            '--color-toggle-background-invalid': '#fc3a4b',
+            '--color-toggle-background-on': '#178fb9',
+            '--color-toggle-background-off': '#777d88',
+            '--color-toggle-text': '#ffffff',
+            '--color-warning-background': '#ee1638',
+            '--color-warning-background-hover': '#da1030',
+            '--color-warning-text-color': '#ffffff',
+            '--color-warning-text-color-inverted': '#ee1638',
+            // The styles below should be kept in sync with 'root.css'
+            // They are repeated there because they're used by e.g. tooltips or context menus
+            // which get rendered outside of the DOM subtree (where normal theme/styles are written).
+            '--color-scroll-thumb': '#afb3b9',
+            '--color-scroll-track': '#313640',
+            '--color-tooltip-background': 'rgba(255, 255, 255, 0.95)',
+            '--color-tooltip-text': '#000000'
+          },
+          compact: {
+            '--font-size-monospace-small': '9px',
+            '--font-size-monospace-normal': '11px',
+            '--font-size-monospace-large': '15px',
+            '--font-size-sans-small': '10px',
+            '--font-size-sans-normal': '12px',
+            '--font-size-sans-large': '14px',
+            '--line-height-data': '18px'
+          },
+          comfortable: {
+            '--font-size-monospace-small': '10px',
+            '--font-size-monospace-normal': '13px',
+            '--font-size-monospace-large': '17px',
+            '--font-size-sans-small': '12px',
+            '--font-size-sans-normal': '14px',
+            '--font-size-sans-large': '16px',
+            '--line-height-data': '22px'
+          }
+        }; // HACK
+        //
+        // Sometimes the inline target is rendered before root styles are applied,
+        // which would result in e.g. NaN itemSize being passed to react-window list.
+
+        var COMFORTABLE_LINE_HEIGHT = parseInt(THEME_STYLES.comfortable['--line-height-data'], 10);
+        var COMPACT_LINE_HEIGHT = parseInt(THEME_STYLES.compact['--line-height-data'], 10);
+        ; // CONCATENATED MODULE: ../react-devtools-timeline/src/constants.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.
+         *
+         * 
+         */
+
+        var REACT_TOTAL_NUM_LANES = 31; // Increment this number any time a backwards breaking change is made to the profiler metadata.
+
+        var SCHEDULING_PROFILER_VERSION = 1;
+        var SNAPSHOT_MAX_HEIGHT = 60;
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/profilingHooks.js
+        function profilingHooks_slicedToArray(arr, i) {
+          return profilingHooks_arrayWithHoles(arr) || profilingHooks_iterableToArrayLimit(arr, i) || profilingHooks_unsupportedIterableToArray(arr, i) || profilingHooks_nonIterableRest();
+        }
+        function profilingHooks_nonIterableRest() {
+          throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+        }
+        function profilingHooks_unsupportedIterableToArray(o, minLen) {
+          if (!o) return;
+          if (typeof o === "string") return profilingHooks_arrayLikeToArray(o, minLen);
+          var n = Object.prototype.toString.call(o).slice(8, -1);
+          if (n === "Object" && o.constructor) n = o.constructor.name;
+          if (n === "Map" || n === "Set") return Array.from(o);
+          if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return profilingHooks_arrayLikeToArray(o, minLen);
+        }
+        function profilingHooks_arrayLikeToArray(arr, len) {
+          if (len == null || len > arr.length) len = arr.length;
+          for (var i = 0, arr2 = new Array(len); i < len; i++) {
+            arr2[i] = arr[i];
+          }
+          return arr2;
+        }
+        function profilingHooks_iterableToArrayLimit(arr, i) {
+          if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
+          var _arr = [];
+          var _n = true;
+          var _d = false;
+          var _e = undefined;
+          try {
+            for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+              _arr.push(_s.value);
+              if (i && _arr.length === i) break;
+            }
+          } catch (err) {
+            _d = true;
+            _e = err;
+          } finally {
+            try {
+              if (!_n && _i["return"] != null) _i["return"]();
+            } finally {
+              if (_d) throw _e;
+            }
+          }
+          return _arr;
+        }
+        function profilingHooks_arrayWithHoles(arr) {
+          if (Array.isArray(arr)) return arr;
+        }
+        function profilingHooks_typeof(obj) {
+          "@babel/helpers - typeof";
+
+          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+            profilingHooks_typeof = function _typeof(obj) {
+              return typeof obj;
+            };
+          } else {
+            profilingHooks_typeof = function _typeof(obj) {
+              return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+            };
+          }
+          return profilingHooks_typeof(obj);
+        }
+
+        /**
+         * 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.
+         *
+         * 
+         */
+
+        // Add padding to the start/stop time of the profile.
+        // This makes the UI nicer to use.
+
+        var TIME_OFFSET = 10;
+        var performanceTarget = null; // If performance exists and supports the subset of the User Timing API that we require.
+
+        var supportsUserTiming = typeof performance !== 'undefined' &&
+        // $FlowFixMe[method-unbinding]
+        typeof performance.mark === 'function' &&
+        // $FlowFixMe[method-unbinding]
+        typeof performance.clearMarks === 'function';
+        var supportsUserTimingV3 = false;
+        if (supportsUserTiming) {
+          var CHECK_V3_MARK = '__v3';
+          var markOptions = {};
+          Object.defineProperty(markOptions, 'startTime', {
+            get: function get() {
+              supportsUserTimingV3 = true;
+              return 0;
+            },
+            set: function set() {}
+          });
+          try {
+            performance.mark(CHECK_V3_MARK, markOptions);
+          } catch (error) {// Ignore
+          } finally {
+            performance.clearMarks(CHECK_V3_MARK);
+          }
+        }
+        if (supportsUserTimingV3) {
+          performanceTarget = performance;
+        } // Some environments (e.g. React Native / Hermes) don't support the performance API yet.
+
+        var profilingHooks_getCurrentTime =
+        // $FlowFixMe[method-unbinding]
+        (typeof performance === "undefined" ? "undefined" : profilingHooks_typeof(performance)) === 'object' && typeof performance.now === 'function' ? function () {
+          return performance.now();
+        } : function () {
+          return Date.now();
+        }; // Mocking the Performance Object (and User Timing APIs) for testing is fragile.
+        // This API allows tests to directly override the User Timing APIs.
+
+        function setPerformanceMock_ONLY_FOR_TESTING(performanceMock) {
+          performanceTarget = performanceMock;
+          supportsUserTiming = performanceMock !== null;
+          supportsUserTimingV3 = performanceMock !== null;
+        }
+        function createProfilingHooks(_ref) {
+          var getDisplayNameForFiber = _ref.getDisplayNameForFiber,
+            getIsProfiling = _ref.getIsProfiling,
+            getLaneLabelMap = _ref.getLaneLabelMap,
+            workTagMap = _ref.workTagMap,
+            currentDispatcherRef = _ref.currentDispatcherRef,
+            reactVersion = _ref.reactVersion;
+          var currentBatchUID = 0;
+          var currentReactComponentMeasure = null;
+          var currentReactMeasuresStack = [];
+          var currentTimelineData = null;
+          var currentFiberStacks = new Map();
+          var isProfiling = false;
+          var nextRenderShouldStartNewBatch = false;
+          function getRelativeTime() {
+            var currentTime = profilingHooks_getCurrentTime();
+            if (currentTimelineData) {
+              if (currentTimelineData.startTime === 0) {
+                currentTimelineData.startTime = currentTime - TIME_OFFSET;
+              }
+              return currentTime - currentTimelineData.startTime;
+            }
+            return 0;
+          }
+          function getInternalModuleRanges() {
+            /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+            if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.getInternalModuleRanges === 'function') {
+              // Ask the DevTools hook for module ranges that may have been reported by the current renderer(s).
+              // Don't do this eagerly like the laneToLabelMap,
+              // because some modules might not yet have registered their boundaries when the renderer is injected.
+              var ranges = __REACT_DEVTOOLS_GLOBAL_HOOK__.getInternalModuleRanges(); // This check would not be required,
+              // except that it's possible for things to override __REACT_DEVTOOLS_GLOBAL_HOOK__.
+
+              if (shared_isArray(ranges)) {
+                return ranges;
+              }
+            }
+            return null;
+          }
+          function getTimelineData() {
+            return currentTimelineData;
+          }
+          function laneToLanesArray(lanes) {
+            var lanesArray = [];
+            var lane = 1;
+            for (var index = 0; index < REACT_TOTAL_NUM_LANES; index++) {
+              if (lane & lanes) {
+                lanesArray.push(lane);
+              }
+              lane *= 2;
+            }
+            return lanesArray;
+          }
+          var laneToLabelMap = typeof getLaneLabelMap === 'function' ? getLaneLabelMap() : null;
+          function markMetadata() {
+            markAndClear("--react-version-".concat(reactVersion));
+            markAndClear("--profiler-version-".concat(SCHEDULING_PROFILER_VERSION));
+            var ranges = getInternalModuleRanges();
+            if (ranges) {
+              for (var i = 0; i < ranges.length; i++) {
+                var range = ranges[i];
+                if (shared_isArray(range) && range.length === 2) {
+                  var _ranges$i = profilingHooks_slicedToArray(ranges[i], 2),
+                    startStackFrame = _ranges$i[0],
+                    stopStackFrame = _ranges$i[1];
+                  markAndClear("--react-internal-module-start-".concat(startStackFrame));
+                  markAndClear("--react-internal-module-stop-".concat(stopStackFrame));
+                }
+              }
+            }
+            if (laneToLabelMap != null) {
+              var labels = Array.from(laneToLabelMap.values()).join(',');
+              markAndClear("--react-lane-labels-".concat(labels));
+            }
+          }
+          function markAndClear(markName) {
+            // This method won't be called unless these functions are defined, so we can skip the extra typeof check.
+            performanceTarget.mark(markName);
+            performanceTarget.clearMarks(markName);
+          }
+          function recordReactMeasureStarted(type, lanes) {
+            // Decide what depth thi work should be rendered at, based on what's on the top of the stack.
+            // It's okay to render over top of "idle" work but everything else should be on its own row.
+            var depth = 0;
+            if (currentReactMeasuresStack.length > 0) {
+              var top = currentReactMeasuresStack[currentReactMeasuresStack.length - 1];
+              depth = top.type === 'render-idle' ? top.depth : top.depth + 1;
+            }
+            var lanesArray = laneToLanesArray(lanes);
+            var reactMeasure = {
+              type: type,
+              batchUID: currentBatchUID,
+              depth: depth,
+              lanes: lanesArray,
+              timestamp: getRelativeTime(),
+              duration: 0
+            };
+            currentReactMeasuresStack.push(reactMeasure);
+            if (currentTimelineData) {
+              var _currentTimelineData = currentTimelineData,
+                batchUIDToMeasuresMap = _currentTimelineData.batchUIDToMeasuresMap,
+                laneToReactMeasureMap = _currentTimelineData.laneToReactMeasureMap;
+              var reactMeasures = batchUIDToMeasuresMap.get(currentBatchUID);
+              if (reactMeasures != null) {
+                reactMeasures.push(reactMeasure);
+              } else {
+                batchUIDToMeasuresMap.set(currentBatchUID, [reactMeasure]);
+              }
+              lanesArray.forEach(function (lane) {
+                reactMeasures = laneToReactMeasureMap.get(lane);
+                if (reactMeasures) {
+                  reactMeasures.push(reactMeasure);
+                }
+              });
+            }
+          }
+          function recordReactMeasureCompleted(type) {
+            var currentTime = getRelativeTime();
+            if (currentReactMeasuresStack.length === 0) {
+              console.error('Unexpected type "%s" completed at %sms while currentReactMeasuresStack is empty.', type, currentTime); // Ignore work "completion" user timing mark that doesn't complete anything
+
+              return;
+            }
+            var top = currentReactMeasuresStack.pop(); // $FlowFixMe[incompatible-type]
+
+            if (top.type !== type) {
+              console.error('Unexpected type "%s" completed at %sms before "%s" completed.', type, currentTime,
+              // $FlowFixMe[incompatible-use]
+              top.type);
+            } // $FlowFixMe[cannot-write] This property should not be writable outside of this function.
+            // $FlowFixMe[incompatible-use]
+
+            top.duration = currentTime - top.timestamp;
+            if (currentTimelineData) {
+              currentTimelineData.duration = getRelativeTime() + TIME_OFFSET;
+            }
+          }
+          function markCommitStarted(lanes) {
+            if (!isProfiling) {
+              return;
+            }
+            recordReactMeasureStarted('commit', lanes); // TODO (timeline) Re-think this approach to "batching"; I don't think it works for Suspense or pre-rendering.
+            // This issue applies to the User Timing data also.
+
+            nextRenderShouldStartNewBatch = true;
+            if (supportsUserTimingV3) {
+              markAndClear("--commit-start-".concat(lanes)); // Some metadata only needs to be logged once per session,
+              // but if profiling information is being recorded via the Performance tab,
+              // DevTools has no way of knowing when the recording starts.
+              // Because of that, we log thie type of data periodically (once per commit).
+
+              markMetadata();
+            }
+          }
+          function markCommitStopped() {
+            if (!isProfiling) {
+              return;
+            }
+            recordReactMeasureCompleted('commit');
+            recordReactMeasureCompleted('render-idle');
+            if (supportsUserTimingV3) {
+              markAndClear('--commit-stop');
+            }
+          }
+          function markComponentRenderStarted(fiber) {
+            if (!isProfiling) {
+              return;
+            }
+            var componentName = getDisplayNameForFiber(fiber) || 'Unknown'; // TODO (timeline) Record and cache component stack
+
+            currentReactComponentMeasure = {
+              componentName: componentName,
+              duration: 0,
+              timestamp: getRelativeTime(),
+              type: 'render',
+              warning: null
+            };
+            if (supportsUserTimingV3) {
+              markAndClear("--component-render-start-".concat(componentName));
+            }
+          }
+          function markComponentRenderStopped() {
+            if (!isProfiling) {
+              return;
+            }
+            if (currentReactComponentMeasure) {
+              if (currentTimelineData) {
+                currentTimelineData.componentMeasures.push(currentReactComponentMeasure);
+              } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+              currentReactComponentMeasure.duration =
+              // $FlowFixMe[incompatible-use] found when upgrading Flow
+              getRelativeTime() - currentReactComponentMeasure.timestamp;
+              currentReactComponentMeasure = null;
+            }
+            if (supportsUserTimingV3) {
+              markAndClear('--component-render-stop');
+            }
+          }
+          function markComponentLayoutEffectMountStarted(fiber) {
+            if (!isProfiling) {
+              return;
+            }
+            var componentName = getDisplayNameForFiber(fiber) || 'Unknown'; // TODO (timeline) Record and cache component stack
+
+            currentReactComponentMeasure = {
+              componentName: componentName,
+              duration: 0,
+              timestamp: getRelativeTime(),
+              type: 'layout-effect-mount',
+              warning: null
+            };
+            if (supportsUserTimingV3) {
+              markAndClear("--component-layout-effect-mount-start-".concat(componentName));
+            }
+          }
+          function markComponentLayoutEffectMountStopped() {
+            if (!isProfiling) {
+              return;
+            }
+            if (currentReactComponentMeasure) {
+              if (currentTimelineData) {
+                currentTimelineData.componentMeasures.push(currentReactComponentMeasure);
+              } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+              currentReactComponentMeasure.duration =
+              // $FlowFixMe[incompatible-use] found when upgrading Flow
+              getRelativeTime() - currentReactComponentMeasure.timestamp;
+              currentReactComponentMeasure = null;
+            }
+            if (supportsUserTimingV3) {
+              markAndClear('--component-layout-effect-mount-stop');
+            }
+          }
+          function markComponentLayoutEffectUnmountStarted(fiber) {
+            if (!isProfiling) {
+              return;
+            }
+            var componentName = getDisplayNameForFiber(fiber) || 'Unknown'; // TODO (timeline) Record and cache component stack
+
+            currentReactComponentMeasure = {
+              componentName: componentName,
+              duration: 0,
+              timestamp: getRelativeTime(),
+              type: 'layout-effect-unmount',
+              warning: null
+            };
+            if (supportsUserTimingV3) {
+              markAndClear("--component-layout-effect-unmount-start-".concat(componentName));
+            }
+          }
+          function markComponentLayoutEffectUnmountStopped() {
+            if (!isProfiling) {
+              return;
+            }
+            if (currentReactComponentMeasure) {
+              if (currentTimelineData) {
+                currentTimelineData.componentMeasures.push(currentReactComponentMeasure);
+              } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+              currentReactComponentMeasure.duration =
+              // $FlowFixMe[incompatible-use] found when upgrading Flow
+              getRelativeTime() - currentReactComponentMeasure.timestamp;
+              currentReactComponentMeasure = null;
+            }
+            if (supportsUserTimingV3) {
+              markAndClear('--component-layout-effect-unmount-stop');
+            }
+          }
+          function markComponentPassiveEffectMountStarted(fiber) {
+            if (!isProfiling) {
+              return;
+            }
+            var componentName = getDisplayNameForFiber(fiber) || 'Unknown'; // TODO (timeline) Record and cache component stack
+
+            currentReactComponentMeasure = {
+              componentName: componentName,
+              duration: 0,
+              timestamp: getRelativeTime(),
+              type: 'passive-effect-mount',
+              warning: null
+            };
+            if (supportsUserTimingV3) {
+              markAndClear("--component-passive-effect-mount-start-".concat(componentName));
+            }
+          }
+          function markComponentPassiveEffectMountStopped() {
+            if (!isProfiling) {
+              return;
+            }
+            if (currentReactComponentMeasure) {
+              if (currentTimelineData) {
+                currentTimelineData.componentMeasures.push(currentReactComponentMeasure);
+              } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+              currentReactComponentMeasure.duration =
+              // $FlowFixMe[incompatible-use] found when upgrading Flow
+              getRelativeTime() - currentReactComponentMeasure.timestamp;
+              currentReactComponentMeasure = null;
+            }
+            if (supportsUserTimingV3) {
+              markAndClear('--component-passive-effect-mount-stop');
+            }
+          }
+          function markComponentPassiveEffectUnmountStarted(fiber) {
+            if (!isProfiling) {
+              return;
+            }
+            var componentName = getDisplayNameForFiber(fiber) || 'Unknown'; // TODO (timeline) Record and cache component stack
+
+            currentReactComponentMeasure = {
+              componentName: componentName,
+              duration: 0,
+              timestamp: getRelativeTime(),
+              type: 'passive-effect-unmount',
+              warning: null
+            };
+            if (supportsUserTimingV3) {
+              markAndClear("--component-passive-effect-unmount-start-".concat(componentName));
+            }
+          }
+          function markComponentPassiveEffectUnmountStopped() {
+            if (!isProfiling) {
+              return;
+            }
+            if (currentReactComponentMeasure) {
+              if (currentTimelineData) {
+                currentTimelineData.componentMeasures.push(currentReactComponentMeasure);
+              } // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+              currentReactComponentMeasure.duration =
+              // $FlowFixMe[incompatible-use] found when upgrading Flow
+              getRelativeTime() - currentReactComponentMeasure.timestamp;
+              currentReactComponentMeasure = null;
+            }
+            if (supportsUserTimingV3) {
+              markAndClear('--component-passive-effect-unmount-stop');
+            }
+          }
+          function markComponentErrored(fiber, thrownValue, lanes) {
+            if (!isProfiling) {
+              return;
+            }
+            var componentName = getDisplayNameForFiber(fiber) || 'Unknown';
+            var phase = fiber.alternate === null ? 'mount' : 'update';
+            var message = '';
+            if (thrownValue !== null && profilingHooks_typeof(thrownValue) === 'object' && typeof thrownValue.message === 'string') {
+              message = thrownValue.message;
+            } else if (typeof thrownValue === 'string') {
+              message = thrownValue;
+            } // TODO (timeline) Record and cache component stack
+
+            if (currentTimelineData) {
+              currentTimelineData.thrownErrors.push({
+                componentName: componentName,
+                message: message,
+                phase: phase,
+                timestamp: getRelativeTime(),
+                type: 'thrown-error'
+              });
+            }
+            if (supportsUserTimingV3) {
+              markAndClear("--error-".concat(componentName, "-").concat(phase, "-").concat(message));
+            }
+          }
+          var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map; // $FlowFixMe[incompatible-type]: Flow cannot handle polymorphic WeakMaps
+
+          var wakeableIDs = new PossiblyWeakMap();
+          var wakeableID = 0;
+          function getWakeableID(wakeable) {
+            if (!wakeableIDs.has(wakeable)) {
+              wakeableIDs.set(wakeable, wakeableID++);
+            }
+            return wakeableIDs.get(wakeable);
+          }
+          function markComponentSuspended(fiber, wakeable, lanes) {
+            if (!isProfiling) {
+              return;
+            }
+            var eventType = wakeableIDs.has(wakeable) ? 'resuspend' : 'suspend';
+            var id = getWakeableID(wakeable);
+            var componentName = getDisplayNameForFiber(fiber) || 'Unknown';
+            var phase = fiber.alternate === null ? 'mount' : 'update'; // Following the non-standard fn.displayName convention,
+            // frameworks like Relay may also annotate Promises with a displayName,
+            // describing what operation/data the thrown Promise is related to.
+            // When this is available we should pass it along to the Timeline.
+
+            var displayName = wakeable.displayName || '';
+            var suspenseEvent = null; // TODO (timeline) Record and cache component stack
+
+            suspenseEvent = {
+              componentName: componentName,
+              depth: 0,
+              duration: 0,
+              id: "".concat(id),
+              phase: phase,
+              promiseName: displayName,
+              resolution: 'unresolved',
+              timestamp: getRelativeTime(),
+              type: 'suspense',
+              warning: null
+            };
+            if (currentTimelineData) {
+              currentTimelineData.suspenseEvents.push(suspenseEvent);
+            }
+            if (supportsUserTimingV3) {
+              markAndClear("--suspense-".concat(eventType, "-").concat(id, "-").concat(componentName, "-").concat(phase, "-").concat(lanes, "-").concat(displayName));
+              wakeable.then(function () {
+                if (suspenseEvent) {
+                  suspenseEvent.duration = getRelativeTime() - suspenseEvent.timestamp;
+                  suspenseEvent.resolution = 'resolved';
+                }
+                if (supportsUserTimingV3) {
+                  markAndClear("--suspense-resolved-".concat(id, "-").concat(componentName));
+                }
+              }, function () {
+                if (suspenseEvent) {
+                  suspenseEvent.duration = getRelativeTime() - suspenseEvent.timestamp;
+                  suspenseEvent.resolution = 'rejected';
+                }
+                if (supportsUserTimingV3) {
+                  markAndClear("--suspense-rejected-".concat(id, "-").concat(componentName));
+                }
+              });
+            }
+          }
+          function markLayoutEffectsStarted(lanes) {
+            if (!isProfiling) {
+              return;
+            }
+            recordReactMeasureStarted('layout-effects', lanes);
+            if (supportsUserTimingV3) {
+              markAndClear("--layout-effects-start-".concat(lanes));
+            }
+          }
+          function markLayoutEffectsStopped() {
+            if (!isProfiling) {
+              return;
+            }
+            recordReactMeasureCompleted('layout-effects');
+            if (supportsUserTimingV3) {
+              markAndClear('--layout-effects-stop');
+            }
+          }
+          function markPassiveEffectsStarted(lanes) {
+            if (!isProfiling) {
+              return;
+            }
+            recordReactMeasureStarted('passive-effects', lanes);
+            if (supportsUserTimingV3) {
+              markAndClear("--passive-effects-start-".concat(lanes));
+            }
+          }
+          function markPassiveEffectsStopped() {
+            if (!isProfiling) {
+              return;
+            }
+            recordReactMeasureCompleted('passive-effects');
+            if (supportsUserTimingV3) {
+              markAndClear('--passive-effects-stop');
+            }
+          }
+          function markRenderStarted(lanes) {
+            if (!isProfiling) {
+              return;
+            }
+            if (nextRenderShouldStartNewBatch) {
+              nextRenderShouldStartNewBatch = false;
+              currentBatchUID++;
+            } // If this is a new batch of work, wrap an "idle" measure around it.
+            // Log it before the "render" measure to preserve the stack ordering.
+
+            if (currentReactMeasuresStack.length === 0 || currentReactMeasuresStack[currentReactMeasuresStack.length - 1].type !== 'render-idle') {
+              recordReactMeasureStarted('render-idle', lanes);
+            }
+            recordReactMeasureStarted('render', lanes);
+            if (supportsUserTimingV3) {
+              markAndClear("--render-start-".concat(lanes));
+            }
+          }
+          function markRenderYielded() {
+            if (!isProfiling) {
+              return;
+            }
+            recordReactMeasureCompleted('render');
+            if (supportsUserTimingV3) {
+              markAndClear('--render-yield');
+            }
+          }
+          function markRenderStopped() {
+            if (!isProfiling) {
+              return;
+            }
+            recordReactMeasureCompleted('render');
+            if (supportsUserTimingV3) {
+              markAndClear('--render-stop');
+            }
+          }
+          function markRenderScheduled(lane) {
+            if (!isProfiling) {
+              return;
+            }
+            if (currentTimelineData) {
+              currentTimelineData.schedulingEvents.push({
+                lanes: laneToLanesArray(lane),
+                timestamp: getRelativeTime(),
+                type: 'schedule-render',
+                warning: null
+              });
+            }
+            if (supportsUserTimingV3) {
+              markAndClear("--schedule-render-".concat(lane));
+            }
+          }
+          function markForceUpdateScheduled(fiber, lane) {
+            if (!isProfiling) {
+              return;
+            }
+            var componentName = getDisplayNameForFiber(fiber) || 'Unknown'; // TODO (timeline) Record and cache component stack
+
+            if (currentTimelineData) {
+              currentTimelineData.schedulingEvents.push({
+                componentName: componentName,
+                lanes: laneToLanesArray(lane),
+                timestamp: getRelativeTime(),
+                type: 'schedule-force-update',
+                warning: null
+              });
+            }
+            if (supportsUserTimingV3) {
+              markAndClear("--schedule-forced-update-".concat(lane, "-").concat(componentName));
+            }
+          }
+          function getParentFibers(fiber) {
+            var parents = [];
+            var parent = fiber;
+            while (parent !== null) {
+              parents.push(parent);
+              parent = parent.return;
+            }
+            return parents;
+          }
+          function markStateUpdateScheduled(fiber, lane) {
+            if (!isProfiling) {
+              return;
+            }
+            var componentName = getDisplayNameForFiber(fiber) || 'Unknown'; // TODO (timeline) Record and cache component stack
+
+            if (currentTimelineData) {
+              var event = {
+                componentName: componentName,
+                // Store the parent fibers so we can post process
+                // them after we finish profiling
+                lanes: laneToLanesArray(lane),
+                timestamp: getRelativeTime(),
+                type: 'schedule-state-update',
+                warning: null
+              };
+              currentFiberStacks.set(event, getParentFibers(fiber)); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+              currentTimelineData.schedulingEvents.push(event);
+            }
+            if (supportsUserTimingV3) {
+              markAndClear("--schedule-state-update-".concat(lane, "-").concat(componentName));
+            }
+          }
+          function toggleProfilingStatus(value) {
+            var recordTimeline = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+            if (isProfiling !== value) {
+              isProfiling = value;
+              if (isProfiling) {
+                var internalModuleSourceToRanges = new Map();
+                if (supportsUserTimingV3) {
+                  var ranges = getInternalModuleRanges();
+                  if (ranges) {
+                    for (var i = 0; i < ranges.length; i++) {
+                      var range = ranges[i];
+                      if (shared_isArray(range) && range.length === 2) {
+                        var _ranges$i2 = profilingHooks_slicedToArray(ranges[i], 2),
+                          startStackFrame = _ranges$i2[0],
+                          stopStackFrame = _ranges$i2[1];
+                        markAndClear("--react-internal-module-start-".concat(startStackFrame));
+                        markAndClear("--react-internal-module-stop-".concat(stopStackFrame));
+                      }
+                    }
+                  }
+                }
+                var laneToReactMeasureMap = new Map();
+                var lane = 1;
+                for (var index = 0; index < REACT_TOTAL_NUM_LANES; index++) {
+                  laneToReactMeasureMap.set(lane, []);
+                  lane *= 2;
+                }
+                currentBatchUID = 0;
+                currentReactComponentMeasure = null;
+                currentReactMeasuresStack = [];
+                currentFiberStacks = new Map();
+                if (recordTimeline) {
+                  currentTimelineData = {
+                    // Session wide metadata; only collected once.
+                    internalModuleSourceToRanges: internalModuleSourceToRanges,
+                    laneToLabelMap: laneToLabelMap || new Map(),
+                    reactVersion: reactVersion,
+                    // Data logged by React during profiling session.
+                    componentMeasures: [],
+                    schedulingEvents: [],
+                    suspenseEvents: [],
+                    thrownErrors: [],
+                    // Data inferred based on what React logs.
+                    batchUIDToMeasuresMap: new Map(),
+                    duration: 0,
+                    laneToReactMeasureMap: laneToReactMeasureMap,
+                    startTime: 0,
+                    // Data only available in Chrome profiles.
+                    flamechart: [],
+                    nativeEvents: [],
+                    networkMeasures: [],
+                    otherUserTimingMarks: [],
+                    snapshots: [],
+                    snapshotHeight: 0
+                  };
+                }
+                nextRenderShouldStartNewBatch = true;
+              } else {
+                // This is __EXPENSIVE__.
+                // We could end up with hundreds of state updated, and for each one of them
+                // would try to create a component stack with possibly hundreds of Fibers.
+                // Creating a cache of component stacks won't help, generating a single stack is already expensive enough.
+                // We should find a way to lazily generate component stacks on demand, when user inspects a specific event.
+                // If we succeed with moving React DevTools Timeline Profiler to Performance panel, then Timeline Profiler would probably be removed.
+                // Now that owner stacks are adopted, revisit this again and cache component stacks per Fiber,
+                // but only return them when needed, sending hundreds of component stacks is beyond the Bridge's bandwidth.
+                // Postprocess Profile data
+                if (currentTimelineData !== null) {
+                  currentTimelineData.schedulingEvents.forEach(function (event) {
+                    if (event.type === 'schedule-state-update') {
+                      // TODO(luna): We can optimize this by creating a map of
+                      // fiber to component stack instead of generating the stack
+                      // for every fiber every time
+                      var fiberStack = currentFiberStacks.get(event);
+                      if (fiberStack && currentDispatcherRef != null) {
+                        event.componentStack = fiberStack.reduce(function (trace, fiber) {
+                          return trace + describeFiber(workTagMap, fiber, currentDispatcherRef);
+                        }, '');
+                      }
+                    }
+                  });
+                } // Clear the current fiber stacks so we don't hold onto the fibers
+                // in memory after profiling finishes
+
+                currentFiberStacks.clear();
+              }
+            }
+          }
+          return {
+            getTimelineData: getTimelineData,
+            profilingHooks: {
+              markCommitStarted: markCommitStarted,
+              markCommitStopped: markCommitStopped,
+              markComponentRenderStarted: markComponentRenderStarted,
+              markComponentRenderStopped: markComponentRenderStopped,
+              markComponentPassiveEffectMountStarted: markComponentPassiveEffectMountStarted,
+              markComponentPassiveEffectMountStopped: markComponentPassiveEffectMountStopped,
+              markComponentPassiveEffectUnmountStarted: markComponentPassiveEffectUnmountStarted,
+              markComponentPassiveEffectUnmountStopped: markComponentPassiveEffectUnmountStopped,
+              markComponentLayoutEffectMountStarted: markComponentLayoutEffectMountStarted,
+              markComponentLayoutEffectMountStopped: markComponentLayoutEffectMountStopped,
+              markComponentLayoutEffectUnmountStarted: markComponentLayoutEffectUnmountStarted,
+              markComponentLayoutEffectUnmountStopped: markComponentLayoutEffectUnmountStopped,
+              markComponentErrored: markComponentErrored,
+              markComponentSuspended: markComponentSuspended,
+              markLayoutEffectsStarted: markLayoutEffectsStarted,
+              markLayoutEffectsStopped: markLayoutEffectsStopped,
+              markPassiveEffectsStarted: markPassiveEffectsStarted,
+              markPassiveEffectsStopped: markPassiveEffectsStopped,
+              markRenderStarted: markRenderStarted,
+              markRenderYielded: markRenderYielded,
+              markRenderStopped: markRenderStopped,
+              markRenderScheduled: markRenderScheduled,
+              markForceUpdateScheduled: markForceUpdateScheduled,
+              markStateUpdateScheduled: markStateUpdateScheduled
+            },
+            toggleProfilingStatus: toggleProfilingStatus
+          };
+        }
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/fiber/renderer.js
+        function _objectWithoutProperties(source, excluded) {
+          if (source == null) return {};
+          var target = _objectWithoutPropertiesLoose(source, excluded);
+          var key, i;
+          if (Object.getOwnPropertySymbols) {
+            var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+            for (i = 0; i < sourceSymbolKeys.length; i++) {
+              key = sourceSymbolKeys[i];
+              if (excluded.indexOf(key) >= 0) continue;
+              if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+              target[key] = source[key];
+            }
+          }
+          return target;
+        }
+        function _objectWithoutPropertiesLoose(source, excluded) {
+          if (source == null) return {};
+          var target = {};
+          var sourceKeys = Object.keys(source);
+          var key, i;
+          for (i = 0; i < sourceKeys.length; i++) {
+            key = sourceKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            target[key] = source[key];
+          }
+          return target;
+        }
+        function renderer_ownKeys(object, enumerableOnly) {
+          var keys = Object.keys(object);
+          if (Object.getOwnPropertySymbols) {
+            var symbols = Object.getOwnPropertySymbols(object);
+            if (enumerableOnly) symbols = symbols.filter(function (sym) {
+              return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+            keys.push.apply(keys, symbols);
+          }
+          return keys;
+        }
+        function renderer_objectSpread(target) {
+          for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i] != null ? arguments[i] : {};
+            if (i % 2) {
+              renderer_ownKeys(Object(source), true).forEach(function (key) {
+                renderer_defineProperty(target, key, source[key]);
+              });
+            } else if (Object.getOwnPropertyDescriptors) {
+              Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+            } else {
+              renderer_ownKeys(Object(source)).forEach(function (key) {
+                Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+              });
+            }
+          }
+          return target;
+        }
+        function renderer_defineProperty(obj, key, value) {
+          if (key in obj) {
+            Object.defineProperty(obj, key, {
+              value: value,
+              enumerable: true,
+              configurable: true,
+              writable: true
+            });
+          } else {
+            obj[key] = value;
+          }
+          return obj;
+        }
+        function fiber_renderer_toConsumableArray(arr) {
+          return fiber_renderer_arrayWithoutHoles(arr) || fiber_renderer_iterableToArray(arr) || fiber_renderer_unsupportedIterableToArray(arr) || fiber_renderer_nonIterableSpread();
+        }
+        function fiber_renderer_nonIterableSpread() {
+          throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+        }
+        function fiber_renderer_iterableToArray(iter) {
+          if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
+        }
+        function fiber_renderer_arrayWithoutHoles(arr) {
+          if (Array.isArray(arr)) return fiber_renderer_arrayLikeToArray(arr);
+        }
+        function renderer_createForOfIteratorHelper(o, allowArrayLike) {
+          var it;
+          if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
+            if (Array.isArray(o) || (it = fiber_renderer_unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+              if (it) o = it;
+              var i = 0;
+              var F = function F() {};
+              return {
+                s: F,
+                n: function n() {
+                  if (i >= o.length) return {
+                    done: true
+                  };
+                  return {
+                    done: false,
+                    value: o[i++]
+                  };
+                },
+                e: function e(_e) {
+                  throw _e;
+                },
+                f: F
+              };
+            }
+            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 normalCompletion = true,
+            didErr = false,
+            err;
+          return {
+            s: function s() {
+              it = o[Symbol.iterator]();
+            },
+            n: function n() {
+              var step = it.next();
+              normalCompletion = step.done;
+              return step;
+            },
+            e: function e(_e2) {
+              didErr = true;
+              err = _e2;
+            },
+            f: function f() {
+              try {
+                if (!normalCompletion && it.return != null) it.return();
+              } finally {
+                if (didErr) throw err;
+              }
+            }
+          };
+        }
+        function fiber_renderer_unsupportedIterableToArray(o, minLen) {
+          if (!o) return;
+          if (typeof o === "string") return fiber_renderer_arrayLikeToArray(o, minLen);
+          var n = Object.prototype.toString.call(o).slice(8, -1);
+          if (n === "Object" && o.constructor) n = o.constructor.name;
+          if (n === "Map" || n === "Set") return Array.from(o);
+          if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return fiber_renderer_arrayLikeToArray(o, minLen);
+        }
+        function fiber_renderer_arrayLikeToArray(arr, len) {
+          if (len == null || len > arr.length) len = arr.length;
+          for (var i = 0, arr2 = new Array(len); i < len; i++) {
+            arr2[i] = arr[i];
+          }
+          return arr2;
+        }
+        function renderer_typeof(obj) {
+          "@babel/helpers - typeof";
+
+          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+            renderer_typeof = function _typeof(obj) {
+              return typeof obj;
+            };
+          } else {
+            renderer_typeof = function _typeof(obj) {
+              return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+            };
+          }
+          return renderer_typeof(obj);
+        }
+
+        /**
+         * 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.
+         *
+         * 
+         */
+
+        // $FlowFixMe[method-unbinding]
+
+        var renderer_toString = Object.prototype.toString;
+        function renderer_isError(object) {
+          return renderer_toString.call(object) === '[object Error]';
+        }
+
+        // Kinds
+
+        var FIBER_INSTANCE = 0;
+        var VIRTUAL_INSTANCE = 1;
+        var FILTERED_FIBER_INSTANCE = 2; // This type represents a stateful instance of a Client Component i.e. a Fiber pair.
+        // These instances also let us track stateful DevTools meta data like id and warnings.
+
+        function createFiberInstance(fiber) {
+          return {
+            kind: FIBER_INSTANCE,
+            id: getUID(),
+            parent: null,
+            firstChild: null,
+            nextSibling: null,
+            source: null,
+            logCount: 0,
+            treeBaseDuration: 0,
+            data: fiber
+          };
+        }
+
+        // This is used to represent a filtered Fiber but still lets us find its host instance.
+        function createFilteredFiberInstance(fiber) {
+          return {
+            kind: FILTERED_FIBER_INSTANCE,
+            id: 0,
+            parent: null,
+            firstChild: null,
+            nextSibling: null,
+            source: null,
+            logCount: 0,
+            treeBaseDuration: 0,
+            data: fiber
+          };
+        } // This type represents a stateful instance of a Server Component or a Component
+        // that gets optimized away - e.g. call-through without creating a Fiber.
+        // It's basically a virtual Fiber. This is not a semantic concept in React.
+        // It only exists as a virtual concept to let the same Element in the DevTools
+        // persist. To be selectable separately from all ReactComponentInfo and overtime.
+
+        function createVirtualInstance(debugEntry) {
+          return {
+            kind: VIRTUAL_INSTANCE,
+            id: getUID(),
+            parent: null,
+            firstChild: null,
+            nextSibling: null,
+            source: null,
+            logCount: 0,
+            treeBaseDuration: 0,
+            data: debugEntry
+          };
+        }
+        function getDispatcherRef(renderer) {
+          if (renderer.currentDispatcherRef === undefined) {
+            return undefined;
+          }
+          var injectedRef = renderer.currentDispatcherRef;
+          if (typeof injectedRef.H === 'undefined' && typeof injectedRef.current !== 'undefined') {
+            // We got a legacy dispatcher injected, let's create a wrapper proxy to translate.
+            return {
+              get H() {
+                return injectedRef.current;
+              },
+              set H(value) {
+                injectedRef.current = value;
+              }
+            };
+          }
+          return injectedRef;
+        }
+        function getFiberFlags(fiber) {
+          // The name of this field changed from "effectTag" to "flags"
+          return fiber.flags !== undefined ? fiber.flags : fiber.effectTag;
+        } // Some environments (e.g. React Native / Hermes) don't support the performance API yet.
+
+        var renderer_getCurrentTime =
+        // $FlowFixMe[method-unbinding]
+        (typeof performance === "undefined" ? "undefined" : renderer_typeof(performance)) === 'object' && typeof performance.now === 'function' ? function () {
+          return performance.now();
+        } : function () {
+          return Date.now();
+        };
+        function getInternalReactConstants(version) {
+          // **********************************************************
+          // The section below is copied from files in React repo.
+          // Keep it in sync, and add version guards if it changes.
+          //
+          // Technically these priority levels are invalid for versions before 16.9,
+          // but 16.9 is the first version to report priority level to DevTools,
+          // so we can avoid checking for earlier versions and support pre-16.9 canary releases in the process.
+          var ReactPriorityLevels = {
+            ImmediatePriority: 99,
+            UserBlockingPriority: 98,
+            NormalPriority: 97,
+            LowPriority: 96,
+            IdlePriority: 95,
+            NoPriority: 90
+          };
+          if (gt(version, '17.0.2')) {
+            ReactPriorityLevels = {
+              ImmediatePriority: 1,
+              UserBlockingPriority: 2,
+              NormalPriority: 3,
+              LowPriority: 4,
+              IdlePriority: 5,
+              NoPriority: 0
+            };
+          }
+          var StrictModeBits = 0;
+          if (gte(version, '18.0.0-alpha')) {
+            // 18+
+            StrictModeBits = 24;
+          } else if (gte(version, '16.9.0')) {
+            // 16.9 - 17
+            StrictModeBits = 1;
+          } else if (gte(version, '16.3.0')) {
+            // 16.3 - 16.8
+            StrictModeBits = 2;
+          }
+          var ReactTypeOfWork = null; // **********************************************************
+          // The section below is copied from files in React repo.
+          // Keep it in sync, and add version guards if it changes.
+          //
+          // TODO Update the gt() check below to be gte() whichever the next version number is.
+          // Currently the version in Git is 17.0.2 (but that version has not been/may not end up being released).
+
+          if (gt(version, '17.0.1')) {
+            ReactTypeOfWork = {
+              CacheComponent: 24,
+              // Experimental
+              ClassComponent: 1,
+              ContextConsumer: 9,
+              ContextProvider: 10,
+              CoroutineComponent: -1,
+              // Removed
+              CoroutineHandlerPhase: -1,
+              // Removed
+              DehydratedSuspenseComponent: 18,
+              // Behind a flag
+              ForwardRef: 11,
+              Fragment: 7,
+              FunctionComponent: 0,
+              HostComponent: 5,
+              HostPortal: 4,
+              HostRoot: 3,
+              HostHoistable: 26,
+              // In reality, 18.2+. But doesn't hurt to include it here
+              HostSingleton: 27,
+              // Same as above
+              HostText: 6,
+              IncompleteClassComponent: 17,
+              IncompleteFunctionComponent: 28,
+              IndeterminateComponent: 2,
+              // removed in 19.0.0
+              LazyComponent: 16,
+              LegacyHiddenComponent: 23,
+              MemoComponent: 14,
+              Mode: 8,
+              OffscreenComponent: 22,
+              // Experimental
+              Profiler: 12,
+              ScopeComponent: 21,
+              // Experimental
+              SimpleMemoComponent: 15,
+              SuspenseComponent: 13,
+              SuspenseListComponent: 19,
+              // Experimental
+              TracingMarkerComponent: 25,
+              // Experimental - This is technically in 18 but we don't
+              // want to fork again so we're adding it here instead
+              YieldComponent: -1,
+              // Removed
+              Throw: 29,
+              ViewTransitionComponent: 30,
+              // Experimental
+              ActivityComponent: 31
+            };
+          } else if (gte(version, '17.0.0-alpha')) {
+            ReactTypeOfWork = {
+              CacheComponent: -1,
+              // Doesn't exist yet
+              ClassComponent: 1,
+              ContextConsumer: 9,
+              ContextProvider: 10,
+              CoroutineComponent: -1,
+              // Removed
+              CoroutineHandlerPhase: -1,
+              // Removed
+              DehydratedSuspenseComponent: 18,
+              // Behind a flag
+              ForwardRef: 11,
+              Fragment: 7,
+              FunctionComponent: 0,
+              HostComponent: 5,
+              HostPortal: 4,
+              HostRoot: 3,
+              HostHoistable: -1,
+              // Doesn't exist yet
+              HostSingleton: -1,
+              // Doesn't exist yet
+              HostText: 6,
+              IncompleteClassComponent: 17,
+              IncompleteFunctionComponent: -1,
+              // Doesn't exist yet
+              IndeterminateComponent: 2,
+              LazyComponent: 16,
+              LegacyHiddenComponent: 24,
+              MemoComponent: 14,
+              Mode: 8,
+              OffscreenComponent: 23,
+              // Experimental
+              Profiler: 12,
+              ScopeComponent: 21,
+              // Experimental
+              SimpleMemoComponent: 15,
+              SuspenseComponent: 13,
+              SuspenseListComponent: 19,
+              // Experimental
+              TracingMarkerComponent: -1,
+              // Doesn't exist yet
+              YieldComponent: -1,
+              // Removed
+              Throw: -1,
+              // Doesn't exist yet
+              ViewTransitionComponent: -1,
+              // Doesn't exist yet
+              ActivityComponent: -1 // Doesn't exist yet
+            };
+          } else if (gte(version, '16.6.0-beta.0')) {
+            ReactTypeOfWork = {
+              CacheComponent: -1,
+              // Doesn't exist yet
+              ClassComponent: 1,
+              ContextConsumer: 9,
+              ContextProvider: 10,
+              CoroutineComponent: -1,
+              // Removed
+              CoroutineHandlerPhase: -1,
+              // Removed
+              DehydratedSuspenseComponent: 18,
+              // Behind a flag
+              ForwardRef: 11,
+              Fragment: 7,
+              FunctionComponent: 0,
+              HostComponent: 5,
+              HostPortal: 4,
+              HostRoot: 3,
+              HostHoistable: -1,
+              // Doesn't exist yet
+              HostSingleton: -1,
+              // Doesn't exist yet
+              HostText: 6,
+              IncompleteClassComponent: 17,
+              IncompleteFunctionComponent: -1,
+              // Doesn't exist yet
+              IndeterminateComponent: 2,
+              LazyComponent: 16,
+              LegacyHiddenComponent: -1,
+              MemoComponent: 14,
+              Mode: 8,
+              OffscreenComponent: -1,
+              // Experimental
+              Profiler: 12,
+              ScopeComponent: -1,
+              // Experimental
+              SimpleMemoComponent: 15,
+              SuspenseComponent: 13,
+              SuspenseListComponent: 19,
+              // Experimental
+              TracingMarkerComponent: -1,
+              // Doesn't exist yet
+              YieldComponent: -1,
+              // Removed
+              Throw: -1,
+              // Doesn't exist yet
+              ViewTransitionComponent: -1,
+              // Doesn't exist yet
+              ActivityComponent: -1 // Doesn't exist yet
+            };
+          } else if (gte(version, '16.4.3-alpha')) {
+            ReactTypeOfWork = {
+              CacheComponent: -1,
+              // Doesn't exist yet
+              ClassComponent: 2,
+              ContextConsumer: 11,
+              ContextProvider: 12,
+              CoroutineComponent: -1,
+              // Removed
+              CoroutineHandlerPhase: -1,
+              // Removed
+              DehydratedSuspenseComponent: -1,
+              // Doesn't exist yet
+              ForwardRef: 13,
+              Fragment: 9,
+              FunctionComponent: 0,
+              HostComponent: 7,
+              HostPortal: 6,
+              HostRoot: 5,
+              HostHoistable: -1,
+              // Doesn't exist yet
+              HostSingleton: -1,
+              // Doesn't exist yet
+              HostText: 8,
+              IncompleteClassComponent: -1,
+              // Doesn't exist yet
+              IncompleteFunctionComponent: -1,
+              // Doesn't exist yet
+              IndeterminateComponent: 4,
+              LazyComponent: -1,
+              // Doesn't exist yet
+              LegacyHiddenComponent: -1,
+              MemoComponent: -1,
+              // Doesn't exist yet
+              Mode: 10,
+              OffscreenComponent: -1,
+              // Experimental
+              Profiler: 15,
+              ScopeComponent: -1,
+              // Experimental
+              SimpleMemoComponent: -1,
+              // Doesn't exist yet
+              SuspenseComponent: 16,
+              SuspenseListComponent: -1,
+              // Doesn't exist yet
+              TracingMarkerComponent: -1,
+              // Doesn't exist yet
+              YieldComponent: -1,
+              // Removed
+              Throw: -1,
+              // Doesn't exist yet
+              ViewTransitionComponent: -1,
+              // Doesn't exist yet
+              ActivityComponent: -1 // Doesn't exist yet
+            };
+          } else {
+            ReactTypeOfWork = {
+              CacheComponent: -1,
+              // Doesn't exist yet
+              ClassComponent: 2,
+              ContextConsumer: 12,
+              ContextProvider: 13,
+              CoroutineComponent: 7,
+              CoroutineHandlerPhase: 8,
+              DehydratedSuspenseComponent: -1,
+              // Doesn't exist yet
+              ForwardRef: 14,
+              Fragment: 10,
+              FunctionComponent: 1,
+              HostComponent: 5,
+              HostPortal: 4,
+              HostRoot: 3,
+              HostHoistable: -1,
+              // Doesn't exist yet
+              HostSingleton: -1,
+              // Doesn't exist yet
+              HostText: 6,
+              IncompleteClassComponent: -1,
+              // Doesn't exist yet
+              IncompleteFunctionComponent: -1,
+              // Doesn't exist yet
+              IndeterminateComponent: 0,
+              LazyComponent: -1,
+              // Doesn't exist yet
+              LegacyHiddenComponent: -1,
+              MemoComponent: -1,
+              // Doesn't exist yet
+              Mode: 11,
+              OffscreenComponent: -1,
+              // Experimental
+              Profiler: 15,
+              ScopeComponent: -1,
+              // Experimental
+              SimpleMemoComponent: -1,
+              // Doesn't exist yet
+              SuspenseComponent: 16,
+              SuspenseListComponent: -1,
+              // Doesn't exist yet
+              TracingMarkerComponent: -1,
+              // Doesn't exist yet
+              YieldComponent: 9,
+              Throw: -1,
+              // Doesn't exist yet
+              ViewTransitionComponent: -1,
+              // Doesn't exist yet
+              ActivityComponent: -1 // Doesn't exist yet
+            };
+          } // **********************************************************
+          // End of copied code.
+          // **********************************************************
+
+          function getTypeSymbol(type) {
+            var symbolOrNumber = renderer_typeof(type) === 'object' && type !== null ? type.$$typeof : type;
+            return renderer_typeof(symbolOrNumber) === 'symbol' ? symbolOrNumber.toString() : symbolOrNumber;
+          }
+          var _ReactTypeOfWork = ReactTypeOfWork,
+            CacheComponent = _ReactTypeOfWork.CacheComponent,
+            ClassComponent = _ReactTypeOfWork.ClassComponent,
+            IncompleteClassComponent = _ReactTypeOfWork.IncompleteClassComponent,
+            IncompleteFunctionComponent = _ReactTypeOfWork.IncompleteFunctionComponent,
+            FunctionComponent = _ReactTypeOfWork.FunctionComponent,
+            IndeterminateComponent = _ReactTypeOfWork.IndeterminateComponent,
+            ForwardRef = _ReactTypeOfWork.ForwardRef,
+            HostRoot = _ReactTypeOfWork.HostRoot,
+            HostHoistable = _ReactTypeOfWork.HostHoistable,
+            HostSingleton = _ReactTypeOfWork.HostSingleton,
+            HostComponent = _ReactTypeOfWork.HostComponent,
+            HostPortal = _ReactTypeOfWork.HostPortal,
+            HostText = _ReactTypeOfWork.HostText,
+            Fragment = _ReactTypeOfWork.Fragment,
+            LazyComponent = _ReactTypeOfWork.LazyComponent,
+            LegacyHiddenComponent = _ReactTypeOfWork.LegacyHiddenComponent,
+            MemoComponent = _ReactTypeOfWork.MemoComponent,
+            OffscreenComponent = _ReactTypeOfWork.OffscreenComponent,
+            Profiler = _ReactTypeOfWork.Profiler,
+            ScopeComponent = _ReactTypeOfWork.ScopeComponent,
+            SimpleMemoComponent = _ReactTypeOfWork.SimpleMemoComponent,
+            SuspenseComponent = _ReactTypeOfWork.SuspenseComponent,
+            SuspenseListComponent = _ReactTypeOfWork.SuspenseListComponent,
+            TracingMarkerComponent = _ReactTypeOfWork.TracingMarkerComponent,
+            Throw = _ReactTypeOfWork.Throw,
+            ViewTransitionComponent = _ReactTypeOfWork.ViewTransitionComponent,
+            ActivityComponent = _ReactTypeOfWork.ActivityComponent;
+          function resolveFiberType(type) {
+            var typeSymbol = getTypeSymbol(type);
+            switch (typeSymbol) {
+              case MEMO_NUMBER:
+              case MEMO_SYMBOL_STRING:
+                // recursively resolving memo type in case of memo(forwardRef(Component))
+                return resolveFiberType(type.type);
+              case FORWARD_REF_NUMBER:
+              case FORWARD_REF_SYMBOL_STRING:
+                return type.render;
+              default:
+                return type;
+            }
+          } // NOTICE Keep in sync with shouldFilterFiber() and other get*ForFiber methods
+
+          function getDisplayNameForFiber(fiber) {
+            var _fiber$updateQueue, _fiber$memoizedState, _fiber$memoizedState$, _fiber$memoizedState2, _fiber$memoizedState3;
+            var shouldSkipForgetCheck = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+            var elementType = fiber.elementType,
+              type = fiber.type,
+              tag = fiber.tag;
+            var resolvedType = type;
+            if (renderer_typeof(type) === 'object' && type !== null) {
+              resolvedType = resolveFiberType(type);
+            }
+            var resolvedContext = null;
+            if (!shouldSkipForgetCheck && (
+            // $FlowFixMe[incompatible-type] fiber.updateQueue is mixed
+            ((_fiber$updateQueue = fiber.updateQueue) === null || _fiber$updateQueue === void 0 ? void 0 : _fiber$updateQueue.memoCache) != null || Array.isArray((_fiber$memoizedState = fiber.memoizedState) === null || _fiber$memoizedState === void 0 ? void 0 : _fiber$memoizedState.memoizedState) && ((_fiber$memoizedState$ = fiber.memoizedState.memoizedState[0]) === null || _fiber$memoizedState$ === void 0 ? void 0 : _fiber$memoizedState$[ReactSymbols_REACT_MEMO_CACHE_SENTINEL]) || ((_fiber$memoizedState2 = fiber.memoizedState) === null || _fiber$memoizedState2 === void 0 ? void 0 : (_fiber$memoizedState3 = _fiber$memoizedState2.memoizedState) === null || _fiber$memoizedState3 === void 0 ? void 0 : _fiber$memoizedState3[ReactSymbols_REACT_MEMO_CACHE_SENTINEL]))) {
+              var displayNameWithoutForgetWrapper = getDisplayNameForFiber(fiber, true);
+              if (displayNameWithoutForgetWrapper == null) {
+                return null;
+              }
+              return "Forget(".concat(displayNameWithoutForgetWrapper, ")");
+            }
+            switch (tag) {
+              case ActivityComponent:
+                return 'Activity';
+              case CacheComponent:
+                return 'Cache';
+              case ClassComponent:
+              case IncompleteClassComponent:
+              case IncompleteFunctionComponent:
+              case FunctionComponent:
+              case IndeterminateComponent:
+                return getDisplayName(resolvedType);
+              case ForwardRef:
+                return getWrappedDisplayName(elementType, resolvedType, 'ForwardRef', 'Anonymous');
+              case HostRoot:
+                var fiberRoot = fiber.stateNode;
+                if (fiberRoot != null && fiberRoot._debugRootType !== null) {
+                  return fiberRoot._debugRootType;
+                }
+                return null;
+              case HostComponent:
+              case HostSingleton:
+              case HostHoistable:
+                return type;
+              case HostPortal:
+              case HostText:
+                return null;
+              case Fragment:
+                return 'Fragment';
+              case LazyComponent:
+                // This display name will not be user visible.
+                // Once a Lazy component loads its inner component, React replaces the tag and type.
+                // This display name will only show up in console logs when DevTools DEBUG mode is on.
+                return 'Lazy';
+              case MemoComponent:
+              case SimpleMemoComponent:
+                // Display name in React does not use `Memo` as a wrapper but fallback name.
+                return getWrappedDisplayName(elementType, resolvedType, 'Memo', 'Anonymous');
+              case SuspenseComponent:
+                return 'Suspense';
+              case LegacyHiddenComponent:
+                return 'LegacyHidden';
+              case OffscreenComponent:
+                return 'Offscreen';
+              case ScopeComponent:
+                return 'Scope';
+              case SuspenseListComponent:
+                return 'SuspenseList';
+              case Profiler:
+                return 'Profiler';
+              case TracingMarkerComponent:
+                return 'TracingMarker';
+              case ViewTransitionComponent:
+                return 'ViewTransition';
+              case Throw:
+                // This should really never be visible.
+                return 'Error';
+              default:
+                var typeSymbol = getTypeSymbol(type);
+                switch (typeSymbol) {
+                  case CONCURRENT_MODE_NUMBER:
+                  case CONCURRENT_MODE_SYMBOL_STRING:
+                  case DEPRECATED_ASYNC_MODE_SYMBOL_STRING:
+                    return null;
+                  case PROVIDER_NUMBER:
+                  case PROVIDER_SYMBOL_STRING:
+                    // 16.3.0 exposed the context object as "context"
+                    // PR #12501 changed it to "_context" for 16.3.1+
+                    // NOTE Keep in sync with inspectElementRaw()
+                    resolvedContext = fiber.type._context || fiber.type.context;
+                    return "".concat(resolvedContext.displayName || 'Context', ".Provider");
+                  case CONTEXT_NUMBER:
+                  case CONTEXT_SYMBOL_STRING:
+                  case SERVER_CONTEXT_SYMBOL_STRING:
+                    if (fiber.type._context === undefined && fiber.type.Provider === fiber.type) {
+                      // In 19+, Context.Provider === Context, so this is a provider.
+                      resolvedContext = fiber.type;
+                      return "".concat(resolvedContext.displayName || 'Context', ".Provider");
+                    } // 16.3-16.5 read from "type" because the Consumer is the actual context object.
+                    // 16.6+ should read from "type._context" because Consumer can be different (in DEV).
+                    // NOTE Keep in sync with inspectElementRaw()
+
+                    resolvedContext = fiber.type._context || fiber.type; // NOTE: TraceUpdatesBackendManager depends on the name ending in '.Consumer'
+                    // If you change the name, figure out a more resilient way to detect it.
+
+                    return "".concat(resolvedContext.displayName || 'Context', ".Consumer");
+                  case CONSUMER_SYMBOL_STRING:
+                    // 19+
+                    resolvedContext = fiber.type._context;
+                    return "".concat(resolvedContext.displayName || 'Context', ".Consumer");
+                  case STRICT_MODE_NUMBER:
+                  case STRICT_MODE_SYMBOL_STRING:
+                    return null;
+                  case PROFILER_NUMBER:
+                  case PROFILER_SYMBOL_STRING:
+                    return "Profiler(".concat(fiber.memoizedProps.id, ")");
+                  case SCOPE_NUMBER:
+                  case SCOPE_SYMBOL_STRING:
+                    return 'Scope';
+                  default:
+                    // Unknown element type.
+                    // This may mean a new element type that has not yet been added to DevTools.
+                    return null;
+                }
+            }
+          }
+          return {
+            getDisplayNameForFiber: getDisplayNameForFiber,
+            getTypeSymbol: getTypeSymbol,
+            ReactPriorityLevels: ReactPriorityLevels,
+            ReactTypeOfWork: ReactTypeOfWork,
+            StrictModeBits: StrictModeBits
+          };
+        } // All environment names we've seen so far. This lets us create a list of filters to apply.
+        // This should ideally include env of filtered Components too so that you can add those as
+        // filters at the same time as removing some other filter.
+
+        var knownEnvironmentNames = new Set(); // Map of FiberRoot to their root FiberInstance.
+
+        var rootToFiberInstanceMap = new Map(); // Map of id to FiberInstance or VirtualInstance.
+        // This Map is used to e.g. get the display name for a Fiber or schedule an update,
+        // operations that should be the same whether the current and work-in-progress Fiber is used.
+
+        var idToDevToolsInstanceMap = new Map(); // Map of canonical HostInstances to the nearest parent DevToolsInstance.
+
+        var publicInstanceToDevToolsInstanceMap = new Map(); // Map of resource DOM nodes to all the nearest DevToolsInstances that depend on it.
+
+        var hostResourceToDevToolsInstanceMap = new Map(); // Ideally, this should be injected from Reconciler config
+
+        function getPublicInstance(instance) {
+          // Typically the PublicInstance and HostInstance is the same thing but not in Fabric.
+          // So we need to detect this and use that as the public instance.
+          // React Native. Modern. Fabric.
+          if (renderer_typeof(instance) === 'object' && instance !== null) {
+            if (renderer_typeof(instance.canonical) === 'object' && instance.canonical !== null) {
+              if (renderer_typeof(instance.canonical.publicInstance) === 'object' && instance.canonical.publicInstance !== null) {
+                return instance.canonical.publicInstance;
+              }
+            } // React Native. Legacy. Paper.
+
+            if (typeof instance._nativeTag === 'number') {
+              return instance._nativeTag;
+            }
+          } // React Web. Usually a DOM element.
+
+          return instance;
+        }
+        function getNativeTag(instance) {
+          if (renderer_typeof(instance) !== 'object' || instance === null) {
+            return null;
+          } // Modern. Fabric.
+
+          if (instance.canonical != null && typeof instance.canonical.nativeTag === 'number') {
+            return instance.canonical.nativeTag;
+          } // Legacy.  Paper.
+
+          if (typeof instance._nativeTag === 'number') {
+            return instance._nativeTag;
+          }
+          return null;
+        }
+        function aquireHostInstance(nearestInstance, hostInstance) {
+          var publicInstance = getPublicInstance(hostInstance);
+          publicInstanceToDevToolsInstanceMap.set(publicInstance, nearestInstance);
+        }
+        function releaseHostInstance(nearestInstance, hostInstance) {
+          var publicInstance = getPublicInstance(hostInstance);
+          if (publicInstanceToDevToolsInstanceMap.get(publicInstance) === nearestInstance) {
+            publicInstanceToDevToolsInstanceMap.delete(publicInstance);
+          }
+        }
+        function aquireHostResource(nearestInstance, resource) {
+          var hostInstance = resource && resource.instance;
+          if (hostInstance) {
+            var publicInstance = getPublicInstance(hostInstance);
+            var resourceInstances = hostResourceToDevToolsInstanceMap.get(publicInstance);
+            if (resourceInstances === undefined) {
+              resourceInstances = new Set();
+              hostResourceToDevToolsInstanceMap.set(publicInstance, resourceInstances); // Store the first match in the main map for quick access when selecting DOM node.
+
+              publicInstanceToDevToolsInstanceMap.set(publicInstance, nearestInstance);
+            }
+            resourceInstances.add(nearestInstance);
+          }
+        }
+        function releaseHostResource(nearestInstance, resource) {
+          var hostInstance = resource && resource.instance;
+          if (hostInstance) {
+            var publicInstance = getPublicInstance(hostInstance);
+            var resourceInstances = hostResourceToDevToolsInstanceMap.get(publicInstance);
+            if (resourceInstances !== undefined) {
+              resourceInstances.delete(nearestInstance);
+              if (resourceInstances.size === 0) {
+                hostResourceToDevToolsInstanceMap.delete(publicInstance);
+                publicInstanceToDevToolsInstanceMap.delete(publicInstance);
+              } else if (publicInstanceToDevToolsInstanceMap.get(publicInstance) === nearestInstance) {
+                // This was the first one. Store the next first one in the main map for easy access.
+                // eslint-disable-next-line no-for-of-loops/no-for-of-loops
+                var _iterator = renderer_createForOfIteratorHelper(resourceInstances),
+                  _step;
+                try {
+                  for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                    var firstInstance = _step.value;
+                    publicInstanceToDevToolsInstanceMap.set(firstInstance, nearestInstance);
+                    break;
+                  }
+                } catch (err) {
+                  _iterator.e(err);
+                } finally {
+                  _iterator.f();
+                }
+              }
+            }
+          }
+        }
+        function renderer_attach(hook, rendererID, renderer, global, shouldStartProfilingNow, profilingSettings) {
+          // Newer versions of the reconciler package also specific reconciler version.
+          // If that version number is present, use it.
+          // Third party renderer versions may not match the reconciler version,
+          // and the latter is what's important in terms of tags and symbols.
+          var version = renderer.reconcilerVersion || renderer.version;
+          var _getInternalReactCons = getInternalReactConstants(version),
+            getDisplayNameForFiber = _getInternalReactCons.getDisplayNameForFiber,
+            getTypeSymbol = _getInternalReactCons.getTypeSymbol,
+            ReactPriorityLevels = _getInternalReactCons.ReactPriorityLevels,
+            ReactTypeOfWork = _getInternalReactCons.ReactTypeOfWork,
+            StrictModeBits = _getInternalReactCons.StrictModeBits;
+          var ActivityComponent = ReactTypeOfWork.ActivityComponent,
+            CacheComponent = ReactTypeOfWork.CacheComponent,
+            ClassComponent = ReactTypeOfWork.ClassComponent,
+            ContextConsumer = ReactTypeOfWork.ContextConsumer,
+            DehydratedSuspenseComponent = ReactTypeOfWork.DehydratedSuspenseComponent,
+            ForwardRef = ReactTypeOfWork.ForwardRef,
+            Fragment = ReactTypeOfWork.Fragment,
+            FunctionComponent = ReactTypeOfWork.FunctionComponent,
+            HostRoot = ReactTypeOfWork.HostRoot,
+            HostHoistable = ReactTypeOfWork.HostHoistable,
+            HostSingleton = ReactTypeOfWork.HostSingleton,
+            HostPortal = ReactTypeOfWork.HostPortal,
+            HostComponent = ReactTypeOfWork.HostComponent,
+            HostText = ReactTypeOfWork.HostText,
+            IncompleteClassComponent = ReactTypeOfWork.IncompleteClassComponent,
+            IncompleteFunctionComponent = ReactTypeOfWork.IncompleteFunctionComponent,
+            IndeterminateComponent = ReactTypeOfWork.IndeterminateComponent,
+            LegacyHiddenComponent = ReactTypeOfWork.LegacyHiddenComponent,
+            MemoComponent = ReactTypeOfWork.MemoComponent,
+            OffscreenComponent = ReactTypeOfWork.OffscreenComponent,
+            SimpleMemoComponent = ReactTypeOfWork.SimpleMemoComponent,
+            SuspenseComponent = ReactTypeOfWork.SuspenseComponent,
+            SuspenseListComponent = ReactTypeOfWork.SuspenseListComponent,
+            TracingMarkerComponent = ReactTypeOfWork.TracingMarkerComponent,
+            Throw = ReactTypeOfWork.Throw,
+            ViewTransitionComponent = ReactTypeOfWork.ViewTransitionComponent;
+          var ImmediatePriority = ReactPriorityLevels.ImmediatePriority,
+            UserBlockingPriority = ReactPriorityLevels.UserBlockingPriority,
+            NormalPriority = ReactPriorityLevels.NormalPriority,
+            LowPriority = ReactPriorityLevels.LowPriority,
+            IdlePriority = ReactPriorityLevels.IdlePriority,
+            NoPriority = ReactPriorityLevels.NoPriority;
+          var getLaneLabelMap = renderer.getLaneLabelMap,
+            injectProfilingHooks = renderer.injectProfilingHooks,
+            overrideHookState = renderer.overrideHookState,
+            overrideHookStateDeletePath = renderer.overrideHookStateDeletePath,
+            overrideHookStateRenamePath = renderer.overrideHookStateRenamePath,
+            overrideProps = renderer.overrideProps,
+            overridePropsDeletePath = renderer.overridePropsDeletePath,
+            overridePropsRenamePath = renderer.overridePropsRenamePath,
+            scheduleRefresh = renderer.scheduleRefresh,
+            setErrorHandler = renderer.setErrorHandler,
+            setSuspenseHandler = renderer.setSuspenseHandler,
+            scheduleUpdate = renderer.scheduleUpdate,
+            getCurrentFiber = renderer.getCurrentFiber;
+          var supportsTogglingError = typeof setErrorHandler === 'function' && typeof scheduleUpdate === 'function';
+          var supportsTogglingSuspense = typeof setSuspenseHandler === 'function' && typeof scheduleUpdate === 'function';
+          if (typeof scheduleRefresh === 'function') {
+            // When Fast Refresh updates a component, the frontend may need to purge cached information.
+            // For example, ASTs cached for the component (for named hooks) may no longer be valid.
+            // Send a signal to the frontend to purge this cached information.
+            // The "fastRefreshScheduled" dispatched is global (not Fiber or even Renderer specific).
+            // This is less effecient since it means the front-end will need to purge the entire cache,
+            // but this is probably an okay trade off in order to reduce coupling between the DevTools and Fast Refresh.
+            renderer.scheduleRefresh = function () {
+              try {
+                hook.emit('fastRefreshScheduled');
+              } finally {
+                return scheduleRefresh.apply(void 0, arguments);
+              }
+            };
+          }
+          var getTimelineData = null;
+          var toggleProfilingStatus = null;
+          if (typeof injectProfilingHooks === 'function') {
+            var response = createProfilingHooks({
+              getDisplayNameForFiber: getDisplayNameForFiber,
+              getIsProfiling: function getIsProfiling() {
+                return isProfiling;
+              },
+              getLaneLabelMap: getLaneLabelMap,
+              currentDispatcherRef: getDispatcherRef(renderer),
+              workTagMap: ReactTypeOfWork,
+              reactVersion: version
+            }); // Pass the Profiling hooks to the reconciler for it to call during render.
+
+            injectProfilingHooks(response.profilingHooks); // Hang onto this toggle so we can notify the external methods of profiling status changes.
+
+            getTimelineData = response.getTimelineData;
+            toggleProfilingStatus = response.toggleProfilingStatus;
+          }
+
+          // Tracks Errors/Warnings logs added to a Fiber. They are added before the commit and get
+          // picked up a FiberInstance. This keeps it around as long as the Fiber is alive which
+          // lets the Fiber get reparented/remounted and still observe the previous errors/warnings.
+          // Unless we explicitly clear the logs from a Fiber.
+          var fiberToComponentLogsMap = new WeakMap(); // Tracks whether we've performed a commit since the last log. This is used to know
+          // whether we received any new logs between the commit and post commit phases. I.e.
+          // if any passive effects called console.warn / console.error.
+
+          var needsToFlushComponentLogs = false;
+          function bruteForceFlushErrorsAndWarnings() {
+            // Refresh error/warning count for all mounted unfiltered Fibers.
+            var hasChanges = false; // eslint-disable-next-line no-for-of-loops/no-for-of-loops
+
+            var _iterator2 = renderer_createForOfIteratorHelper(idToDevToolsInstanceMap.values()),
+              _step2;
+            try {
+              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                var devtoolsInstance = _step2.value;
+                if (devtoolsInstance.kind === FIBER_INSTANCE) {
+                  var _fiber = devtoolsInstance.data;
+                  var componentLogsEntry = fiberToComponentLogsMap.get(_fiber);
+                  var changed = recordConsoleLogs(devtoolsInstance, componentLogsEntry);
+                  if (changed) {
+                    hasChanges = true;
+                    updateMostRecentlyInspectedElementIfNecessary(devtoolsInstance.id);
+                  }
+                } else {// Virtual Instances cannot log in passive effects and so never appear here.
+                }
+              }
+            } catch (err) {
+              _iterator2.e(err);
+            } finally {
+              _iterator2.f();
+            }
+            if (hasChanges) {
+              flushPendingEvents();
+            }
+          }
+          function clearErrorsAndWarnings() {
+            // Note, this only clears logs for Fibers that have instances. If they're filtered
+            // and then mount, the logs are there. Ensuring we only clear what you've seen.
+            // If we wanted to clear the whole set, we'd replace fiberToComponentLogsMap with a
+            // new WeakMap. It's unclear whether we should clear componentInfoToComponentLogsMap
+            // since it's shared by other renderers but presumably it would.
+            // eslint-disable-next-line no-for-of-loops/no-for-of-loops
+            var _iterator3 = renderer_createForOfIteratorHelper(idToDevToolsInstanceMap.values()),
+              _step3;
+            try {
+              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                var devtoolsInstance = _step3.value;
+                if (devtoolsInstance.kind === FIBER_INSTANCE) {
+                  var _fiber2 = devtoolsInstance.data;
+                  fiberToComponentLogsMap.delete(_fiber2);
+                  if (_fiber2.alternate) {
+                    fiberToComponentLogsMap.delete(_fiber2.alternate);
+                  }
+                } else {
+                  componentInfoToComponentLogsMap["delete"](devtoolsInstance.data);
+                }
+                var changed = recordConsoleLogs(devtoolsInstance, undefined);
+                if (changed) {
+                  updateMostRecentlyInspectedElementIfNecessary(devtoolsInstance.id);
+                }
+              }
+            } catch (err) {
+              _iterator3.e(err);
+            } finally {
+              _iterator3.f();
+            }
+            flushPendingEvents();
+          }
+          function clearConsoleLogsHelper(instanceID, type) {
+            var devtoolsInstance = idToDevToolsInstanceMap.get(instanceID);
+            if (devtoolsInstance !== undefined) {
+              var componentLogsEntry;
+              if (devtoolsInstance.kind === FIBER_INSTANCE) {
+                var _fiber3 = devtoolsInstance.data;
+                componentLogsEntry = fiberToComponentLogsMap.get(_fiber3);
+                if (componentLogsEntry === undefined && _fiber3.alternate !== null) {
+                  componentLogsEntry = fiberToComponentLogsMap.get(_fiber3.alternate);
+                }
+              } else {
+                var componentInfo = devtoolsInstance.data;
+                componentLogsEntry = componentInfoToComponentLogsMap.get(componentInfo);
+              }
+              if (componentLogsEntry !== undefined) {
+                if (type === 'error') {
+                  componentLogsEntry.errors.clear();
+                  componentLogsEntry.errorsCount = 0;
+                } else {
+                  componentLogsEntry.warnings.clear();
+                  componentLogsEntry.warningsCount = 0;
+                }
+                var changed = recordConsoleLogs(devtoolsInstance, componentLogsEntry);
+                if (changed) {
+                  flushPendingEvents();
+                  updateMostRecentlyInspectedElementIfNecessary(devtoolsInstance.id);
+                }
+              }
+            }
+          }
+          function clearErrorsForElementID(instanceID) {
+            clearConsoleLogsHelper(instanceID, 'error');
+          }
+          function clearWarningsForElementID(instanceID) {
+            clearConsoleLogsHelper(instanceID, 'warn');
+          }
+          function updateMostRecentlyInspectedElementIfNecessary(fiberID) {
+            if (mostRecentlyInspectedElement !== null && mostRecentlyInspectedElement.id === fiberID) {
+              hasElementUpdatedSinceLastInspected = true;
+            }
+          }
+          function getComponentStack(topFrame) {
+            if (getCurrentFiber == null) {
+              // Expected this to be part of the renderer. Ignore.
+              return null;
+            }
+            var current = getCurrentFiber();
+            if (current === null) {
+              // Outside of our render scope.
+              return null;
+            }
+            if (DevToolsFiberComponentStack_supportsConsoleTasks(current)) {
+              // This will be handled natively by console.createTask. No need for
+              // DevTools to add it.
+              return null;
+            }
+            var dispatcherRef = getDispatcherRef(renderer);
+            if (dispatcherRef === undefined) {
+              return null;
+            }
+            var enableOwnerStacks = supportsOwnerStacks(current);
+            var componentStack = '';
+            if (enableOwnerStacks) {
+              // Prefix the owner stack with the current stack. I.e. what called
+              // console.error. While this will also be part of the native stack,
+              // it is hidden and not presented alongside this argument so we print
+              // them all together.
+              var topStackFrames = formatOwnerStack(topFrame);
+              if (topStackFrames) {
+                componentStack += '\n' + topStackFrames;
+              }
+              componentStack += getOwnerStackByFiberInDev(ReactTypeOfWork, current, dispatcherRef);
+            } else {
+              componentStack = getStackByFiberInDevAndProd(ReactTypeOfWork, current, dispatcherRef);
+            }
+            return {
+              enableOwnerStacks: enableOwnerStacks,
+              componentStack: componentStack
+            };
+          } // Called when an error or warning is logged during render, commit, or passive (including unmount functions).
+
+          function onErrorOrWarning(type, args) {
+            if (getCurrentFiber == null) {
+              // Expected this to be part of the renderer. Ignore.
+              return;
+            }
+            var fiber = getCurrentFiber();
+            if (fiber === null) {
+              // Outside of our render scope.
+              return;
+            }
+            if (type === 'error') {
+              // if this is an error simulated by us to trigger error boundary, ignore
+              if (forceErrorForFibers.get(fiber) === true || fiber.alternate !== null && forceErrorForFibers.get(fiber.alternate) === true) {
+                return;
+              }
+            } // We can't really use this message as a unique key, since we can't distinguish
+            // different objects in this implementation. We have to delegate displaying of the objects
+            // to the environment, the browser console, for example, so this is why this should be kept
+            // as an array of arguments, instead of the plain string.
+            // [Warning: %o, {...}] and [Warning: %o, {...}] will be considered as the same message,
+            // even if objects are different
+
+            var message = formatConsoleArgumentsToSingleString.apply(void 0, fiber_renderer_toConsumableArray(args)); // Track the warning/error for later.
+
+            var componentLogsEntry = fiberToComponentLogsMap.get(fiber);
+            if (componentLogsEntry === undefined && fiber.alternate !== null) {
+              componentLogsEntry = fiberToComponentLogsMap.get(fiber.alternate);
+              if (componentLogsEntry !== undefined) {
+                // Use the same set for both Fibers.
+                fiberToComponentLogsMap.set(fiber, componentLogsEntry);
+              }
+            }
+            if (componentLogsEntry === undefined) {
+              componentLogsEntry = {
+                errors: new Map(),
+                errorsCount: 0,
+                warnings: new Map(),
+                warningsCount: 0
+              };
+              fiberToComponentLogsMap.set(fiber, componentLogsEntry);
+            }
+            var messageMap = type === 'error' ? componentLogsEntry.errors : componentLogsEntry.warnings;
+            var count = messageMap.get(message) || 0;
+            messageMap.set(message, count + 1);
+            if (type === 'error') {
+              componentLogsEntry.errorsCount++;
+            } else {
+              componentLogsEntry.warningsCount++;
+            } // The changes will be flushed later when we commit.
+            // If the log happened in a passive effect, then this happens after we've
+            // already committed the new tree so the change won't show up until we rerender
+            // that component again. We need to visit a Component with passive effects in
+            // handlePostCommitFiberRoot again to ensure that we flush the changes after passive.
+
+            needsToFlushComponentLogs = true;
+          }
+          function debug(name, instance, parentInstance) {
+            var extraString = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';
+            if (__DEBUG__) {
+              var displayName = instance.kind === VIRTUAL_INSTANCE ? instance.data.name || 'null' : instance.data.tag + ':' + (getDisplayNameForFiber(instance.data) || 'null');
+              var maybeID = instance.kind === FILTERED_FIBER_INSTANCE ? '<no id>' : instance.id;
+              var parentDisplayName = parentInstance === null ? '' : parentInstance.kind === VIRTUAL_INSTANCE ? parentInstance.data.name || 'null' : parentInstance.data.tag + ':' + (getDisplayNameForFiber(parentInstance.data) || 'null');
+              var maybeParentID = parentInstance === null || parentInstance.kind === FILTERED_FIBER_INSTANCE ? '<no id>' : parentInstance.id;
+              console.groupCollapsed("[renderer] %c".concat(name, " %c").concat(displayName, " (").concat(maybeID, ") %c").concat(parentInstance ? "".concat(parentDisplayName, " (").concat(maybeParentID, ")") : '', " %c").concat(extraString), 'color: red; font-weight: bold;', 'color: blue;', 'color: purple;', 'color: black;');
+              console.log(new Error().stack.split('\n').slice(1).join('\n'));
+              console.groupEnd();
+            }
+          } // eslint-disable-next-line no-unused-vars
+
+          function debugTree(instance) {
+            var indent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+            if (__DEBUG__) {
+              var name = (instance.kind !== VIRTUAL_INSTANCE ? getDisplayNameForFiber(instance.data) : instance.data.name) || '';
+              console.log('  '.repeat(indent) + '- ' + (instance.kind === FILTERED_FIBER_INSTANCE ? 0 : instance.id) + ' (' + name + ')', 'parent', instance.parent === null ? ' ' : instance.parent.kind === FILTERED_FIBER_INSTANCE ? 0 : instance.parent.id, 'next', instance.nextSibling === null ? ' ' : instance.nextSibling.id);
+              var child = instance.firstChild;
+              while (child !== null) {
+                debugTree(child, indent + 1);
+                child = child.nextSibling;
+              }
+            }
+          } // Configurable Components tree filters.
+
+          var hideElementsWithDisplayNames = new Set();
+          var hideElementsWithPaths = new Set();
+          var hideElementsWithTypes = new Set();
+          var hideElementsWithEnvs = new Set(); // Highlight updates
+
+          var traceUpdatesEnabled = false;
+          var traceUpdatesForNodes = new Set();
+          function applyComponentFilters(componentFilters) {
+            hideElementsWithTypes.clear();
+            hideElementsWithDisplayNames.clear();
+            hideElementsWithPaths.clear();
+            hideElementsWithEnvs.clear();
+            componentFilters.forEach(function (componentFilter) {
+              if (!componentFilter.isEnabled) {
+                return;
+              }
+              switch (componentFilter.type) {
+                case ComponentFilterDisplayName:
+                  if (componentFilter.isValid && componentFilter.value !== '') {
+                    hideElementsWithDisplayNames.add(new RegExp(componentFilter.value, 'i'));
+                  }
+                  break;
+                case ComponentFilterElementType:
+                  hideElementsWithTypes.add(componentFilter.value);
+                  break;
+                case ComponentFilterLocation:
+                  if (componentFilter.isValid && componentFilter.value !== '') {
+                    hideElementsWithPaths.add(new RegExp(componentFilter.value, 'i'));
+                  }
+                  break;
+                case ComponentFilterHOC:
+                  hideElementsWithDisplayNames.add(new RegExp('\\('));
+                  break;
+                case ComponentFilterEnvironmentName:
+                  hideElementsWithEnvs.add(componentFilter.value);
+                  break;
+                default:
+                  console.warn("Invalid component filter type \"".concat(componentFilter.type, "\""));
+                  break;
+              }
+            });
+          } // The renderer interface can't read saved component filters directly,
+          // because they are stored in localStorage within the context of the extension.
+          // Instead it relies on the extension to pass filters through.
+
+          if (window.__REACT_DEVTOOLS_COMPONENT_FILTERS__ != null) {
+            var componentFiltersWithoutLocationBasedOnes = filterOutLocationComponentFilters(window.__REACT_DEVTOOLS_COMPONENT_FILTERS__);
+            applyComponentFilters(componentFiltersWithoutLocationBasedOnes);
+          } else {
+            // Unfortunately this feature is not expected to work for React Native for now.
+            // It would be annoying for us to spam YellowBox warnings with unactionable stuff,
+            // so for now just skip this message...
+            //console.warn('⚛ DevTools: Could not locate saved component filters');
+            // Fallback to assuming the default filters in this case.
+            applyComponentFilters(getDefaultComponentFilters());
+          } // If necessary, we can revisit optimizing this operation.
+          // For example, we could add a new recursive unmount tree operation.
+          // The unmount operations are already significantly smaller than mount operations though.
+          // This is something to keep in mind for later.
+
+          function updateComponentFilters(componentFilters) {
+            if (isProfiling) {
+              // Re-mounting a tree while profiling is in progress might break a lot of assumptions.
+              // If necessary, we could support this- but it doesn't seem like a necessary use case.
+              throw Error('Cannot modify filter preferences while profiling');
+            } // Recursively unmount all roots.
+
+            hook.getFiberRoots(rendererID).forEach(function (root) {
+              var rootInstance = rootToFiberInstanceMap.get(root);
+              if (rootInstance === undefined) {
+                throw new Error('Expected the root instance to already exist when applying filters');
+              }
+              currentRoot = rootInstance;
+              unmountInstanceRecursively(rootInstance);
+              rootToFiberInstanceMap.delete(root);
+              flushPendingEvents(root);
+              currentRoot = null;
+            });
+            applyComponentFilters(componentFilters); // Reset pseudo counters so that new path selections will be persisted.
+
+            rootDisplayNameCounter.clear(); // Recursively re-mount all roots with new filter criteria applied.
+
+            hook.getFiberRoots(rendererID).forEach(function (root) {
+              var current = root.current;
+              var newRoot = createFiberInstance(current);
+              rootToFiberInstanceMap.set(root, newRoot);
+              idToDevToolsInstanceMap.set(newRoot.id, newRoot); // Before the traversals, remember to start tracking
+              // our path in case we have selection to restore.
+
+              if (trackedPath !== null) {
+                mightBeOnTrackedPath = true;
+              }
+              currentRoot = newRoot;
+              setRootPseudoKey(currentRoot.id, root.current);
+              mountFiberRecursively(root.current, false);
+              flushPendingEvents(root);
+              currentRoot = null;
+            });
+            flushPendingEvents();
+            needsToFlushComponentLogs = false;
+          }
+          function getEnvironmentNames() {
+            return Array.from(knownEnvironmentNames);
+          }
+          function shouldFilterVirtual(data, secondaryEnv) {
+            // For purposes of filtering Server Components are always Function Components.
+            // Environment will be used to filter Server vs Client.
+            // Technically they can be forwardRef and memo too but those filters will go away
+            // as those become just plain user space function components like any HoC.
+            if (hideElementsWithTypes.has(types_ElementTypeFunction)) {
+              return true;
+            }
+            if (hideElementsWithDisplayNames.size > 0) {
+              var displayName = data.name;
+              if (displayName != null) {
+                // eslint-disable-next-line no-for-of-loops/no-for-of-loops
+                var _iterator4 = renderer_createForOfIteratorHelper(hideElementsWithDisplayNames),
+                  _step4;
+                try {
+                  for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+                    var displayNameRegExp = _step4.value;
+                    if (displayNameRegExp.test(displayName)) {
+                      return true;
+                    }
+                  }
+                } catch (err) {
+                  _iterator4.e(err);
+                } finally {
+                  _iterator4.f();
+                }
+              }
+            }
+            if ((data.env == null || hideElementsWithEnvs.has(data.env)) && (secondaryEnv === null || hideElementsWithEnvs.has(secondaryEnv))) {
+              // If a Component has two environments, you have to filter both for it not to appear.
+              return true;
+            }
+            return false;
+          } // NOTICE Keep in sync with get*ForFiber methods
+
+          function shouldFilterFiber(fiber) {
+            var tag = fiber.tag,
+              type = fiber.type,
+              key = fiber.key;
+            switch (tag) {
+              case DehydratedSuspenseComponent:
+                // TODO: ideally we would show dehydrated Suspense immediately.
+                // However, it has some special behavior (like disconnecting
+                // an alternate and turning into real Suspense) which breaks DevTools.
+                // For now, ignore it, and only show it once it gets hydrated.
+                // https://github.com/bvaughn/react-devtools-experimental/issues/197
+                return true;
+              case HostPortal:
+              case HostText:
+              case LegacyHiddenComponent:
+              case OffscreenComponent:
+              case Throw:
+                return true;
+              case HostRoot:
+                // It is never valid to filter the root element.
+                return false;
+              case Fragment:
+                return key === null;
+              default:
+                var typeSymbol = getTypeSymbol(type);
+                switch (typeSymbol) {
+                  case CONCURRENT_MODE_NUMBER:
+                  case CONCURRENT_MODE_SYMBOL_STRING:
+                  case DEPRECATED_ASYNC_MODE_SYMBOL_STRING:
+                  case STRICT_MODE_NUMBER:
+                  case STRICT_MODE_SYMBOL_STRING:
+                    return true;
+                  default:
+                    break;
+                }
+            }
+            var elementType = getElementTypeForFiber(fiber);
+            if (hideElementsWithTypes.has(elementType)) {
+              return true;
+            }
+            if (hideElementsWithDisplayNames.size > 0) {
+              var displayName = getDisplayNameForFiber(fiber);
+              if (displayName != null) {
+                // eslint-disable-next-line no-for-of-loops/no-for-of-loops
+                var _iterator5 = renderer_createForOfIteratorHelper(hideElementsWithDisplayNames),
+                  _step5;
+                try {
+                  for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+                    var displayNameRegExp = _step5.value;
+                    if (displayNameRegExp.test(displayName)) {
+                      return true;
+                    }
+                  }
+                } catch (err) {
+                  _iterator5.e(err);
+                } finally {
+                  _iterator5.f();
+                }
+              }
+            }
+            if (hideElementsWithEnvs.has('Client')) {
+              // If we're filtering out the Client environment we should filter out all
+              // "Client Components". Technically that also includes the built-ins but
+              // since that doesn't actually include any additional code loading it's
+              // useful to not filter out the built-ins. Those can be filtered separately.
+              // There's no other way to filter out just Function components on the Client.
+              // Therefore, this only filters Class and Function components.
+              switch (tag) {
+                case ClassComponent:
+                case IncompleteClassComponent:
+                case IncompleteFunctionComponent:
+                case FunctionComponent:
+                case IndeterminateComponent:
+                case ForwardRef:
+                case MemoComponent:
+                case SimpleMemoComponent:
+                  return true;
+              }
+            }
+            /* DISABLED: https://github.com/facebook/react/pull/28417
+            if (hideElementsWithPaths.size > 0) {
+              const source = getSourceForFiber(fiber);
+               if (source != null) {
+                const {fileName} = source;
+                // eslint-disable-next-line no-for-of-loops/no-for-of-loops
+                for (const pathRegExp of hideElementsWithPaths) {
+                  if (pathRegExp.test(fileName)) {
+                    return true;
+                  }
+                }
+              }
+            }
+            */
+
+            return false;
+          } // NOTICE Keep in sync with shouldFilterFiber() and other get*ForFiber methods
+
+          function getElementTypeForFiber(fiber) {
+            var type = fiber.type,
+              tag = fiber.tag;
+            switch (tag) {
+              case ActivityComponent:
+                return ElementTypeActivity;
+              case ClassComponent:
+              case IncompleteClassComponent:
+                return types_ElementTypeClass;
+              case IncompleteFunctionComponent:
+              case FunctionComponent:
+              case IndeterminateComponent:
+                return types_ElementTypeFunction;
+              case ForwardRef:
+                return types_ElementTypeForwardRef;
+              case HostRoot:
+                return ElementTypeRoot;
+              case HostComponent:
+              case HostHoistable:
+              case HostSingleton:
+                return ElementTypeHostComponent;
+              case HostPortal:
+              case HostText:
+              case Fragment:
+                return ElementTypeOtherOrUnknown;
+              case MemoComponent:
+              case SimpleMemoComponent:
+                return types_ElementTypeMemo;
+              case SuspenseComponent:
+                return ElementTypeSuspense;
+              case SuspenseListComponent:
+                return ElementTypeSuspenseList;
+              case TracingMarkerComponent:
+                return ElementTypeTracingMarker;
+              case ViewTransitionComponent:
+                return ElementTypeViewTransition;
+              default:
+                var typeSymbol = getTypeSymbol(type);
+                switch (typeSymbol) {
+                  case CONCURRENT_MODE_NUMBER:
+                  case CONCURRENT_MODE_SYMBOL_STRING:
+                  case DEPRECATED_ASYNC_MODE_SYMBOL_STRING:
+                    return ElementTypeOtherOrUnknown;
+                  case PROVIDER_NUMBER:
+                  case PROVIDER_SYMBOL_STRING:
+                    return ElementTypeContext;
+                  case CONTEXT_NUMBER:
+                  case CONTEXT_SYMBOL_STRING:
+                    return ElementTypeContext;
+                  case STRICT_MODE_NUMBER:
+                  case STRICT_MODE_SYMBOL_STRING:
+                    return ElementTypeOtherOrUnknown;
+                  case PROFILER_NUMBER:
+                  case PROFILER_SYMBOL_STRING:
+                    return ElementTypeProfiler;
+                  default:
+                    return ElementTypeOtherOrUnknown;
+                }
+            }
+          } // When a mount or update is in progress, this value tracks the root that is being operated on.
+
+          var currentRoot = null; // Removes a Fiber (and its alternate) from the Maps used to track their id.
+          // This method should always be called when a Fiber is unmounting.
+
+          function untrackFiber(nearestInstance, fiber) {
+            if (forceErrorForFibers.size > 0) {
+              forceErrorForFibers.delete(fiber);
+              if (fiber.alternate) {
+                forceErrorForFibers.delete(fiber.alternate);
+              }
+              if (forceErrorForFibers.size === 0 && setErrorHandler != null) {
+                setErrorHandler(shouldErrorFiberAlwaysNull);
+              }
+            }
+            if (forceFallbackForFibers.size > 0) {
+              forceFallbackForFibers.delete(fiber);
+              if (fiber.alternate) {
+                forceFallbackForFibers.delete(fiber.alternate);
+              }
+              if (forceFallbackForFibers.size === 0 && setSuspenseHandler != null) {
+                setSuspenseHandler(shouldSuspendFiberAlwaysFalse);
+              }
+            } // TODO: Consider using a WeakMap instead. The only thing where that doesn't work
+            // is React Native Paper which tracks tags but that support is eventually going away
+            // and can use the old findFiberByHostInstance strategy.
+
+            if (fiber.tag === HostHoistable) {
+              releaseHostResource(nearestInstance, fiber.memoizedState);
+            } else if (fiber.tag === HostComponent || fiber.tag === HostText || fiber.tag === HostSingleton) {
+              releaseHostInstance(nearestInstance, fiber.stateNode);
+            } // Recursively clean up any filtered Fibers below this one as well since
+            // we won't recordUnmount on those.
+
+            for (var child = fiber.child; child !== null; child = child.sibling) {
+              if (shouldFilterFiber(child)) {
+                untrackFiber(nearestInstance, child);
+              }
+            }
+          }
+          function getChangeDescription(prevFiber, nextFiber) {
+            switch (nextFiber.tag) {
+              case ClassComponent:
+                if (prevFiber === null) {
+                  return {
+                    context: null,
+                    didHooksChange: false,
+                    isFirstMount: true,
+                    props: null,
+                    state: null
+                  };
+                } else {
+                  var data = {
+                    context: getContextChanged(prevFiber, nextFiber),
+                    didHooksChange: false,
+                    isFirstMount: false,
+                    props: getChangedKeys(prevFiber.memoizedProps, nextFiber.memoizedProps),
+                    state: getChangedKeys(prevFiber.memoizedState, nextFiber.memoizedState)
+                  };
+                  return data;
+                }
+              case IncompleteFunctionComponent:
+              case FunctionComponent:
+              case IndeterminateComponent:
+              case ForwardRef:
+              case MemoComponent:
+              case SimpleMemoComponent:
+                if (prevFiber === null) {
+                  return {
+                    context: null,
+                    didHooksChange: false,
+                    isFirstMount: true,
+                    props: null,
+                    state: null
+                  };
+                } else {
+                  var indices = getChangedHooksIndices(prevFiber.memoizedState, nextFiber.memoizedState);
+                  var _data = {
+                    context: getContextChanged(prevFiber, nextFiber),
+                    didHooksChange: indices !== null && indices.length > 0,
+                    isFirstMount: false,
+                    props: getChangedKeys(prevFiber.memoizedProps, nextFiber.memoizedProps),
+                    state: null,
+                    hooks: indices
+                  }; // Only traverse the hooks list once, depending on what info we're returning.
+
+                  return _data;
+                }
+              default:
+                return null;
+            }
+          }
+          function getContextChanged(prevFiber, nextFiber) {
+            var prevContext = prevFiber.dependencies && prevFiber.dependencies.firstContext;
+            var nextContext = nextFiber.dependencies && nextFiber.dependencies.firstContext;
+            while (prevContext && nextContext) {
+              // Note this only works for versions of React that support this key (e.v. 18+)
+              // For older versions, there's no good way to read the current context value after render has completed.
+              // This is because React maintains a stack of context values during render,
+              // but by the time DevTools is called, render has finished and the stack is empty.
+              if (prevContext.context !== nextContext.context) {
+                // If the order of context has changed, then the later context values might have
+                // changed too but the main reason it rerendered was earlier. Either an earlier
+                // context changed value but then we would have exited already. If we end up here
+                // it's because a state or props change caused the order of contexts used to change.
+                // So the main cause is not the contexts themselves.
+                return false;
+              }
+              if (!shared_objectIs(prevContext.memoizedValue, nextContext.memoizedValue)) {
+                return true;
+              }
+              prevContext = prevContext.next;
+              nextContext = nextContext.next;
+            }
+            return false;
+          }
+          function isHookThatCanScheduleUpdate(hookObject) {
+            var queue = hookObject.queue;
+            if (!queue) {
+              return false;
+            }
+            var boundHasOwnProperty = shared_hasOwnProperty.bind(queue); // Detect the shape of useState() / useReducer() / useTransition()
+            // using the attributes that are unique to these hooks
+            // but also stable (e.g. not tied to current Lanes implementation)
+            // We don't check for dispatch property, because useTransition doesn't have it
+
+            if (boundHasOwnProperty('pending')) {
+              return true;
+            } // Detect useSyncExternalStore()
+
+            return boundHasOwnProperty('value') && boundHasOwnProperty('getSnapshot') && typeof queue.getSnapshot === 'function';
+          }
+          function didStatefulHookChange(prev, next) {
+            var prevMemoizedState = prev.memoizedState;
+            var nextMemoizedState = next.memoizedState;
+            if (isHookThatCanScheduleUpdate(prev)) {
+              return prevMemoizedState !== nextMemoizedState;
+            }
+            return false;
+          }
+          function getChangedHooksIndices(prev, next) {
+            if (prev == null || next == null) {
+              return null;
+            }
+            var indices = [];
+            var index = 0;
+            while (next !== null) {
+              if (didStatefulHookChange(prev, next)) {
+                indices.push(index);
+              }
+              next = next.next;
+              prev = prev.next;
+              index++;
+            }
+            return indices;
+          }
+          function getChangedKeys(prev, next) {
+            if (prev == null || next == null) {
+              return null;
+            }
+            var keys = new Set([].concat(fiber_renderer_toConsumableArray(Object.keys(prev)), fiber_renderer_toConsumableArray(Object.keys(next))));
+            var changedKeys = []; // eslint-disable-next-line no-for-of-loops/no-for-of-loops
+
+            var _iterator6 = renderer_createForOfIteratorHelper(keys),
+              _step6;
+            try {
+              for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+                var key = _step6.value;
+                if (prev[key] !== next[key]) {
+                  changedKeys.push(key);
+                }
+              }
+            } catch (err) {
+              _iterator6.e(err);
+            } finally {
+              _iterator6.f();
+            }
+            return changedKeys;
+          }
+          function didFiberRender(prevFiber, nextFiber) {
+            switch (nextFiber.tag) {
+              case ClassComponent:
+              case FunctionComponent:
+              case ContextConsumer:
+              case MemoComponent:
+              case SimpleMemoComponent:
+              case ForwardRef:
+                // For types that execute user code, we check PerformedWork effect.
+                // We don't reflect bailouts (either referential or sCU) in DevTools.
+                // TODO: This flag is a leaked implementation detail. Once we start
+                // releasing DevTools in lockstep with React, we should import a
+                // function from the reconciler instead.
+                var PerformedWork = 1;
+                return (getFiberFlags(nextFiber) & PerformedWork) === PerformedWork;
+              // Note: ContextConsumer only gets PerformedWork effect in 16.3.3+
+              // so it won't get highlighted with React 16.3.0 to 16.3.2.
+
+              default:
+                // For host components and other types, we compare inputs
+                // to determine whether something is an update.
+                return prevFiber.memoizedProps !== nextFiber.memoizedProps || prevFiber.memoizedState !== nextFiber.memoizedState || prevFiber.ref !== nextFiber.ref;
+            }
+          }
+          var pendingOperations = [];
+          var pendingRealUnmountedIDs = [];
+          var pendingOperationsQueue = [];
+          var pendingStringTable = new Map();
+          var pendingStringTableLength = 0;
+          var pendingUnmountedRootID = null;
+          function pushOperation(op) {
+            if (false) {}
+            pendingOperations.push(op);
+          }
+          function shouldBailoutWithPendingOperations() {
+            if (isProfiling) {
+              if (currentCommitProfilingMetadata != null && currentCommitProfilingMetadata.durations.length > 0) {
+                return false;
+              }
+            }
+            return pendingOperations.length === 0 && pendingRealUnmountedIDs.length === 0 && pendingUnmountedRootID === null;
+          }
+          function flushOrQueueOperations(operations) {
+            if (shouldBailoutWithPendingOperations()) {
+              return;
+            }
+            if (pendingOperationsQueue !== null) {
+              pendingOperationsQueue.push(operations);
+            } else {
+              hook.emit('operations', operations);
+            }
+          }
+          function recordConsoleLogs(instance, componentLogsEntry) {
+            if (componentLogsEntry === undefined) {
+              if (instance.logCount === 0) {
+                // Nothing has changed.
+                return false;
+              } // Reset to zero.
+
+              instance.logCount = 0;
+              pushOperation(TREE_OPERATION_UPDATE_ERRORS_OR_WARNINGS);
+              pushOperation(instance.id);
+              pushOperation(0);
+              pushOperation(0);
+              return true;
+            } else {
+              var totalCount = componentLogsEntry.errorsCount + componentLogsEntry.warningsCount;
+              if (instance.logCount === totalCount) {
+                // Nothing has changed.
+                return false;
+              } // Update counts.
+
+              instance.logCount = totalCount;
+              pushOperation(TREE_OPERATION_UPDATE_ERRORS_OR_WARNINGS);
+              pushOperation(instance.id);
+              pushOperation(componentLogsEntry.errorsCount);
+              pushOperation(componentLogsEntry.warningsCount);
+              return true;
+            }
+          }
+          function flushPendingEvents(root) {
+            if (shouldBailoutWithPendingOperations()) {
+              // If we aren't profiling, we can just bail out here.
+              // No use sending an empty update over the bridge.
+              //
+              // The Profiler stores metadata for each commit and reconstructs the app tree per commit using:
+              // (1) an initial tree snapshot and
+              // (2) the operations array for each commit
+              // Because of this, it's important that the operations and metadata arrays align,
+              // So it's important not to omit even empty operations while profiling is active.
+              return;
+            }
+            var numUnmountIDs = pendingRealUnmountedIDs.length + (pendingUnmountedRootID === null ? 0 : 1);
+            var operations = new Array(
+            // Identify which renderer this update is coming from.
+            2 +
+            // [rendererID, rootFiberID]
+            // How big is the string table?
+            1 +
+            // [stringTableLength]
+            // Then goes the actual string table.
+            pendingStringTableLength + (
+            // All unmounts are batched in a single message.
+            // [TREE_OPERATION_REMOVE, removedIDLength, ...ids]
+            numUnmountIDs > 0 ? 2 + numUnmountIDs : 0) +
+            // Regular operations
+            pendingOperations.length); // Identify which renderer this update is coming from.
+            // This enables roots to be mapped to renderers,
+            // Which in turn enables fiber props, states, and hooks to be inspected.
+
+            var i = 0;
+            operations[i++] = rendererID;
+            if (currentRoot === null) {
+              // TODO: This is not always safe so this field is probably not needed.
+              operations[i++] = -1;
+            } else {
+              operations[i++] = currentRoot.id;
+            } // Now fill in the string table.
+            // [stringTableLength, str1Length, ...str1, str2Length, ...str2, ...]
+
+            operations[i++] = pendingStringTableLength;
+            pendingStringTable.forEach(function (entry, stringKey) {
+              var encodedString = entry.encodedString; // Don't use the string length.
+              // It won't work for multibyte characters (like emoji).
+
+              var length = encodedString.length;
+              operations[i++] = length;
+              for (var j = 0; j < length; j++) {
+                operations[i + j] = encodedString[j];
+              }
+              i += length;
+            });
+            if (numUnmountIDs > 0) {
+              // All unmounts except roots are batched in a single message.
+              operations[i++] = TREE_OPERATION_REMOVE; // The first number is how many unmounted IDs we're gonna send.
+
+              operations[i++] = numUnmountIDs; // Fill in the real unmounts in the reverse order.
+              // They were inserted parents-first by React, but we want children-first.
+              // So we traverse our array backwards.
+
+              for (var j = 0; j < pendingRealUnmountedIDs.length; j++) {
+                operations[i++] = pendingRealUnmountedIDs[j];
+              } // The root ID should always be unmounted last.
+
+              if (pendingUnmountedRootID !== null) {
+                operations[i] = pendingUnmountedRootID;
+                i++;
+              }
+            } // Fill in the rest of the operations.
+
+            for (var _j = 0; _j < pendingOperations.length; _j++) {
+              operations[i + _j] = pendingOperations[_j];
+            }
+            i += pendingOperations.length; // Let the frontend know about tree operations.
+
+            flushOrQueueOperations(operations); // Reset all of the pending state now that we've told the frontend about it.
+
+            pendingOperations.length = 0;
+            pendingRealUnmountedIDs.length = 0;
+            pendingUnmountedRootID = null;
+            pendingStringTable.clear();
+            pendingStringTableLength = 0;
+          }
+          function getStringID(string) {
+            if (string === null) {
+              return 0;
+            }
+            var existingEntry = pendingStringTable.get(string);
+            if (existingEntry !== undefined) {
+              return existingEntry.id;
+            }
+            var id = pendingStringTable.size + 1;
+            var encodedString = utfEncodeString(string);
+            pendingStringTable.set(string, {
+              encodedString: encodedString,
+              id: id
+            }); // The string table total length needs to account both for the string length,
+            // and for the array item that contains the length itself.
+            //
+            // Don't use string length for this table.
+            // It won't work for multibyte characters (like emoji).
+
+            pendingStringTableLength += encodedString.length + 1;
+            return id;
+          }
+          function recordMount(fiber, parentInstance) {
+            var isRoot = fiber.tag === HostRoot;
+            var fiberInstance;
+            if (isRoot) {
+              var entry = rootToFiberInstanceMap.get(fiber.stateNode);
+              if (entry === undefined) {
+                throw new Error('The root should have been registered at this point');
+              }
+              fiberInstance = entry;
+            } else {
+              fiberInstance = createFiberInstance(fiber);
+            }
+            idToDevToolsInstanceMap.set(fiberInstance.id, fiberInstance);
+            var id = fiberInstance.id;
+            if (__DEBUG__) {
+              debug('recordMount()', fiberInstance, parentInstance);
+            }
+            var isProfilingSupported = fiber.hasOwnProperty('treeBaseDuration');
+            if (isRoot) {
+              var hasOwnerMetadata = fiber.hasOwnProperty('_debugOwner'); // Adding a new field here would require a bridge protocol version bump (a backwads breaking change).
+              // Instead let's re-purpose a pre-existing field to carry more information.
+
+              var profilingFlags = 0;
+              if (isProfilingSupported) {
+                profilingFlags = PROFILING_FLAG_BASIC_SUPPORT;
+                if (typeof injectProfilingHooks === 'function') {
+                  profilingFlags |= PROFILING_FLAG_TIMELINE_SUPPORT;
+                }
+              } // Set supportsStrictMode to false for production renderer builds
+
+              var isProductionBuildOfRenderer = renderer.bundleType === 0;
+              pushOperation(TREE_OPERATION_ADD);
+              pushOperation(id);
+              pushOperation(ElementTypeRoot);
+              pushOperation((fiber.mode & StrictModeBits) !== 0 ? 1 : 0);
+              pushOperation(profilingFlags);
+              pushOperation(!isProductionBuildOfRenderer && StrictModeBits !== 0 ? 1 : 0);
+              pushOperation(hasOwnerMetadata ? 1 : 0);
+              if (isProfiling) {
+                if (displayNamesByRootID !== null) {
+                  displayNamesByRootID.set(id, getDisplayNameForRoot(fiber));
+                }
+              }
+            } else {
+              var key = fiber.key;
+              var displayName = getDisplayNameForFiber(fiber);
+              var elementType = getElementTypeForFiber(fiber); // Finding the owner instance might require traversing the whole parent path which
+              // doesn't have great big O notation. Ideally we'd lazily fetch the owner when we
+              // need it but we have some synchronous operations in the front end like Alt+Left
+              // which selects the owner immediately. Typically most owners are only a few parents
+              // away so maybe it's not so bad.
+
+              var debugOwner = getUnfilteredOwner(fiber);
+              var ownerInstance = findNearestOwnerInstance(parentInstance, debugOwner);
+              if (ownerInstance !== null && debugOwner === fiber._debugOwner && fiber._debugStack != null && ownerInstance.source === null) {
+                // The new Fiber is directly owned by the ownerInstance. Therefore somewhere on
+                // the debugStack will be a stack frame inside the ownerInstance's source.
+                ownerInstance.source = fiber._debugStack;
+              }
+              var ownerID = ownerInstance === null ? 0 : ownerInstance.id;
+              var parentID = parentInstance ? parentInstance.kind === FILTERED_FIBER_INSTANCE ?
+              // A Filtered Fiber Instance will always have a Virtual Instance as a parent.
+              parentInstance.parent.id : parentInstance.id : 0;
+              var displayNameStringID = getStringID(displayName); // This check is a guard to handle a React element that has been modified
+              // in such a way as to bypass the default stringification of the "key" property.
+
+              var keyString = key === null ? null : String(key);
+              var keyStringID = getStringID(keyString);
+              pushOperation(TREE_OPERATION_ADD);
+              pushOperation(id);
+              pushOperation(elementType);
+              pushOperation(parentID);
+              pushOperation(ownerID);
+              pushOperation(displayNameStringID);
+              pushOperation(keyStringID); // If this subtree has a new mode, let the frontend know.
+
+              if ((fiber.mode & StrictModeBits) !== 0) {
+                var parentFiber = null;
+                var parentFiberInstance = parentInstance;
+                while (parentFiberInstance !== null) {
+                  if (parentFiberInstance.kind === FIBER_INSTANCE) {
+                    parentFiber = parentFiberInstance.data;
+                    break;
+                  }
+                  parentFiberInstance = parentFiberInstance.parent;
+                }
+                if (parentFiber === null || (parentFiber.mode & StrictModeBits) === 0) {
+                  pushOperation(TREE_OPERATION_SET_SUBTREE_MODE);
+                  pushOperation(id);
+                  pushOperation(StrictMode);
+                }
+              }
+            }
+            var componentLogsEntry = fiberToComponentLogsMap.get(fiber);
+            if (componentLogsEntry === undefined && fiber.alternate !== null) {
+              componentLogsEntry = fiberToComponentLogsMap.get(fiber.alternate);
+            }
+            recordConsoleLogs(fiberInstance, componentLogsEntry);
+            if (isProfilingSupported) {
+              recordProfilingDurations(fiberInstance, null);
+            }
+            return fiberInstance;
+          }
+          function recordVirtualMount(instance, parentInstance, secondaryEnv) {
+            var id = instance.id;
+            idToDevToolsInstanceMap.set(id, instance);
+            var componentInfo = instance.data;
+            var key = typeof componentInfo.key === 'string' ? componentInfo.key : null;
+            var env = componentInfo.env;
+            var displayName = componentInfo.name || '';
+            if (typeof env === 'string') {
+              // We model environment as an HoC name for now.
+              if (secondaryEnv !== null) {
+                displayName = secondaryEnv + '(' + displayName + ')';
+              }
+              displayName = env + '(' + displayName + ')';
+            }
+            var elementType = types_ElementTypeVirtual; // Finding the owner instance might require traversing the whole parent path which
+            // doesn't have great big O notation. Ideally we'd lazily fetch the owner when we
+            // need it but we have some synchronous operations in the front end like Alt+Left
+            // which selects the owner immediately. Typically most owners are only a few parents
+            // away so maybe it's not so bad.
+
+            var debugOwner = getUnfilteredOwner(componentInfo);
+            var ownerInstance = findNearestOwnerInstance(parentInstance, debugOwner);
+            if (ownerInstance !== null && debugOwner === componentInfo.owner && componentInfo.debugStack != null && ownerInstance.source === null) {
+              // The new Fiber is directly owned by the ownerInstance. Therefore somewhere on
+              // the debugStack will be a stack frame inside the ownerInstance's source.
+              ownerInstance.source = componentInfo.debugStack;
+            }
+            var ownerID = ownerInstance === null ? 0 : ownerInstance.id;
+            var parentID = parentInstance ? parentInstance.kind === FILTERED_FIBER_INSTANCE ?
+            // A Filtered Fiber Instance will always have a Virtual Instance as a parent.
+            parentInstance.parent.id : parentInstance.id : 0;
+            var displayNameStringID = getStringID(displayName); // This check is a guard to handle a React element that has been modified
+            // in such a way as to bypass the default stringification of the "key" property.
+
+            var keyString = key === null ? null : String(key);
+            var keyStringID = getStringID(keyString);
+            pushOperation(TREE_OPERATION_ADD);
+            pushOperation(id);
+            pushOperation(elementType);
+            pushOperation(parentID);
+            pushOperation(ownerID);
+            pushOperation(displayNameStringID);
+            pushOperation(keyStringID);
+            var componentLogsEntry = componentInfoToComponentLogsMap.get(componentInfo);
+            recordConsoleLogs(instance, componentLogsEntry);
+          }
+          function recordUnmount(fiberInstance) {
+            var fiber = fiberInstance.data;
+            if (__DEBUG__) {
+              debug('recordUnmount()', fiberInstance, reconcilingParent);
+            }
+            if (trackedPathMatchInstance === fiberInstance) {
+              // We're in the process of trying to restore previous selection.
+              // If this fiber matched but is being unmounted, there's no use trying.
+              // Reset the state so we don't keep holding onto it.
+              setTrackedPath(null);
+            }
+            var id = fiberInstance.id;
+            var isRoot = fiber.tag === HostRoot;
+            if (isRoot) {
+              // Roots must be removed only after all children have been removed.
+              // So we track it separately.
+              pendingUnmountedRootID = id;
+            } else {
+              // To maintain child-first ordering,
+              // we'll push it into one of these queues,
+              // and later arrange them in the correct order.
+              pendingRealUnmountedIDs.push(id);
+            }
+            idToDevToolsInstanceMap.delete(fiberInstance.id);
+            untrackFiber(fiberInstance, fiber);
+          } // Running state of the remaining children from the previous version of this parent that
+          // we haven't yet added back. This should be reset anytime we change parent.
+          // Any remaining ones at the end will be deleted.
+
+          var remainingReconcilingChildren = null; // The previously placed child.
+
+          var previouslyReconciledSibling = null; // To save on stack allocation and ensure that they are updated as a pair, we also store
+          // the current parent here as well.
+
+          var reconcilingParent = null;
+          function insertChild(instance) {
+            var parentInstance = reconcilingParent;
+            if (parentInstance === null) {
+              // This instance is at the root.
+              return;
+            } // Place it in the parent.
+
+            instance.parent = parentInstance;
+            if (previouslyReconciledSibling === null) {
+              previouslyReconciledSibling = instance;
+              parentInstance.firstChild = instance;
+            } else {
+              previouslyReconciledSibling.nextSibling = instance;
+              previouslyReconciledSibling = instance;
+            }
+            instance.nextSibling = null;
+          }
+          function moveChild(instance, previousSibling) {
+            removeChild(instance, previousSibling);
+            insertChild(instance);
+          }
+          function removeChild(instance, previousSibling) {
+            if (instance.parent === null) {
+              if (remainingReconcilingChildren === instance) {
+                throw new Error('Remaining children should not have items with no parent');
+              } else if (instance.nextSibling !== null) {
+                throw new Error('A deleted instance should not have next siblings');
+              } // Already deleted.
+
+              return;
+            }
+            var parentInstance = reconcilingParent;
+            if (parentInstance === null) {
+              throw new Error('Should not have a parent if we are at the root');
+            }
+            if (instance.parent !== parentInstance) {
+              throw new Error('Cannot remove a node from a different parent than is being reconciled.');
+            } // Remove an existing child from its current position, which we assume is in the
+            // remainingReconcilingChildren set.
+
+            if (previousSibling === null) {
+              // We're first in the remaining set. Remove us.
+              if (remainingReconcilingChildren !== instance) {
+                throw new Error('Expected a placed child to be moved from the remaining set.');
+              }
+              remainingReconcilingChildren = instance.nextSibling;
+            } else {
+              previousSibling.nextSibling = instance.nextSibling;
+            }
+            instance.nextSibling = null;
+            instance.parent = null;
+          }
+          function unmountRemainingChildren() {
+            var child = remainingReconcilingChildren;
+            while (child !== null) {
+              unmountInstanceRecursively(child);
+              child = remainingReconcilingChildren;
+            }
+          }
+          function mountVirtualInstanceRecursively(virtualInstance, firstChild, lastChild,
+          // non-inclusive
+          traceNearestHostComponentUpdate, virtualLevel // the nth level of virtual instances
+          ) {
+            // If we have the tree selection from previous reload, try to match this Instance.
+            // Also remember whether to do the same for siblings.
+            var mightSiblingsBeOnTrackedPath = updateVirtualTrackedPathStateBeforeMount(virtualInstance, reconcilingParent);
+            var stashedParent = reconcilingParent;
+            var stashedPrevious = previouslyReconciledSibling;
+            var stashedRemaining = remainingReconcilingChildren; // Push a new DevTools instance parent while reconciling this subtree.
+
+            reconcilingParent = virtualInstance;
+            previouslyReconciledSibling = null;
+            remainingReconcilingChildren = null;
+            try {
+              mountVirtualChildrenRecursively(firstChild, lastChild, traceNearestHostComponentUpdate, virtualLevel + 1); // Must be called after all children have been appended.
+
+              recordVirtualProfilingDurations(virtualInstance);
+            } finally {
+              reconcilingParent = stashedParent;
+              previouslyReconciledSibling = stashedPrevious;
+              remainingReconcilingChildren = stashedRemaining;
+              updateTrackedPathStateAfterMount(mightSiblingsBeOnTrackedPath);
+            }
+          }
+          function recordVirtualUnmount(instance) {
+            if (trackedPathMatchInstance === instance) {
+              // We're in the process of trying to restore previous selection.
+              // If this fiber matched but is being unmounted, there's no use trying.
+              // Reset the state so we don't keep holding onto it.
+              setTrackedPath(null);
+            }
+            var id = instance.id;
+            pendingRealUnmountedIDs.push(id);
+          }
+          function getSecondaryEnvironmentName(debugInfo, index) {
+            if (debugInfo != null) {
+              var componentInfo = debugInfo[index];
+              for (var i = index + 1; i < debugInfo.length; i++) {
+                var debugEntry = debugInfo[i];
+                if (typeof debugEntry.env === 'string') {
+                  // If the next environment is different then this component was the boundary
+                  // and it changed before entering the next component. So we assign this
+                  // component a secondary environment.
+                  return componentInfo.env !== debugEntry.env ? debugEntry.env : null;
+                }
+              }
+            }
+            return null;
+          }
+          function mountVirtualChildrenRecursively(firstChild, lastChild,
+          // non-inclusive
+          traceNearestHostComponentUpdate, virtualLevel // the nth level of virtual instances
+          ) {
+            // Iterate over siblings rather than recursing.
+            // This reduces the chance of stack overflow for wide trees (e.g. lists with many items).
+            var fiber = firstChild;
+            var previousVirtualInstance = null;
+            var previousVirtualInstanceFirstFiber = firstChild;
+            while (fiber !== null && fiber !== lastChild) {
+              var level = 0;
+              if (fiber._debugInfo) {
+                for (var i = 0; i < fiber._debugInfo.length; i++) {
+                  var debugEntry = fiber._debugInfo[i];
+                  if (typeof debugEntry.name !== 'string') {
+                    // Not a Component. Some other Debug Info.
+                    continue;
+                  } // Scan up until the next Component to see if this component changed environment.
+
+                  var componentInfo = debugEntry;
+                  var secondaryEnv = getSecondaryEnvironmentName(fiber._debugInfo, i);
+                  if (componentInfo.env != null) {
+                    knownEnvironmentNames.add(componentInfo.env);
+                  }
+                  if (secondaryEnv !== null) {
+                    knownEnvironmentNames.add(secondaryEnv);
+                  }
+                  if (shouldFilterVirtual(componentInfo, secondaryEnv)) {
+                    // Skip.
+                    continue;
+                  }
+                  if (level === virtualLevel) {
+                    if (previousVirtualInstance === null ||
+                    // Consecutive children with the same debug entry as a parent gets
+                    // treated as if they share the same virtual instance.
+                    previousVirtualInstance.data !== debugEntry) {
+                      if (previousVirtualInstance !== null) {
+                        // Mount any previous children that should go into the previous parent.
+                        mountVirtualInstanceRecursively(previousVirtualInstance, previousVirtualInstanceFirstFiber, fiber, traceNearestHostComponentUpdate, virtualLevel);
+                      }
+                      previousVirtualInstance = createVirtualInstance(componentInfo);
+                      recordVirtualMount(previousVirtualInstance, reconcilingParent, secondaryEnv);
+                      insertChild(previousVirtualInstance);
+                      previousVirtualInstanceFirstFiber = fiber;
+                    }
+                    level++;
+                    break;
+                  } else {
+                    level++;
+                  }
+                }
+              }
+              if (level === virtualLevel) {
+                if (previousVirtualInstance !== null) {
+                  // If we were working on a virtual instance and this is not a virtual
+                  // instance, then we end the sequence and mount any previous children
+                  // that should go into the previous virtual instance.
+                  mountVirtualInstanceRecursively(previousVirtualInstance, previousVirtualInstanceFirstFiber, fiber, traceNearestHostComponentUpdate, virtualLevel);
+                  previousVirtualInstance = null;
+                } // We've reached the end of the virtual levels, but not beyond,
+                // and now continue with the regular fiber.
+
+                mountFiberRecursively(fiber, traceNearestHostComponentUpdate);
+              }
+              fiber = fiber.sibling;
+            }
+            if (previousVirtualInstance !== null) {
+              // Mount any previous children that should go into the previous parent.
+              mountVirtualInstanceRecursively(previousVirtualInstance, previousVirtualInstanceFirstFiber, null, traceNearestHostComponentUpdate, virtualLevel);
+            }
+          }
+          function mountChildrenRecursively(firstChild, traceNearestHostComponentUpdate) {
+            mountVirtualChildrenRecursively(firstChild, null, traceNearestHostComponentUpdate, 0 // first level
+            );
+          }
+          function mountFiberRecursively(fiber, traceNearestHostComponentUpdate) {
+            var shouldIncludeInTree = !shouldFilterFiber(fiber);
+            var newInstance = null;
+            if (shouldIncludeInTree) {
+              newInstance = recordMount(fiber, reconcilingParent);
+              insertChild(newInstance);
+              if (__DEBUG__) {
+                debug('mountFiberRecursively()', newInstance, reconcilingParent);
+              }
+            } else if (reconcilingParent !== null && reconcilingParent.kind === VIRTUAL_INSTANCE) {
+              // If the parent is a Virtual Instance and we filtered this Fiber we include a
+              // hidden node.
+              if (reconcilingParent.data === fiber._debugOwner && fiber._debugStack != null && reconcilingParent.source === null) {
+                // The new Fiber is directly owned by the parent. Therefore somewhere on the
+                // debugStack will be a stack frame inside parent that we can use as its soruce.
+                reconcilingParent.source = fiber._debugStack;
+              }
+              newInstance = createFilteredFiberInstance(fiber);
+              insertChild(newInstance);
+              if (__DEBUG__) {
+                debug('mountFiberRecursively()', newInstance, reconcilingParent);
+              }
+            } // If we have the tree selection from previous reload, try to match this Fiber.
+            // Also remember whether to do the same for siblings.
+
+            var mightSiblingsBeOnTrackedPath = updateTrackedPathStateBeforeMount(fiber, newInstance);
+            var stashedParent = reconcilingParent;
+            var stashedPrevious = previouslyReconciledSibling;
+            var stashedRemaining = remainingReconcilingChildren;
+            if (newInstance !== null) {
+              // Push a new DevTools instance parent while reconciling this subtree.
+              reconcilingParent = newInstance;
+              previouslyReconciledSibling = null;
+              remainingReconcilingChildren = null;
+            }
+            try {
+              if (traceUpdatesEnabled) {
+                if (traceNearestHostComponentUpdate) {
+                  var elementType = getElementTypeForFiber(fiber); // If an ancestor updated, we should mark the nearest host nodes for highlighting.
+
+                  if (elementType === ElementTypeHostComponent) {
+                    traceUpdatesForNodes.add(fiber.stateNode);
+                    traceNearestHostComponentUpdate = false;
+                  }
+                } // We intentionally do not re-enable the traceNearestHostComponentUpdate flag in this branch,
+                // because we don't want to highlight every host node inside of a newly mounted subtree.
+              }
+              if (fiber.tag === HostHoistable) {
+                var nearestInstance = reconcilingParent;
+                if (nearestInstance === null) {
+                  throw new Error('Did not expect a host hoistable to be the root');
+                }
+                aquireHostResource(nearestInstance, fiber.memoizedState);
+              } else if (fiber.tag === HostComponent || fiber.tag === HostText || fiber.tag === HostSingleton) {
+                var _nearestInstance = reconcilingParent;
+                if (_nearestInstance === null) {
+                  throw new Error('Did not expect a host hoistable to be the root');
+                }
+                aquireHostInstance(_nearestInstance, fiber.stateNode);
+              }
+              if (fiber.tag === SuspenseComponent) {
+                var isTimedOut = fiber.memoizedState !== null;
+                if (isTimedOut) {
+                  // Special case: if Suspense mounts in a timed-out state,
+                  // get the fallback child from the inner fragment and mount
+                  // it as if it was our own child. Updates handle this too.
+                  var primaryChildFragment = fiber.child;
+                  var fallbackChildFragment = primaryChildFragment ? primaryChildFragment.sibling : null;
+                  if (fallbackChildFragment) {
+                    var fallbackChild = fallbackChildFragment.child;
+                    if (fallbackChild !== null) {
+                      updateTrackedPathStateBeforeMount(fallbackChildFragment, null);
+                      mountChildrenRecursively(fallbackChild, traceNearestHostComponentUpdate);
+                    }
+                  }
+                } else {
+                  var primaryChild = null;
+                  var areSuspenseChildrenConditionallyWrapped = OffscreenComponent === -1;
+                  if (areSuspenseChildrenConditionallyWrapped) {
+                    primaryChild = fiber.child;
+                  } else if (fiber.child !== null) {
+                    primaryChild = fiber.child.child;
+                    updateTrackedPathStateBeforeMount(fiber.child, null);
+                  }
+                  if (primaryChild !== null) {
+                    mountChildrenRecursively(primaryChild, traceNearestHostComponentUpdate);
+                  }
+                }
+              } else {
+                if (fiber.child !== null) {
+                  mountChildrenRecursively(fiber.child, traceNearestHostComponentUpdate);
+                }
+              }
+            } finally {
+              if (newInstance !== null) {
+                reconcilingParent = stashedParent;
+                previouslyReconciledSibling = stashedPrevious;
+                remainingReconcilingChildren = stashedRemaining;
+              }
+            } // We're exiting this Fiber now, and entering its siblings.
+            // If we have selection to restore, we might need to re-activate tracking.
+
+            updateTrackedPathStateAfterMount(mightSiblingsBeOnTrackedPath);
+          } // We use this to simulate unmounting for Suspense trees
+          // when we switch from primary to fallback, or deleting a subtree.
+
+          function unmountInstanceRecursively(instance) {
+            if (__DEBUG__) {
+              debug('unmountInstanceRecursively()', instance, reconcilingParent);
+            }
+            var stashedParent = reconcilingParent;
+            var stashedPrevious = previouslyReconciledSibling;
+            var stashedRemaining = remainingReconcilingChildren; // Push a new DevTools instance parent while reconciling this subtree.
+
+            reconcilingParent = instance;
+            previouslyReconciledSibling = null; // Move all the children of this instance to the remaining set.
+
+            remainingReconcilingChildren = instance.firstChild;
+            instance.firstChild = null;
+            try {
+              // Unmount the remaining set.
+              unmountRemainingChildren();
+            } finally {
+              reconcilingParent = stashedParent;
+              previouslyReconciledSibling = stashedPrevious;
+              remainingReconcilingChildren = stashedRemaining;
+            }
+            if (instance.kind === FIBER_INSTANCE) {
+              recordUnmount(instance);
+            } else if (instance.kind === VIRTUAL_INSTANCE) {
+              recordVirtualUnmount(instance);
+            } else {
+              untrackFiber(instance, instance.data);
+            }
+            removeChild(instance, null);
+          }
+          function recordProfilingDurations(fiberInstance, prevFiber) {
+            var id = fiberInstance.id;
+            var fiber = fiberInstance.data;
+            var actualDuration = fiber.actualDuration,
+              treeBaseDuration = fiber.treeBaseDuration;
+            fiberInstance.treeBaseDuration = treeBaseDuration || 0;
+            if (isProfiling) {
+              // It's important to update treeBaseDuration even if the current Fiber did not render,
+              // because it's possible that one of its descendants did.
+              if (prevFiber == null || treeBaseDuration !== prevFiber.treeBaseDuration) {
+                // Tree base duration updates are included in the operations typed array.
+                // So we have to convert them from milliseconds to microseconds so we can send them as ints.
+                var convertedTreeBaseDuration = Math.floor((treeBaseDuration || 0) * 1000);
+                pushOperation(TREE_OPERATION_UPDATE_TREE_BASE_DURATION);
+                pushOperation(id);
+                pushOperation(convertedTreeBaseDuration);
+              }
+              if (prevFiber == null || didFiberRender(prevFiber, fiber)) {
+                if (actualDuration != null) {
+                  // The actual duration reported by React includes time spent working on children.
+                  // This is useful information, but it's also useful to be able to exclude child durations.
+                  // The frontend can't compute this, since the immediate children may have been filtered out.
+                  // So we need to do this on the backend.
+                  // Note that this calculated self duration is not the same thing as the base duration.
+                  // The two are calculated differently (tree duration does not accumulate).
+                  var selfDuration = actualDuration;
+                  var child = fiber.child;
+                  while (child !== null) {
+                    selfDuration -= child.actualDuration || 0;
+                    child = child.sibling;
+                  } // If profiling is active, store durations for elements that were rendered during the commit.
+                  // Note that we should do this for any fiber we performed work on, regardless of its actualDuration value.
+                  // In some cases actualDuration might be 0 for fibers we worked on (particularly if we're using Date.now)
+                  // In other cases (e.g. Memo) actualDuration might be greater than 0 even if we "bailed out".
+
+                  var metadata = currentCommitProfilingMetadata;
+                  metadata.durations.push(id, actualDuration, selfDuration);
+                  metadata.maxActualDuration = Math.max(metadata.maxActualDuration, actualDuration);
+                  if (recordChangeDescriptions) {
+                    var changeDescription = getChangeDescription(prevFiber, fiber);
+                    if (changeDescription !== null) {
+                      if (metadata.changeDescriptions !== null) {
+                        metadata.changeDescriptions.set(id, changeDescription);
+                      }
+                    }
+                  }
+                }
+              } // If this Fiber was in the set of memoizedUpdaters we need to record
+              // it to be included in the description of the commit.
+
+              var fiberRoot = currentRoot.data.stateNode;
+              var updaters = fiberRoot.memoizedUpdaters;
+              if (updaters != null && (updaters.has(fiber) ||
+              // We check the alternate here because we're matching identity and
+              // prevFiber might be same as fiber.
+              fiber.alternate !== null && updaters.has(fiber.alternate))) {
+                var _metadata = currentCommitProfilingMetadata;
+                if (_metadata.updaters === null) {
+                  _metadata.updaters = [];
+                }
+                _metadata.updaters.push(instanceToSerializedElement(fiberInstance));
+              }
+            }
+          }
+          function recordVirtualProfilingDurations(virtualInstance) {
+            var id = virtualInstance.id;
+            var treeBaseDuration = 0; // Add up the base duration of the child instances. The virtual base duration
+            // will be the same as children's duration since we don't take up any render
+            // time in the virtual instance.
+
+            for (var child = virtualInstance.firstChild; child !== null; child = child.nextSibling) {
+              treeBaseDuration += child.treeBaseDuration;
+            }
+            if (isProfiling) {
+              var previousTreeBaseDuration = virtualInstance.treeBaseDuration;
+              if (treeBaseDuration !== previousTreeBaseDuration) {
+                // Tree base duration updates are included in the operations typed array.
+                // So we have to convert them from milliseconds to microseconds so we can send them as ints.
+                var convertedTreeBaseDuration = Math.floor((treeBaseDuration || 0) * 1000);
+                pushOperation(TREE_OPERATION_UPDATE_TREE_BASE_DURATION);
+                pushOperation(id);
+                pushOperation(convertedTreeBaseDuration);
+              }
+            }
+            virtualInstance.treeBaseDuration = treeBaseDuration;
+          }
+          function recordResetChildren(parentInstance) {
+            if (__DEBUG__) {
+              if (parentInstance.firstChild !== null) {
+                debug('recordResetChildren()', parentInstance.firstChild, parentInstance);
+              }
+            } // The frontend only really cares about the displayName, key, and children.
+            // The first two don't really change, so we are only concerned with the order of children here.
+            // This is trickier than a simple comparison though, since certain types of fibers are filtered.
+
+            var nextChildren = [];
+            var child = parentInstance.firstChild;
+            while (child !== null) {
+              if (child.kind === FILTERED_FIBER_INSTANCE) {
+                for (var innerChild = parentInstance.firstChild; innerChild !== null; innerChild = innerChild.nextSibling) {
+                  nextChildren.push(innerChild.id);
+                }
+              } else {
+                nextChildren.push(child.id);
+              }
+              child = child.nextSibling;
+            }
+            var numChildren = nextChildren.length;
+            if (numChildren < 2) {
+              // No need to reorder.
+              return;
+            }
+            pushOperation(TREE_OPERATION_REORDER_CHILDREN);
+            pushOperation(parentInstance.id);
+            pushOperation(numChildren);
+            for (var i = 0; i < nextChildren.length; i++) {
+              pushOperation(nextChildren[i]);
+            }
+          }
+          function updateVirtualInstanceRecursively(virtualInstance, nextFirstChild, nextLastChild,
+          // non-inclusive
+          prevFirstChild, traceNearestHostComponentUpdate, virtualLevel // the nth level of virtual instances
+          ) {
+            var stashedParent = reconcilingParent;
+            var stashedPrevious = previouslyReconciledSibling;
+            var stashedRemaining = remainingReconcilingChildren; // Push a new DevTools instance parent while reconciling this subtree.
+
+            reconcilingParent = virtualInstance;
+            previouslyReconciledSibling = null; // Move all the children of this instance to the remaining set.
+            // We'll move them back one by one, and anything that remains is deleted.
+
+            remainingReconcilingChildren = virtualInstance.firstChild;
+            virtualInstance.firstChild = null;
+            try {
+              if (updateVirtualChildrenRecursively(nextFirstChild, nextLastChild, prevFirstChild, traceNearestHostComponentUpdate, virtualLevel + 1)) {
+                recordResetChildren(virtualInstance);
+              } // Update the errors/warnings count. If this Instance has switched to a different
+              // ReactComponentInfo instance, such as when refreshing Server Components, then
+              // we replace all the previous logs with the ones associated with the new ones rather
+              // than merging. Because deduping is expected to happen at the request level.
+
+              var componentLogsEntry = componentInfoToComponentLogsMap.get(virtualInstance.data);
+              recordConsoleLogs(virtualInstance, componentLogsEntry); // Must be called after all children have been appended.
+
+              recordVirtualProfilingDurations(virtualInstance);
+            } finally {
+              unmountRemainingChildren();
+              reconcilingParent = stashedParent;
+              previouslyReconciledSibling = stashedPrevious;
+              remainingReconcilingChildren = stashedRemaining;
+            }
+          }
+          function updateVirtualChildrenRecursively(nextFirstChild, nextLastChild,
+          // non-inclusive
+          prevFirstChild, traceNearestHostComponentUpdate, virtualLevel // the nth level of virtual instances
+          ) {
+            var shouldResetChildren = false; // If the first child is different, we need to traverse them.
+            // Each next child will be either a new child (mount) or an alternate (update).
+
+            var nextChild = nextFirstChild;
+            var prevChildAtSameIndex = prevFirstChild;
+            var previousVirtualInstance = null;
+            var previousVirtualInstanceWasMount = false;
+            var previousVirtualInstanceNextFirstFiber = nextFirstChild;
+            var previousVirtualInstancePrevFirstFiber = prevFirstChild;
+            while (nextChild !== null && nextChild !== nextLastChild) {
+              var level = 0;
+              if (nextChild._debugInfo) {
+                for (var i = 0; i < nextChild._debugInfo.length; i++) {
+                  var debugEntry = nextChild._debugInfo[i];
+                  if (typeof debugEntry.name !== 'string') {
+                    // Not a Component. Some other Debug Info.
+                    continue;
+                  }
+                  var componentInfo = debugEntry;
+                  var secondaryEnv = getSecondaryEnvironmentName(nextChild._debugInfo, i);
+                  if (componentInfo.env != null) {
+                    knownEnvironmentNames.add(componentInfo.env);
+                  }
+                  if (secondaryEnv !== null) {
+                    knownEnvironmentNames.add(secondaryEnv);
+                  }
+                  if (shouldFilterVirtual(componentInfo, secondaryEnv)) {
+                    continue;
+                  }
+                  if (level === virtualLevel) {
+                    if (previousVirtualInstance === null ||
+                    // Consecutive children with the same debug entry as a parent gets
+                    // treated as if they share the same virtual instance.
+                    previousVirtualInstance.data !== componentInfo) {
+                      if (previousVirtualInstance !== null) {
+                        // Mount any previous children that should go into the previous parent.
+                        if (previousVirtualInstanceWasMount) {
+                          mountVirtualInstanceRecursively(previousVirtualInstance, previousVirtualInstanceNextFirstFiber, nextChild, traceNearestHostComponentUpdate, virtualLevel);
+                        } else {
+                          updateVirtualInstanceRecursively(previousVirtualInstance, previousVirtualInstanceNextFirstFiber, nextChild, previousVirtualInstancePrevFirstFiber, traceNearestHostComponentUpdate, virtualLevel);
+                        }
+                      }
+                      var previousSiblingOfBestMatch = null;
+                      var bestMatch = remainingReconcilingChildren;
+                      if (componentInfo.key != null) {
+                        // If there is a key try to find a matching key in the set.
+                        bestMatch = remainingReconcilingChildren;
+                        while (bestMatch !== null) {
+                          if (bestMatch.kind === VIRTUAL_INSTANCE && bestMatch.data.key === componentInfo.key) {
+                            break;
+                          }
+                          previousSiblingOfBestMatch = bestMatch;
+                          bestMatch = bestMatch.nextSibling;
+                        }
+                      }
+                      if (bestMatch !== null && bestMatch.kind === VIRTUAL_INSTANCE && bestMatch.data.name === componentInfo.name && bestMatch.data.env === componentInfo.env && bestMatch.data.key === componentInfo.key) {
+                        // If the previous children had a virtual instance in the same slot
+                        // with the same name, then we claim it and reuse it for this update.
+                        // Update it with the latest entry.
+                        bestMatch.data = componentInfo;
+                        moveChild(bestMatch, previousSiblingOfBestMatch);
+                        previousVirtualInstance = bestMatch;
+                        previousVirtualInstanceWasMount = false;
+                      } else {
+                        // Otherwise we create a new instance.
+                        var newVirtualInstance = createVirtualInstance(componentInfo);
+                        recordVirtualMount(newVirtualInstance, reconcilingParent, secondaryEnv);
+                        insertChild(newVirtualInstance);
+                        previousVirtualInstance = newVirtualInstance;
+                        previousVirtualInstanceWasMount = true;
+                        shouldResetChildren = true;
+                      } // Existing children might be reparented into this new virtual instance.
+                      // TODO: This will cause the front end to error which needs to be fixed.
+
+                      previousVirtualInstanceNextFirstFiber = nextChild;
+                      previousVirtualInstancePrevFirstFiber = prevChildAtSameIndex;
+                    }
+                    level++;
+                    break;
+                  } else {
+                    level++;
+                  }
+                }
+              }
+              if (level === virtualLevel) {
+                if (previousVirtualInstance !== null) {
+                  // If we were working on a virtual instance and this is not a virtual
+                  // instance, then we end the sequence and update any previous children
+                  // that should go into the previous virtual instance.
+                  if (previousVirtualInstanceWasMount) {
+                    mountVirtualInstanceRecursively(previousVirtualInstance, previousVirtualInstanceNextFirstFiber, nextChild, traceNearestHostComponentUpdate, virtualLevel);
+                  } else {
+                    updateVirtualInstanceRecursively(previousVirtualInstance, previousVirtualInstanceNextFirstFiber, nextChild, previousVirtualInstancePrevFirstFiber, traceNearestHostComponentUpdate, virtualLevel);
+                  }
+                  previousVirtualInstance = null;
+                } // We've reached the end of the virtual levels, but not beyond,
+                // and now continue with the regular fiber.
+                // Do a fast pass over the remaining children to find the previous instance.
+                // TODO: This doesn't have the best O(n) for a large set of children that are
+                // reordered. Consider using a temporary map if it's not the very next one.
+
+                var prevChild = void 0;
+                if (prevChildAtSameIndex === nextChild) {
+                  // This set is unchanged. We're just going through it to place all the
+                  // children again.
+                  prevChild = nextChild;
+                } else {
+                  // We don't actually need to rely on the alternate here. We could also
+                  // reconcile against stateNode, key or whatever. Doesn't have to be same
+                  // Fiber pair.
+                  prevChild = nextChild.alternate;
+                }
+                var previousSiblingOfExistingInstance = null;
+                var existingInstance = null;
+                if (prevChild !== null) {
+                  existingInstance = remainingReconcilingChildren;
+                  while (existingInstance !== null) {
+                    if (existingInstance.data === prevChild) {
+                      break;
+                    }
+                    previousSiblingOfExistingInstance = existingInstance;
+                    existingInstance = existingInstance.nextSibling;
+                  }
+                }
+                if (existingInstance !== null) {
+                  // Common case. Match in the same parent.
+                  var fiberInstance = existingInstance; // Only matches if it's a Fiber.
+                  // We keep track if the order of the children matches the previous order.
+                  // They are always different referentially, but if the instances line up
+                  // conceptually we'll want to know that.
+
+                  if (prevChild !== prevChildAtSameIndex) {
+                    shouldResetChildren = true;
+                  }
+                  moveChild(fiberInstance, previousSiblingOfExistingInstance);
+                  if (updateFiberRecursively(fiberInstance, nextChild, prevChild, traceNearestHostComponentUpdate)) {
+                    // If a nested tree child order changed but it can't handle its own
+                    // child order invalidation (e.g. because it's filtered out like host nodes),
+                    // propagate the need to reset child order upwards to this Fiber.
+                    shouldResetChildren = true;
+                  }
+                } else if (prevChild !== null && shouldFilterFiber(nextChild)) {
+                  // If this Fiber should be filtered, we need to still update its children.
+                  // This relies on an alternate since we don't have an Instance with the previous
+                  // child on it. Ideally, the reconciliation wouldn't need previous Fibers that
+                  // are filtered from the tree.
+                  if (updateFiberRecursively(null, nextChild, prevChild, traceNearestHostComponentUpdate)) {
+                    shouldResetChildren = true;
+                  }
+                } else {
+                  // It's possible for a FiberInstance to be reparented when virtual parents
+                  // get their sequence split or change structure with the same render result.
+                  // In this case we unmount the and remount the FiberInstances.
+                  // This might cause us to lose the selection but it's an edge case.
+                  // We let the previous instance remain in the "remaining queue" it is
+                  // in to be deleted at the end since it'll have no match.
+                  mountFiberRecursively(nextChild, traceNearestHostComponentUpdate); // Need to mark the parent set to remount the new instance.
+
+                  shouldResetChildren = true;
+                }
+              } // Try the next child.
+
+              nextChild = nextChild.sibling; // Advance the pointer in the previous list so that we can
+              // keep comparing if they line up.
+
+              if (!shouldResetChildren && prevChildAtSameIndex !== null) {
+                prevChildAtSameIndex = prevChildAtSameIndex.sibling;
+              }
+            }
+            if (previousVirtualInstance !== null) {
+              if (previousVirtualInstanceWasMount) {
+                mountVirtualInstanceRecursively(previousVirtualInstance, previousVirtualInstanceNextFirstFiber, null, traceNearestHostComponentUpdate, virtualLevel);
+              } else {
+                updateVirtualInstanceRecursively(previousVirtualInstance, previousVirtualInstanceNextFirstFiber, null, previousVirtualInstancePrevFirstFiber, traceNearestHostComponentUpdate, virtualLevel);
+              }
+            } // If we have no more children, but used to, they don't line up.
+
+            if (prevChildAtSameIndex !== null) {
+              shouldResetChildren = true;
+            }
+            return shouldResetChildren;
+          } // Returns whether closest unfiltered fiber parent needs to reset its child list.
+
+          function updateChildrenRecursively(nextFirstChild, prevFirstChild, traceNearestHostComponentUpdate) {
+            if (nextFirstChild === null) {
+              return prevFirstChild !== null;
+            }
+            return updateVirtualChildrenRecursively(nextFirstChild, null, prevFirstChild, traceNearestHostComponentUpdate, 0);
+          } // Returns whether closest unfiltered fiber parent needs to reset its child list.
+
+          function updateFiberRecursively(fiberInstance,
+          // null if this should be filtered
+          nextFiber, prevFiber, traceNearestHostComponentUpdate) {
+            if (__DEBUG__) {
+              if (fiberInstance !== null) {
+                debug('updateFiberRecursively()', fiberInstance, reconcilingParent);
+              }
+            }
+            if (traceUpdatesEnabled) {
+              var elementType = getElementTypeForFiber(nextFiber);
+              if (traceNearestHostComponentUpdate) {
+                // If an ancestor updated, we should mark the nearest host nodes for highlighting.
+                if (elementType === ElementTypeHostComponent) {
+                  traceUpdatesForNodes.add(nextFiber.stateNode);
+                  traceNearestHostComponentUpdate = false;
+                }
+              } else {
+                if (elementType === types_ElementTypeFunction || elementType === types_ElementTypeClass || elementType === ElementTypeContext || elementType === types_ElementTypeMemo || elementType === types_ElementTypeForwardRef) {
+                  // Otherwise if this is a traced ancestor, flag for the nearest host descendant(s).
+                  traceNearestHostComponentUpdate = didFiberRender(prevFiber, nextFiber);
+                }
+              }
+            }
+            var stashedParent = reconcilingParent;
+            var stashedPrevious = previouslyReconciledSibling;
+            var stashedRemaining = remainingReconcilingChildren;
+            if (fiberInstance !== null) {
+              // Update the Fiber so we that we always keep the current Fiber on the data.
+              fiberInstance.data = nextFiber;
+              if (mostRecentlyInspectedElement !== null && mostRecentlyInspectedElement.id === fiberInstance.id && didFiberRender(prevFiber, nextFiber)) {
+                // If this Fiber has updated, clear cached inspected data.
+                // If it is inspected again, it may need to be re-run to obtain updated hooks values.
+                hasElementUpdatedSinceLastInspected = true;
+              } // Push a new DevTools instance parent while reconciling this subtree.
+
+              reconcilingParent = fiberInstance;
+              previouslyReconciledSibling = null; // Move all the children of this instance to the remaining set.
+              // We'll move them back one by one, and anything that remains is deleted.
+
+              remainingReconcilingChildren = fiberInstance.firstChild;
+              fiberInstance.firstChild = null;
+            }
+            try {
+              if (nextFiber.tag === HostHoistable && prevFiber.memoizedState !== nextFiber.memoizedState) {
+                var nearestInstance = reconcilingParent;
+                if (nearestInstance === null) {
+                  throw new Error('Did not expect a host hoistable to be the root');
+                }
+                releaseHostResource(nearestInstance, prevFiber.memoizedState);
+                aquireHostResource(nearestInstance, nextFiber.memoizedState);
+              } else if ((nextFiber.tag === HostComponent || nextFiber.tag === HostText || nextFiber.tag === HostSingleton) && prevFiber.stateNode !== nextFiber.stateNode) {
+                // In persistent mode, it's possible for the stateNode to update with
+                // a new clone. In that case we need to release the old one and aquire
+                // new one instead.
+                var _nearestInstance2 = reconcilingParent;
+                if (_nearestInstance2 === null) {
+                  throw new Error('Did not expect a host hoistable to be the root');
+                }
+                releaseHostInstance(_nearestInstance2, prevFiber.stateNode);
+                aquireHostInstance(_nearestInstance2, nextFiber.stateNode);
+              }
+              var isSuspense = nextFiber.tag === SuspenseComponent;
+              var shouldResetChildren = false; // The behavior of timed-out Suspense trees is unique.
+              // Rather than unmount the timed out content (and possibly lose important state),
+              // React re-parents this content within a hidden Fragment while the fallback is showing.
+              // This behavior doesn't need to be observable in the DevTools though.
+              // It might even result in a bad user experience for e.g. node selection in the Elements panel.
+              // The easiest fix is to strip out the intermediate Fragment fibers,
+              // so the Elements panel and Profiler don't need to special case them.
+              // Suspense components only have a non-null memoizedState if they're timed-out.
+
+              var prevDidTimeout = isSuspense && prevFiber.memoizedState !== null;
+              var nextDidTimeOut = isSuspense && nextFiber.memoizedState !== null; // The logic below is inspired by the code paths in updateSuspenseComponent()
+              // inside ReactFiberBeginWork in the React source code.
+
+              if (prevDidTimeout && nextDidTimeOut) {
+                // Fallback -> Fallback:
+                // 1. Reconcile fallback set.
+                var nextFiberChild = nextFiber.child;
+                var nextFallbackChildSet = nextFiberChild ? nextFiberChild.sibling : null; // Note: We can't use nextFiber.child.sibling.alternate
+                // because the set is special and alternate may not exist.
+
+                var prevFiberChild = prevFiber.child;
+                var prevFallbackChildSet = prevFiberChild ? prevFiberChild.sibling : null;
+                if (prevFallbackChildSet == null && nextFallbackChildSet != null) {
+                  mountChildrenRecursively(nextFallbackChildSet, traceNearestHostComponentUpdate);
+                  shouldResetChildren = true;
+                }
+                if (nextFallbackChildSet != null && prevFallbackChildSet != null && updateChildrenRecursively(nextFallbackChildSet, prevFallbackChildSet, traceNearestHostComponentUpdate)) {
+                  shouldResetChildren = true;
+                }
+              } else if (prevDidTimeout && !nextDidTimeOut) {
+                // Fallback -> Primary:
+                // 1. Unmount fallback set
+                // Note: don't emulate fallback unmount because React actually did it.
+                // 2. Mount primary set
+                var nextPrimaryChildSet = nextFiber.child;
+                if (nextPrimaryChildSet !== null) {
+                  mountChildrenRecursively(nextPrimaryChildSet, traceNearestHostComponentUpdate);
+                }
+                shouldResetChildren = true;
+              } else if (!prevDidTimeout && nextDidTimeOut) {
+                // Primary -> Fallback:
+                // 1. Hide primary set
+                // We simply don't re-add the fallback children and let
+                // unmountRemainingChildren() handle it.
+                // 2. Mount fallback set
+                var _nextFiberChild = nextFiber.child;
+                var _nextFallbackChildSet = _nextFiberChild ? _nextFiberChild.sibling : null;
+                if (_nextFallbackChildSet != null) {
+                  mountChildrenRecursively(_nextFallbackChildSet, traceNearestHostComponentUpdate);
+                  shouldResetChildren = true;
+                }
+              } else {
+                // Common case: Primary -> Primary.
+                // This is the same code path as for non-Suspense fibers.
+                if (nextFiber.child !== prevFiber.child) {
+                  if (updateChildrenRecursively(nextFiber.child, prevFiber.child, traceNearestHostComponentUpdate)) {
+                    shouldResetChildren = true;
+                  }
+                } else {
+                  // Children are unchanged.
+                  if (fiberInstance !== null) {
+                    // All the remaining children will be children of this same fiber so we can just reuse them.
+                    // I.e. we just restore them by undoing what we did above.
+                    fiberInstance.firstChild = remainingReconcilingChildren;
+                    remainingReconcilingChildren = null;
+                    if (traceUpdatesEnabled) {
+                      // If we're tracing updates and we've bailed out before reaching a host node,
+                      // we should fall back to recursively marking the nearest host descendants for highlight.
+                      if (traceNearestHostComponentUpdate) {
+                        var hostInstances = findAllCurrentHostInstances(fiberInstance);
+                        hostInstances.forEach(function (hostInstance) {
+                          traceUpdatesForNodes.add(hostInstance);
+                        });
+                      }
+                    }
+                  } else {
+                    // If this fiber is filtered there might be changes to this set elsewhere so we have
+                    // to visit each child to place it back in the set. We let the child bail out instead.
+                    if (updateChildrenRecursively(nextFiber.child, prevFiber.child, false)) {
+                      throw new Error('The children should not have changed if we pass in the same set.');
+                    }
+                  }
+                }
+              }
+              if (fiberInstance !== null) {
+                var componentLogsEntry = fiberToComponentLogsMap.get(fiberInstance.data);
+                if (componentLogsEntry === undefined && fiberInstance.data.alternate) {
+                  componentLogsEntry = fiberToComponentLogsMap.get(fiberInstance.data.alternate);
+                }
+                recordConsoleLogs(fiberInstance, componentLogsEntry);
+                var isProfilingSupported = nextFiber.hasOwnProperty('treeBaseDuration');
+                if (isProfilingSupported) {
+                  recordProfilingDurations(fiberInstance, prevFiber);
+                }
+              }
+              if (shouldResetChildren) {
+                // We need to crawl the subtree for closest non-filtered Fibers
+                // so that we can display them in a flat children set.
+                if (fiberInstance !== null) {
+                  recordResetChildren(fiberInstance); // We've handled the child order change for this Fiber.
+                  // Since it's included, there's no need to invalidate parent child order.
+
+                  return false;
+                } else {
+                  // Let the closest unfiltered parent Fiber reset its child order instead.
+                  return true;
+                }
+              } else {
+                return false;
+              }
+            } finally {
+              if (fiberInstance !== null) {
+                unmountRemainingChildren();
+                reconcilingParent = stashedParent;
+                previouslyReconciledSibling = stashedPrevious;
+                remainingReconcilingChildren = stashedRemaining;
+              }
+            }
+          }
+          function cleanup() {
+            isProfiling = false;
+          }
+          function rootSupportsProfiling(root) {
+            if (root.memoizedInteractions != null) {
+              // v16 builds include this field for the scheduler/tracing API.
+              return true;
+            } else if (root.current != null && root.current.hasOwnProperty('treeBaseDuration')) {
+              // The scheduler/tracing API was removed in v17 though
+              // so we need to check a non-root Fiber.
+              return true;
+            } else {
+              return false;
+            }
+          }
+          function flushInitialOperations() {
+            var localPendingOperationsQueue = pendingOperationsQueue;
+            pendingOperationsQueue = null;
+            if (localPendingOperationsQueue !== null && localPendingOperationsQueue.length > 0) {
+              // We may have already queued up some operations before the frontend connected
+              // If so, let the frontend know about them.
+              localPendingOperationsQueue.forEach(function (operations) {
+                hook.emit('operations', operations);
+              });
+            } else {
+              // Before the traversals, remember to start tracking
+              // our path in case we have selection to restore.
+              if (trackedPath !== null) {
+                mightBeOnTrackedPath = true;
+              } // If we have not been profiling, then we can just walk the tree and build up its current state as-is.
+
+              hook.getFiberRoots(rendererID).forEach(function (root) {
+                var current = root.current;
+                var newRoot = createFiberInstance(current);
+                rootToFiberInstanceMap.set(root, newRoot);
+                idToDevToolsInstanceMap.set(newRoot.id, newRoot);
+                currentRoot = newRoot;
+                setRootPseudoKey(currentRoot.id, root.current); // Handle multi-renderer edge-case where only some v16 renderers support profiling.
+
+                if (isProfiling && rootSupportsProfiling(root)) {
+                  // If profiling is active, store commit time and duration.
+                  // The frontend may request this information after profiling has stopped.
+                  currentCommitProfilingMetadata = {
+                    changeDescriptions: recordChangeDescriptions ? new Map() : null,
+                    durations: [],
+                    commitTime: renderer_getCurrentTime() - profilingStartTime,
+                    maxActualDuration: 0,
+                    priorityLevel: null,
+                    updaters: null,
+                    effectDuration: null,
+                    passiveEffectDuration: null
+                  };
+                }
+                mountFiberRecursively(root.current, false);
+                flushPendingEvents(root);
+                needsToFlushComponentLogs = false;
+                currentRoot = null;
+              });
+            }
+          }
+          function handleCommitFiberUnmount(fiber) {// This Hook is no longer used. After having shipped DevTools everywhere it is
+            // safe to stop calling it from Fiber.
+          }
+          function handlePostCommitFiberRoot(root) {
+            if (isProfiling && rootSupportsProfiling(root)) {
+              if (currentCommitProfilingMetadata !== null) {
+                var _getEffectDurations = getEffectDurations(root),
+                  effectDuration = _getEffectDurations.effectDuration,
+                  passiveEffectDuration = _getEffectDurations.passiveEffectDuration; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+                currentCommitProfilingMetadata.effectDuration = effectDuration; // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+                currentCommitProfilingMetadata.passiveEffectDuration = passiveEffectDuration;
+              }
+            }
+            if (needsToFlushComponentLogs) {
+              // We received new logs after commit. I.e. in a passive effect. We need to
+              // traverse the tree to find the affected ones. If we just moved the whole
+              // tree traversal from handleCommitFiberRoot to handlePostCommitFiberRoot
+              // this wouldn't be needed. For now we just brute force check all instances.
+              // This is not that common of a case.
+              bruteForceFlushErrorsAndWarnings();
+            }
+          }
+          function handleCommitFiberRoot(root, priorityLevel) {
+            var current = root.current;
+            var prevFiber = null;
+            var rootInstance = rootToFiberInstanceMap.get(root);
+            if (!rootInstance) {
+              rootInstance = createFiberInstance(current);
+              rootToFiberInstanceMap.set(root, rootInstance);
+              idToDevToolsInstanceMap.set(rootInstance.id, rootInstance);
+            } else {
+              prevFiber = rootInstance.data;
+            }
+            currentRoot = rootInstance; // Before the traversals, remember to start tracking
+            // our path in case we have selection to restore.
+
+            if (trackedPath !== null) {
+              mightBeOnTrackedPath = true;
+            }
+            if (traceUpdatesEnabled) {
+              traceUpdatesForNodes.clear();
+            } // Handle multi-renderer edge-case where only some v16 renderers support profiling.
+
+            var isProfilingSupported = rootSupportsProfiling(root);
+            if (isProfiling && isProfilingSupported) {
+              // If profiling is active, store commit time and duration.
+              // The frontend may request this information after profiling has stopped.
+              currentCommitProfilingMetadata = {
+                changeDescriptions: recordChangeDescriptions ? new Map() : null,
+                durations: [],
+                commitTime: renderer_getCurrentTime() - profilingStartTime,
+                maxActualDuration: 0,
+                priorityLevel: priorityLevel == null ? null : formatPriorityLevel(priorityLevel),
+                updaters: null,
+                // Initialize to null; if new enough React version is running,
+                // these values will be read during separate handlePostCommitFiberRoot() call.
+                effectDuration: null,
+                passiveEffectDuration: null
+              };
+            }
+            if (prevFiber !== null) {
+              // TODO: relying on this seems a bit fishy.
+              var wasMounted = prevFiber.memoizedState != null && prevFiber.memoizedState.element != null &&
+              // A dehydrated root is not considered mounted
+              prevFiber.memoizedState.isDehydrated !== true;
+              var isMounted = current.memoizedState != null && current.memoizedState.element != null &&
+              // A dehydrated root is not considered mounted
+              current.memoizedState.isDehydrated !== true;
+              if (!wasMounted && isMounted) {
+                // Mount a new root.
+                setRootPseudoKey(currentRoot.id, current);
+                mountFiberRecursively(current, false);
+              } else if (wasMounted && isMounted) {
+                // Update an existing root.
+                updateFiberRecursively(rootInstance, current, prevFiber, false);
+              } else if (wasMounted && !isMounted) {
+                // Unmount an existing root.
+                unmountInstanceRecursively(rootInstance);
+                removeRootPseudoKey(currentRoot.id);
+                rootToFiberInstanceMap.delete(root);
+              }
+            } else {
+              // Mount a new root.
+              setRootPseudoKey(currentRoot.id, current);
+              mountFiberRecursively(current, false);
+            }
+            if (isProfiling && isProfilingSupported) {
+              if (!shouldBailoutWithPendingOperations()) {
+                var commitProfilingMetadata = rootToCommitProfilingMetadataMap.get(currentRoot.id);
+                if (commitProfilingMetadata != null) {
+                  commitProfilingMetadata.push(currentCommitProfilingMetadata);
+                } else {
+                  rootToCommitProfilingMetadataMap.set(currentRoot.id, [currentCommitProfilingMetadata]);
+                }
+              }
+            } // We're done here.
+
+            flushPendingEvents(root);
+            needsToFlushComponentLogs = false;
+            if (traceUpdatesEnabled) {
+              hook.emit('traceUpdates', traceUpdatesForNodes);
+            }
+            currentRoot = null;
+          }
+          function getResourceInstance(fiber) {
+            if (fiber.tag === HostHoistable) {
+              var resource = fiber.memoizedState; // Feature Detect a DOM Specific Instance of a Resource
+
+              if (renderer_typeof(resource) === 'object' && resource !== null && resource.instance != null) {
+                return resource.instance;
+              }
+            }
+            return null;
+          }
+          function appendHostInstancesByDevToolsInstance(devtoolsInstance, hostInstances) {
+            if (devtoolsInstance.kind !== VIRTUAL_INSTANCE) {
+              var _fiber4 = devtoolsInstance.data;
+              appendHostInstancesByFiber(_fiber4, hostInstances);
+              return;
+            } // Search the tree for the nearest child Fiber and add all its host instances.
+            // TODO: If the true nearest Fiber is filtered, we might skip it and instead include all
+            // the children below it. In the extreme case, searching the whole tree.
+
+            for (var child = devtoolsInstance.firstChild; child !== null; child = child.nextSibling) {
+              appendHostInstancesByDevToolsInstance(child, hostInstances);
+            }
+          }
+          function appendHostInstancesByFiber(fiber, hostInstances) {
+            // Next we'll drill down this component to find all HostComponent/Text.
+            var node = fiber;
+            while (true) {
+              if (node.tag === HostComponent || node.tag === HostText || node.tag === HostSingleton || node.tag === HostHoistable) {
+                var hostInstance = node.stateNode || getResourceInstance(node);
+                if (hostInstance) {
+                  hostInstances.push(hostInstance);
+                }
+              } else if (node.child) {
+                node.child.return = node;
+                node = node.child;
+                continue;
+              }
+              if (node === fiber) {
+                return;
+              }
+              while (!node.sibling) {
+                if (!node.return || node.return === fiber) {
+                  return;
+                }
+                node = node.return;
+              }
+              node.sibling.return = node.return;
+              node = node.sibling;
+            }
+          }
+          function findAllCurrentHostInstances(devtoolsInstance) {
+            var hostInstances = [];
+            appendHostInstancesByDevToolsInstance(devtoolsInstance, hostInstances);
+            return hostInstances;
+          }
+          function findHostInstancesForElementID(id) {
+            try {
+              var devtoolsInstance = idToDevToolsInstanceMap.get(id);
+              if (devtoolsInstance === undefined) {
+                console.warn("Could not find DevToolsInstance with id \"".concat(id, "\""));
+                return null;
+              }
+              return findAllCurrentHostInstances(devtoolsInstance);
+            } catch (err) {
+              // The fiber might have unmounted by now.
+              return null;
+            }
+          }
+          function getDisplayNameForElementID(id) {
+            var devtoolsInstance = idToDevToolsInstanceMap.get(id);
+            if (devtoolsInstance === undefined) {
+              return null;
+            }
+            if (devtoolsInstance.kind === FIBER_INSTANCE) {
+              return getDisplayNameForFiber(devtoolsInstance.data);
+            } else {
+              return devtoolsInstance.data.name || '';
+            }
+          }
+          function getNearestMountedDOMNode(publicInstance) {
+            var domNode = publicInstance;
+            while (domNode && !publicInstanceToDevToolsInstanceMap.has(domNode)) {
+              // $FlowFixMe: In practice this is either null or Element.
+              domNode = domNode.parentNode;
+            }
+            return domNode;
+          }
+          function getElementIDForHostInstance(publicInstance) {
+            var instance = publicInstanceToDevToolsInstanceMap.get(publicInstance);
+            if (instance !== undefined) {
+              if (instance.kind === FILTERED_FIBER_INSTANCE) {
+                // A Filtered Fiber Instance will always have a Virtual Instance as a parent.
+                return instance.parent.id;
+              }
+              return instance.id;
+            }
+            return null;
+          }
+          function getElementAttributeByPath(id, path) {
+            if (isMostRecentlyInspectedElement(id)) {
+              return utils_getInObject(mostRecentlyInspectedElement, path);
+            }
+            return undefined;
+          }
+          function getElementSourceFunctionById(id) {
+            var devtoolsInstance = idToDevToolsInstanceMap.get(id);
+            if (devtoolsInstance === undefined) {
+              console.warn("Could not find DevToolsInstance with id \"".concat(id, "\""));
+              return null;
+            }
+            if (devtoolsInstance.kind !== FIBER_INSTANCE) {
+              // TODO: Handle VirtualInstance.
+              return null;
+            }
+            var fiber = devtoolsInstance.data;
+            var elementType = fiber.elementType,
+              tag = fiber.tag,
+              type = fiber.type;
+            switch (tag) {
+              case ClassComponent:
+              case IncompleteClassComponent:
+              case IncompleteFunctionComponent:
+              case IndeterminateComponent:
+              case FunctionComponent:
+                return type;
+              case ForwardRef:
+                return type.render;
+              case MemoComponent:
+              case SimpleMemoComponent:
+                return elementType != null && elementType.type != null ? elementType.type : type;
+              default:
+                return null;
+            }
+          }
+          function instanceToSerializedElement(instance) {
+            if (instance.kind === FIBER_INSTANCE) {
+              var _fiber5 = instance.data;
+              return {
+                displayName: getDisplayNameForFiber(_fiber5) || 'Anonymous',
+                id: instance.id,
+                key: _fiber5.key,
+                type: getElementTypeForFiber(_fiber5)
+              };
+            } else {
+              var componentInfo = instance.data;
+              return {
+                displayName: componentInfo.name || 'Anonymous',
+                id: instance.id,
+                key: componentInfo.key == null ? null : componentInfo.key,
+                type: types_ElementTypeVirtual
+              };
+            }
+          }
+          function getOwnersList(id) {
+            var devtoolsInstance = idToDevToolsInstanceMap.get(id);
+            if (devtoolsInstance === undefined) {
+              console.warn("Could not find DevToolsInstance with id \"".concat(id, "\""));
+              return null;
+            }
+            var self = instanceToSerializedElement(devtoolsInstance);
+            var owners = getOwnersListFromInstance(devtoolsInstance); // This is particular API is prefixed with the current instance too for some reason.
+
+            if (owners === null) {
+              return [self];
+            }
+            owners.unshift(self);
+            owners.reverse();
+            return owners;
+          }
+          function getOwnersListFromInstance(instance) {
+            var owner = getUnfilteredOwner(instance.data);
+            if (owner === null) {
+              return null;
+            }
+            var owners = [];
+            var parentInstance = instance.parent;
+            while (parentInstance !== null && owner !== null) {
+              var ownerInstance = findNearestOwnerInstance(parentInstance, owner);
+              if (ownerInstance !== null) {
+                owners.push(instanceToSerializedElement(ownerInstance)); // Get the next owner and keep searching from the previous match.
+
+                owner = getUnfilteredOwner(owner);
+                parentInstance = ownerInstance.parent;
+              } else {
+                break;
+              }
+            }
+            return owners;
+          }
+          function getUnfilteredOwner(owner) {
+            if (owner == null) {
+              return null;
+            }
+            if (typeof owner.tag === 'number') {
+              var ownerFiber = owner; // Refined
+
+              owner = ownerFiber._debugOwner;
+            } else {
+              var ownerInfo = owner; // Refined
+
+              owner = ownerInfo.owner;
+            }
+            while (owner) {
+              if (typeof owner.tag === 'number') {
+                var _ownerFiber = owner; // Refined
+
+                if (!shouldFilterFiber(_ownerFiber)) {
+                  return _ownerFiber;
+                }
+                owner = _ownerFiber._debugOwner;
+              } else {
+                var _ownerInfo = owner; // Refined
+
+                if (!shouldFilterVirtual(_ownerInfo, null)) {
+                  return _ownerInfo;
+                }
+                owner = _ownerInfo.owner;
+              }
+            }
+            return null;
+          }
+          function findNearestOwnerInstance(parentInstance, owner) {
+            if (owner == null) {
+              return null;
+            } // Search the parent path for any instance that matches this kind of owner.
+
+            while (parentInstance !== null) {
+              if (parentInstance.data === owner ||
+              // Typically both owner and instance.data would refer to the current version of a Fiber
+              // but it is possible for memoization to ignore the owner on the JSX. Then the new Fiber
+              // isn't propagated down as the new owner. In that case we might match the alternate
+              // instead. This is a bit hacky but the fastest check since type casting owner to a Fiber
+              // needs a duck type check anyway.
+              parentInstance.data === owner.alternate) {
+                if (parentInstance.kind === FILTERED_FIBER_INSTANCE) {
+                  return null;
+                }
+                return parentInstance;
+              }
+              parentInstance = parentInstance.parent;
+            } // It is technically possible to create an element and render it in a different parent
+            // but this is a weird edge case and it is worth not having to scan the tree or keep
+            // a register for every fiber/component info.
+
+            return null;
+          } // Fast path props lookup for React Native style editor.
+          // Could use inspectElementRaw() but that would require shallow rendering hooks components,
+          // and could also mess with memoization.
+
+          function getInstanceAndStyle(id) {
+            var instance = null;
+            var style = null;
+            var devtoolsInstance = idToDevToolsInstanceMap.get(id);
+            if (devtoolsInstance === undefined) {
+              console.warn("Could not find DevToolsInstance with id \"".concat(id, "\""));
+              return {
+                instance: instance,
+                style: style
+              };
+            }
+            if (devtoolsInstance.kind !== FIBER_INSTANCE) {
+              // TODO: Handle VirtualInstance.
+              return {
+                instance: instance,
+                style: style
+              };
+            }
+            var fiber = devtoolsInstance.data;
+            if (fiber !== null) {
+              instance = fiber.stateNode;
+              if (fiber.memoizedProps !== null) {
+                style = fiber.memoizedProps.style;
+              }
+            }
+            return {
+              instance: instance,
+              style: style
+            };
+          }
+          function isErrorBoundary(fiber) {
+            var tag = fiber.tag,
+              type = fiber.type;
+            switch (tag) {
+              case ClassComponent:
+              case IncompleteClassComponent:
+                var instance = fiber.stateNode;
+                return typeof type.getDerivedStateFromError === 'function' || instance !== null && typeof instance.componentDidCatch === 'function';
+              default:
+                return false;
+            }
+          }
+          function inspectElementRaw(id) {
+            var devtoolsInstance = idToDevToolsInstanceMap.get(id);
+            if (devtoolsInstance === undefined) {
+              console.warn("Could not find DevToolsInstance with id \"".concat(id, "\""));
+              return null;
+            }
+            if (devtoolsInstance.kind === VIRTUAL_INSTANCE) {
+              return inspectVirtualInstanceRaw(devtoolsInstance);
+            }
+            if (devtoolsInstance.kind === FIBER_INSTANCE) {
+              return inspectFiberInstanceRaw(devtoolsInstance);
+            }
+            devtoolsInstance; // assert exhaustive
+
+            throw new Error('Unsupported instance kind');
+          }
+          function inspectFiberInstanceRaw(fiberInstance) {
+            var fiber = fiberInstance.data;
+            if (fiber == null) {
+              return null;
+            }
+            var stateNode = fiber.stateNode,
+              key = fiber.key,
+              memoizedProps = fiber.memoizedProps,
+              memoizedState = fiber.memoizedState,
+              dependencies = fiber.dependencies,
+              tag = fiber.tag,
+              type = fiber.type;
+            var elementType = getElementTypeForFiber(fiber);
+            var usesHooks = (tag === FunctionComponent || tag === SimpleMemoComponent || tag === ForwardRef) && (!!memoizedState || !!dependencies); // TODO Show custom UI for Cache like we do for Suspense
+            // For now, just hide state data entirely since it's not meant to be inspected.
+
+            var showState = !usesHooks && tag !== CacheComponent;
+            var typeSymbol = getTypeSymbol(type);
+            var canViewSource = false;
+            var context = null;
+            if (tag === ClassComponent || tag === FunctionComponent || tag === IncompleteClassComponent || tag === IncompleteFunctionComponent || tag === IndeterminateComponent || tag === MemoComponent || tag === ForwardRef || tag === SimpleMemoComponent) {
+              canViewSource = true;
+              if (stateNode && stateNode.context != null) {
+                // Don't show an empty context object for class components that don't use the context API.
+                var shouldHideContext = elementType === types_ElementTypeClass && !(type.contextTypes || type.contextType);
+                if (!shouldHideContext) {
+                  context = stateNode.context;
+                }
+              }
+            } else if (
+            // Detect pre-19 Context Consumers
+            (typeSymbol === CONTEXT_NUMBER || typeSymbol === CONTEXT_SYMBOL_STRING) && !(
+            // In 19+, CONTEXT_SYMBOL_STRING means a Provider instead.
+            // It will be handled in a different branch below.
+            // Eventually, this entire branch can be removed.
+            type._context === undefined && type.Provider === type)) {
+              // 16.3-16.5 read from "type" because the Consumer is the actual context object.
+              // 16.6+ should read from "type._context" because Consumer can be different (in DEV).
+              // NOTE Keep in sync with getDisplayNameForFiber()
+              var consumerResolvedContext = type._context || type; // Global context value.
+
+              context = consumerResolvedContext._currentValue || null; // Look for overridden value.
+
+              var _current = fiber.return;
+              while (_current !== null) {
+                var currentType = _current.type;
+                var currentTypeSymbol = getTypeSymbol(currentType);
+                if (currentTypeSymbol === PROVIDER_NUMBER || currentTypeSymbol === PROVIDER_SYMBOL_STRING) {
+                  // 16.3.0 exposed the context object as "context"
+                  // PR #12501 changed it to "_context" for 16.3.1+
+                  // NOTE Keep in sync with getDisplayNameForFiber()
+                  var providerResolvedContext = currentType._context || currentType.context;
+                  if (providerResolvedContext === consumerResolvedContext) {
+                    context = _current.memoizedProps.value;
+                    break;
+                  }
+                }
+                _current = _current.return;
+              }
+            } else if (
+            // Detect 19+ Context Consumers
+            typeSymbol === CONSUMER_SYMBOL_STRING) {
+              // This branch is 19+ only, where Context.Provider === Context.
+              // NOTE Keep in sync with getDisplayNameForFiber()
+              var _consumerResolvedContext = type._context; // Global context value.
+
+              context = _consumerResolvedContext._currentValue || null; // Look for overridden value.
+
+              var _current2 = fiber.return;
+              while (_current2 !== null) {
+                var _currentType = _current2.type;
+                var _currentTypeSymbol = getTypeSymbol(_currentType);
+                if (
+                // In 19+, these are Context Providers
+                _currentTypeSymbol === CONTEXT_SYMBOL_STRING) {
+                  var _providerResolvedContext = _currentType;
+                  if (_providerResolvedContext === _consumerResolvedContext) {
+                    context = _current2.memoizedProps.value;
+                    break;
+                  }
+                }
+                _current2 = _current2.return;
+              }
+            }
+            var hasLegacyContext = false;
+            if (context !== null) {
+              hasLegacyContext = !!type.contextTypes; // To simplify hydration and display logic for context, wrap in a value object.
+              // Otherwise simple values (e.g. strings, booleans) become harder to handle.
+
+              context = {
+                value: context
+              };
+            }
+            var owners = getOwnersListFromInstance(fiberInstance);
+            var hooks = null;
+            if (usesHooks) {
+              var originalConsoleMethods = {}; // Temporarily disable all console logging before re-running the hook.
+
+              for (var method in console) {
+                try {
+                  // $FlowFixMe[invalid-computed-prop]
+                  originalConsoleMethods[method] = console[method]; // $FlowFixMe[prop-missing]
+
+                  console[method] = function () {};
+                } catch (error) {}
+              }
+              try {
+                hooks = (0, react_debug_tools.inspectHooksOfFiber)(fiber, getDispatcherRef(renderer));
+              } finally {
+                // Restore original console functionality.
+                for (var _method in originalConsoleMethods) {
+                  try {
+                    // $FlowFixMe[prop-missing]
+                    console[_method] = originalConsoleMethods[_method];
+                  } catch (error) {}
+                }
+              }
+            }
+            var rootType = null;
+            var current = fiber;
+            var hasErrorBoundary = false;
+            var hasSuspenseBoundary = false;
+            while (current.return !== null) {
+              var temp = current;
+              current = current.return;
+              if (temp.tag === SuspenseComponent) {
+                hasSuspenseBoundary = true;
+              } else if (isErrorBoundary(temp)) {
+                hasErrorBoundary = true;
+              }
+            }
+            var fiberRoot = current.stateNode;
+            if (fiberRoot != null && fiberRoot._debugRootType !== null) {
+              rootType = fiberRoot._debugRootType;
+            }
+            var isTimedOutSuspense = tag === SuspenseComponent && memoizedState !== null;
+            var isErrored = false;
+            if (isErrorBoundary(fiber)) {
+              // if the current inspected element is an error boundary,
+              // either that we want to use it to toggle off error state
+              // or that we allow to force error state on it if it's within another
+              // error boundary
+              //
+              // TODO: This flag is a leaked implementation detail. Once we start
+              // releasing DevTools in lockstep with React, we should import a function
+              // from the reconciler instead.
+              var DidCapture = 128;
+              isErrored = (fiber.flags & DidCapture) !== 0 || forceErrorForFibers.get(fiber) === true || fiber.alternate !== null && forceErrorForFibers.get(fiber.alternate) === true;
+            }
+            var plugins = {
+              stylex: null
+            };
+            if (enableStyleXFeatures) {
+              if (memoizedProps != null && memoizedProps.hasOwnProperty('xstyle')) {
+                plugins.stylex = getStyleXData(memoizedProps.xstyle);
+              }
+            }
+            var source = null;
+            if (canViewSource) {
+              source = getSourceForFiberInstance(fiberInstance);
+            }
+            var componentLogsEntry = fiberToComponentLogsMap.get(fiber);
+            if (componentLogsEntry === undefined && fiber.alternate !== null) {
+              componentLogsEntry = fiberToComponentLogsMap.get(fiber.alternate);
+            }
+            var nativeTag = null;
+            if (elementType === ElementTypeHostComponent) {
+              nativeTag = getNativeTag(fiber.stateNode);
+            }
+            return {
+              id: fiberInstance.id,
+              // Does the current renderer support editable hooks and function props?
+              canEditHooks: typeof overrideHookState === 'function',
+              canEditFunctionProps: typeof overrideProps === 'function',
+              // Does the current renderer support advanced editing interface?
+              canEditHooksAndDeletePaths: typeof overrideHookStateDeletePath === 'function',
+              canEditHooksAndRenamePaths: typeof overrideHookStateRenamePath === 'function',
+              canEditFunctionPropsDeletePaths: typeof overridePropsDeletePath === 'function',
+              canEditFunctionPropsRenamePaths: typeof overridePropsRenamePath === 'function',
+              canToggleError: supportsTogglingError && hasErrorBoundary,
+              // Is this error boundary in error state.
+              isErrored: isErrored,
+              canToggleSuspense: supportsTogglingSuspense && hasSuspenseBoundary && (
+              // If it's showing the real content, we can always flip fallback.
+              !isTimedOutSuspense ||
+              // If it's showing fallback because we previously forced it to,
+              // allow toggling it back to remove the fallback override.
+              forceFallbackForFibers.has(fiber) || fiber.alternate !== null && forceFallbackForFibers.has(fiber.alternate)),
+              // Can view component source location.
+              canViewSource: canViewSource,
+              source: source,
+              // Does the component have legacy context attached to it.
+              hasLegacyContext: hasLegacyContext,
+              key: key != null ? key : null,
+              type: elementType,
+              // Inspectable properties.
+              // TODO Review sanitization approach for the below inspectable values.
+              context: context,
+              hooks: hooks,
+              props: memoizedProps,
+              state: showState ? memoizedState : null,
+              errors: componentLogsEntry === undefined ? [] : Array.from(componentLogsEntry.errors.entries()),
+              warnings: componentLogsEntry === undefined ? [] : Array.from(componentLogsEntry.warnings.entries()),
+              // List of owners
+              owners: owners,
+              rootType: rootType,
+              rendererPackageName: renderer.rendererPackageName,
+              rendererVersion: renderer.version,
+              plugins: plugins,
+              nativeTag: nativeTag
+            };
+          }
+          function inspectVirtualInstanceRaw(virtualInstance) {
+            var canViewSource = true;
+            var source = getSourceForInstance(virtualInstance);
+            var componentInfo = virtualInstance.data;
+            var key = typeof componentInfo.key === 'string' ? componentInfo.key : null;
+            var props = componentInfo.props == null ? null : componentInfo.props;
+            var owners = getOwnersListFromInstance(virtualInstance);
+            var rootType = null;
+            var hasErrorBoundary = false;
+            var hasSuspenseBoundary = false;
+            var nearestFiber = getNearestFiber(virtualInstance);
+            if (nearestFiber !== null) {
+              var current = nearestFiber;
+              while (current.return !== null) {
+                var temp = current;
+                current = current.return;
+                if (temp.tag === SuspenseComponent) {
+                  hasSuspenseBoundary = true;
+                } else if (isErrorBoundary(temp)) {
+                  hasErrorBoundary = true;
+                }
+              }
+              var fiberRoot = current.stateNode;
+              if (fiberRoot != null && fiberRoot._debugRootType !== null) {
+                rootType = fiberRoot._debugRootType;
+              }
+            }
+            var plugins = {
+              stylex: null
+            };
+            var componentLogsEntry = componentInfoToComponentLogsMap.get(componentInfo);
+            return {
+              id: virtualInstance.id,
+              canEditHooks: false,
+              canEditFunctionProps: false,
+              canEditHooksAndDeletePaths: false,
+              canEditHooksAndRenamePaths: false,
+              canEditFunctionPropsDeletePaths: false,
+              canEditFunctionPropsRenamePaths: false,
+              canToggleError: supportsTogglingError && hasErrorBoundary,
+              isErrored: false,
+              canToggleSuspense: supportsTogglingSuspense && hasSuspenseBoundary,
+              // Can view component source location.
+              canViewSource: canViewSource,
+              source: source,
+              // Does the component have legacy context attached to it.
+              hasLegacyContext: false,
+              key: key,
+              type: types_ElementTypeVirtual,
+              // Inspectable properties.
+              // TODO Review sanitization approach for the below inspectable values.
+              context: null,
+              hooks: null,
+              props: props,
+              state: null,
+              errors: componentLogsEntry === undefined ? [] : Array.from(componentLogsEntry.errors.entries()),
+              warnings: componentLogsEntry === undefined ? [] : Array.from(componentLogsEntry.warnings.entries()),
+              // List of owners
+              owners: owners,
+              rootType: rootType,
+              rendererPackageName: renderer.rendererPackageName,
+              rendererVersion: renderer.version,
+              plugins: plugins,
+              nativeTag: null
+            };
+          }
+          var mostRecentlyInspectedElement = null;
+          var hasElementUpdatedSinceLastInspected = false;
+          var currentlyInspectedPaths = {};
+          function isMostRecentlyInspectedElement(id) {
+            return mostRecentlyInspectedElement !== null && mostRecentlyInspectedElement.id === id;
+          }
+          function isMostRecentlyInspectedElementCurrent(id) {
+            return isMostRecentlyInspectedElement(id) && !hasElementUpdatedSinceLastInspected;
+          } // Track the intersection of currently inspected paths,
+          // so that we can send their data along if the element is re-rendered.
+
+          function mergeInspectedPaths(path) {
+            var current = currentlyInspectedPaths;
+            path.forEach(function (key) {
+              if (!current[key]) {
+                current[key] = {};
+              }
+              current = current[key];
+            });
+          }
+          function createIsPathAllowed(key, secondaryCategory) {
+            // This function helps prevent previously-inspected paths from being dehydrated in updates.
+            // This is important to avoid a bad user experience where expanded toggles collapse on update.
+            return function isPathAllowed(path) {
+              switch (secondaryCategory) {
+                case 'hooks':
+                  if (path.length === 1) {
+                    // Never dehydrate the "hooks" object at the top levels.
+                    return true;
+                  }
+                  if (path[path.length - 2] === 'hookSource' && path[path.length - 1] === 'fileName') {
+                    // It's important to preserve the full file name (URL) for hook sources
+                    // in case the user has enabled the named hooks feature.
+                    // Otherwise the frontend may end up with a partial URL which it can't load.
+                    return true;
+                  }
+                  if (path[path.length - 1] === 'subHooks' || path[path.length - 2] === 'subHooks') {
+                    // Dehydrating the 'subHooks' property makes the HooksTree UI a lot more complicated,
+                    // so it's easiest for now if we just don't break on this boundary.
+                    // We can always dehydrate a level deeper (in the value object).
+                    return true;
+                  }
+                  break;
+                default:
+                  break;
+              }
+              var current = key === null ? currentlyInspectedPaths : currentlyInspectedPaths[key];
+              if (!current) {
+                return false;
+              }
+              for (var i = 0; i < path.length; i++) {
+                current = current[path[i]];
+                if (!current) {
+                  return false;
+                }
+              }
+              return true;
+            };
+          }
+          function updateSelectedElement(inspectedElement) {
+            var hooks = inspectedElement.hooks,
+              id = inspectedElement.id,
+              props = inspectedElement.props;
+            var devtoolsInstance = idToDevToolsInstanceMap.get(id);
+            if (devtoolsInstance === undefined) {
+              console.warn("Could not find DevToolsInstance with id \"".concat(id, "\""));
+              return;
+            }
+            if (devtoolsInstance.kind !== FIBER_INSTANCE) {
+              // TODO: Handle VirtualInstance.
+              return;
+            }
+            var fiber = devtoolsInstance.data;
+            var elementType = fiber.elementType,
+              stateNode = fiber.stateNode,
+              tag = fiber.tag,
+              type = fiber.type;
+            switch (tag) {
+              case ClassComponent:
+              case IncompleteClassComponent:
+              case IndeterminateComponent:
+                global.$r = stateNode;
+                break;
+              case IncompleteFunctionComponent:
+              case FunctionComponent:
+                global.$r = {
+                  hooks: hooks,
+                  props: props,
+                  type: type
+                };
+                break;
+              case ForwardRef:
+                global.$r = {
+                  hooks: hooks,
+                  props: props,
+                  type: type.render
+                };
+                break;
+              case MemoComponent:
+              case SimpleMemoComponent:
+                global.$r = {
+                  hooks: hooks,
+                  props: props,
+                  type: elementType != null && elementType.type != null ? elementType.type : type
+                };
+                break;
+              default:
+                global.$r = null;
+                break;
+            }
+          }
+          function storeAsGlobal(id, path, count) {
+            if (isMostRecentlyInspectedElement(id)) {
+              var value = utils_getInObject(mostRecentlyInspectedElement, path);
+              var key = "$reactTemp".concat(count);
+              window[key] = value;
+              console.log(key);
+              console.log(value);
+            }
+          }
+          function getSerializedElementValueByPath(id, path) {
+            if (isMostRecentlyInspectedElement(id)) {
+              var valueToCopy = utils_getInObject(mostRecentlyInspectedElement, path);
+              return serializeToString(valueToCopy);
+            }
+          }
+          function inspectElement(requestID, id, path, forceFullData) {
+            if (path !== null) {
+              mergeInspectedPaths(path);
+            }
+            if (isMostRecentlyInspectedElement(id) && !forceFullData) {
+              if (!hasElementUpdatedSinceLastInspected) {
+                if (path !== null) {
+                  var secondaryCategory = null;
+                  if (path[0] === 'hooks') {
+                    secondaryCategory = 'hooks';
+                  } // If this element has not been updated since it was last inspected,
+                  // we can just return the subset of data in the newly-inspected path.
+
+                  return {
+                    id: id,
+                    responseID: requestID,
+                    type: 'hydrated-path',
+                    path: path,
+                    value: cleanForBridge(utils_getInObject(mostRecentlyInspectedElement, path), createIsPathAllowed(null, secondaryCategory), path)
+                  };
+                } else {
+                  // If this element has not been updated since it was last inspected, we don't need to return it.
+                  // Instead we can just return the ID to indicate that it has not changed.
+                  return {
+                    id: id,
+                    responseID: requestID,
+                    type: 'no-change'
+                  };
+                }
+              }
+            } else {
+              currentlyInspectedPaths = {};
+            }
+            hasElementUpdatedSinceLastInspected = false;
+            try {
+              mostRecentlyInspectedElement = inspectElementRaw(id);
+            } catch (error) {
+              // the error name is synced with ReactDebugHooks
+              if (error.name === 'ReactDebugToolsRenderError') {
+                var message = 'Error rendering inspected element.';
+                var stack; // Log error & cause for user to debug
+
+                console.error(message + '\n\n', error);
+                if (error.cause != null) {
+                  var componentName = getDisplayNameForElementID(id);
+                  console.error('React DevTools encountered an error while trying to inspect hooks. ' + 'This is most likely caused by an error in current inspected component' + (componentName != null ? ": \"".concat(componentName, "\".") : '.') + '\nThe error thrown in the component is: \n\n', error.cause);
+                  if (error.cause instanceof Error) {
+                    message = error.cause.message || message;
+                    stack = error.cause.stack;
+                  }
+                }
+                return {
+                  type: 'error',
+                  errorType: 'user',
+                  id: id,
+                  responseID: requestID,
+                  message: message,
+                  stack: stack
+                };
+              } // the error name is synced with ReactDebugHooks
+
+              if (error.name === 'ReactDebugToolsUnsupportedHookError') {
+                return {
+                  type: 'error',
+                  errorType: 'unknown-hook',
+                  id: id,
+                  responseID: requestID,
+                  message: 'Unsupported hook in the react-debug-tools package: ' + error.message
+                };
+              } // Log Uncaught Error
+
+              console.error('Error inspecting element.\n\n', error);
+              return {
+                type: 'error',
+                errorType: 'uncaught',
+                id: id,
+                responseID: requestID,
+                message: error.message,
+                stack: error.stack
+              };
+            }
+            if (mostRecentlyInspectedElement === null) {
+              return {
+                id: id,
+                responseID: requestID,
+                type: 'not-found'
+              };
+            } // Any time an inspected element has an update,
+            // we should update the selected $r value as wel.
+            // Do this before dehydration (cleanForBridge).
+
+            updateSelectedElement(mostRecentlyInspectedElement); // Clone before cleaning so that we preserve the full data.
+            // This will enable us to send patches without re-inspecting if hydrated paths are requested.
+            // (Reducing how often we shallow-render is a better DX for function components that use hooks.)
+
+            var cleanedInspectedElement = renderer_objectSpread({}, mostRecentlyInspectedElement); // $FlowFixMe[prop-missing] found when upgrading Flow
+
+            cleanedInspectedElement.context = cleanForBridge(cleanedInspectedElement.context, createIsPathAllowed('context', null)); // $FlowFixMe[prop-missing] found when upgrading Flow
+
+            cleanedInspectedElement.hooks = cleanForBridge(cleanedInspectedElement.hooks, createIsPathAllowed('hooks', 'hooks')); // $FlowFixMe[prop-missing] found when upgrading Flow
+
+            cleanedInspectedElement.props = cleanForBridge(cleanedInspectedElement.props, createIsPathAllowed('props', null)); // $FlowFixMe[prop-missing] found when upgrading Flow
+
+            cleanedInspectedElement.state = cleanForBridge(cleanedInspectedElement.state, createIsPathAllowed('state', null));
+            return {
+              id: id,
+              responseID: requestID,
+              type: 'full-data',
+              // $FlowFixMe[prop-missing] found when upgrading Flow
+              value: cleanedInspectedElement
+            };
+          }
+          function logElementToConsole(id) {
+            var result = isMostRecentlyInspectedElementCurrent(id) ? mostRecentlyInspectedElement : inspectElementRaw(id);
+            if (result === null) {
+              console.warn("Could not find DevToolsInstance with id \"".concat(id, "\""));
+              return;
+            }
+            var displayName = getDisplayNameForElementID(id);
+            var supportsGroup = typeof console.groupCollapsed === 'function';
+            if (supportsGroup) {
+              console.groupCollapsed("[Click to expand] %c<".concat(displayName || 'Component', " />"),
+              // --dom-tag-name-color is the CSS variable Chrome styles HTML elements with in the console.
+              'color: var(--dom-tag-name-color); font-weight: normal;');
+            }
+            if (result.props !== null) {
+              console.log('Props:', result.props);
+            }
+            if (result.state !== null) {
+              console.log('State:', result.state);
+            }
+            if (result.hooks !== null) {
+              console.log('Hooks:', result.hooks);
+            }
+            var hostInstances = findHostInstancesForElementID(id);
+            if (hostInstances !== null) {
+              console.log('Nodes:', hostInstances);
+            }
+            if (window.chrome || /firefox/i.test(navigator.userAgent)) {
+              console.log('Right-click any value to save it as a global variable for further inspection.');
+            }
+            if (supportsGroup) {
+              console.groupEnd();
+            }
+          }
+          function deletePath(type, id, hookID, path) {
+            var devtoolsInstance = idToDevToolsInstanceMap.get(id);
+            if (devtoolsInstance === undefined) {
+              console.warn("Could not find DevToolsInstance with id \"".concat(id, "\""));
+              return;
+            }
+            if (devtoolsInstance.kind !== FIBER_INSTANCE) {
+              // TODO: Handle VirtualInstance.
+              return;
+            }
+            var fiber = devtoolsInstance.data;
+            if (fiber !== null) {
+              var instance = fiber.stateNode;
+              switch (type) {
+                case 'context':
+                  // To simplify hydration and display of primitive context values (e.g. number, string)
+                  // the inspectElement() method wraps context in a {value: ...} object.
+                  // We need to remove the first part of the path (the "value") before continuing.
+                  path = path.slice(1);
+                  switch (fiber.tag) {
+                    case ClassComponent:
+                      if (path.length === 0) {// Simple context value (noop)
+                      } else {
+                        deletePathInObject(instance.context, path);
+                      }
+                      instance.forceUpdate();
+                      break;
+                    case FunctionComponent:
+                      // Function components using legacy context are not editable
+                      // because there's no instance on which to create a cloned, mutated context.
+                      break;
+                  }
+                  break;
+                case 'hooks':
+                  if (typeof overrideHookStateDeletePath === 'function') {
+                    overrideHookStateDeletePath(fiber, hookID, path);
+                  }
+                  break;
+                case 'props':
+                  if (instance === null) {
+                    if (typeof overridePropsDeletePath === 'function') {
+                      overridePropsDeletePath(fiber, path);
+                    }
+                  } else {
+                    fiber.pendingProps = copyWithDelete(instance.props, path);
+                    instance.forceUpdate();
+                  }
+                  break;
+                case 'state':
+                  deletePathInObject(instance.state, path);
+                  instance.forceUpdate();
+                  break;
+              }
+            }
+          }
+          function renamePath(type, id, hookID, oldPath, newPath) {
+            var devtoolsInstance = idToDevToolsInstanceMap.get(id);
+            if (devtoolsInstance === undefined) {
+              console.warn("Could not find DevToolsInstance with id \"".concat(id, "\""));
+              return;
+            }
+            if (devtoolsInstance.kind !== FIBER_INSTANCE) {
+              // TODO: Handle VirtualInstance.
+              return;
+            }
+            var fiber = devtoolsInstance.data;
+            if (fiber !== null) {
+              var instance = fiber.stateNode;
+              switch (type) {
+                case 'context':
+                  // To simplify hydration and display of primitive context values (e.g. number, string)
+                  // the inspectElement() method wraps context in a {value: ...} object.
+                  // We need to remove the first part of the path (the "value") before continuing.
+                  oldPath = oldPath.slice(1);
+                  newPath = newPath.slice(1);
+                  switch (fiber.tag) {
+                    case ClassComponent:
+                      if (oldPath.length === 0) {// Simple context value (noop)
+                      } else {
+                        renamePathInObject(instance.context, oldPath, newPath);
+                      }
+                      instance.forceUpdate();
+                      break;
+                    case FunctionComponent:
+                      // Function components using legacy context are not editable
+                      // because there's no instance on which to create a cloned, mutated context.
+                      break;
+                  }
+                  break;
+                case 'hooks':
+                  if (typeof overrideHookStateRenamePath === 'function') {
+                    overrideHookStateRenamePath(fiber, hookID, oldPath, newPath);
+                  }
+                  break;
+                case 'props':
+                  if (instance === null) {
+                    if (typeof overridePropsRenamePath === 'function') {
+                      overridePropsRenamePath(fiber, oldPath, newPath);
+                    }
+                  } else {
+                    fiber.pendingProps = copyWithRename(instance.props, oldPath, newPath);
+                    instance.forceUpdate();
+                  }
+                  break;
+                case 'state':
+                  renamePathInObject(instance.state, oldPath, newPath);
+                  instance.forceUpdate();
+                  break;
+              }
+            }
+          }
+          function overrideValueAtPath(type, id, hookID, path, value) {
+            var devtoolsInstance = idToDevToolsInstanceMap.get(id);
+            if (devtoolsInstance === undefined) {
+              console.warn("Could not find DevToolsInstance with id \"".concat(id, "\""));
+              return;
+            }
+            if (devtoolsInstance.kind !== FIBER_INSTANCE) {
+              // TODO: Handle VirtualInstance.
+              return;
+            }
+            var fiber = devtoolsInstance.data;
+            if (fiber !== null) {
+              var instance = fiber.stateNode;
+              switch (type) {
+                case 'context':
+                  // To simplify hydration and display of primitive context values (e.g. number, string)
+                  // the inspectElement() method wraps context in a {value: ...} object.
+                  // We need to remove the first part of the path (the "value") before continuing.
+                  path = path.slice(1);
+                  switch (fiber.tag) {
+                    case ClassComponent:
+                      if (path.length === 0) {
+                        // Simple context value
+                        instance.context = value;
+                      } else {
+                        utils_setInObject(instance.context, path, value);
+                      }
+                      instance.forceUpdate();
+                      break;
+                    case FunctionComponent:
+                      // Function components using legacy context are not editable
+                      // because there's no instance on which to create a cloned, mutated context.
+                      break;
+                  }
+                  break;
+                case 'hooks':
+                  if (typeof overrideHookState === 'function') {
+                    overrideHookState(fiber, hookID, path, value);
+                  }
+                  break;
+                case 'props':
+                  switch (fiber.tag) {
+                    case ClassComponent:
+                      fiber.pendingProps = copyWithSet(instance.props, path, value);
+                      instance.forceUpdate();
+                      break;
+                    default:
+                      if (typeof overrideProps === 'function') {
+                        overrideProps(fiber, path, value);
+                      }
+                      break;
+                  }
+                  break;
+                case 'state':
+                  switch (fiber.tag) {
+                    case ClassComponent:
+                      utils_setInObject(instance.state, path, value);
+                      instance.forceUpdate();
+                      break;
+                  }
+                  break;
+              }
+            }
+          }
+          var currentCommitProfilingMetadata = null;
+          var displayNamesByRootID = null;
+          var initialTreeBaseDurationsMap = null;
+          var isProfiling = false;
+          var profilingStartTime = 0;
+          var recordChangeDescriptions = false;
+          var recordTimeline = false;
+          var rootToCommitProfilingMetadataMap = null;
+          function getProfilingData() {
+            var dataForRoots = [];
+            if (rootToCommitProfilingMetadataMap === null) {
+              throw Error('getProfilingData() called before any profiling data was recorded');
+            }
+            rootToCommitProfilingMetadataMap.forEach(function (commitProfilingMetadata, rootID) {
+              var commitData = [];
+              var displayName = displayNamesByRootID !== null && displayNamesByRootID.get(rootID) || 'Unknown';
+              var initialTreeBaseDurations = initialTreeBaseDurationsMap !== null && initialTreeBaseDurationsMap.get(rootID) || [];
+              commitProfilingMetadata.forEach(function (commitProfilingData, commitIndex) {
+                var changeDescriptions = commitProfilingData.changeDescriptions,
+                  durations = commitProfilingData.durations,
+                  effectDuration = commitProfilingData.effectDuration,
+                  maxActualDuration = commitProfilingData.maxActualDuration,
+                  passiveEffectDuration = commitProfilingData.passiveEffectDuration,
+                  priorityLevel = commitProfilingData.priorityLevel,
+                  commitTime = commitProfilingData.commitTime,
+                  updaters = commitProfilingData.updaters;
+                var fiberActualDurations = [];
+                var fiberSelfDurations = [];
+                for (var i = 0; i < durations.length; i += 3) {
+                  var fiberID = durations[i];
+                  fiberActualDurations.push([fiberID, formatDurationToMicrosecondsGranularity(durations[i + 1])]);
+                  fiberSelfDurations.push([fiberID, formatDurationToMicrosecondsGranularity(durations[i + 2])]);
+                }
+                commitData.push({
+                  changeDescriptions: changeDescriptions !== null ? Array.from(changeDescriptions.entries()) : null,
+                  duration: formatDurationToMicrosecondsGranularity(maxActualDuration),
+                  effectDuration: effectDuration !== null ? formatDurationToMicrosecondsGranularity(effectDuration) : null,
+                  fiberActualDurations: fiberActualDurations,
+                  fiberSelfDurations: fiberSelfDurations,
+                  passiveEffectDuration: passiveEffectDuration !== null ? formatDurationToMicrosecondsGranularity(passiveEffectDuration) : null,
+                  priorityLevel: priorityLevel,
+                  timestamp: commitTime,
+                  updaters: updaters
+                });
+              });
+              dataForRoots.push({
+                commitData: commitData,
+                displayName: displayName,
+                initialTreeBaseDurations: initialTreeBaseDurations,
+                rootID: rootID
+              });
+            });
+            var timelineData = null;
+            if (typeof getTimelineData === 'function') {
+              var currentTimelineData = getTimelineData();
+              if (currentTimelineData) {
+                var batchUIDToMeasuresMap = currentTimelineData.batchUIDToMeasuresMap,
+                  internalModuleSourceToRanges = currentTimelineData.internalModuleSourceToRanges,
+                  laneToLabelMap = currentTimelineData.laneToLabelMap,
+                  laneToReactMeasureMap = currentTimelineData.laneToReactMeasureMap,
+                  rest = _objectWithoutProperties(currentTimelineData, ["batchUIDToMeasuresMap", "internalModuleSourceToRanges", "laneToLabelMap", "laneToReactMeasureMap"]);
+                timelineData = renderer_objectSpread(renderer_objectSpread({}, rest), {}, {
+                  // Most of the data is safe to parse as-is,
+                  // but we need to convert the nested Arrays back to Maps.
+                  // Most of the data is safe to serialize as-is,
+                  // but we need to convert the Maps to nested Arrays.
+                  batchUIDToMeasuresKeyValueArray: Array.from(batchUIDToMeasuresMap.entries()),
+                  internalModuleSourceToRanges: Array.from(internalModuleSourceToRanges.entries()),
+                  laneToLabelKeyValueArray: Array.from(laneToLabelMap.entries()),
+                  laneToReactMeasureKeyValueArray: Array.from(laneToReactMeasureMap.entries())
+                });
+              }
+            }
+            return {
+              dataForRoots: dataForRoots,
+              rendererID: rendererID,
+              timelineData: timelineData
+            };
+          }
+          function snapshotTreeBaseDurations(instance, target) {
+            // We don't need to convert milliseconds to microseconds in this case,
+            // because the profiling summary is JSON serialized.
+            if (instance.kind !== FILTERED_FIBER_INSTANCE) {
+              target.push([instance.id, instance.treeBaseDuration]);
+            }
+            for (var child = instance.firstChild; child !== null; child = child.nextSibling) {
+              snapshotTreeBaseDurations(child, target);
+            }
+          }
+          function startProfiling(shouldRecordChangeDescriptions, shouldRecordTimeline) {
+            if (isProfiling) {
+              return;
+            }
+            recordChangeDescriptions = shouldRecordChangeDescriptions;
+            recordTimeline = shouldRecordTimeline; // Capture initial values as of the time profiling starts.
+            // It's important we snapshot both the durations and the id-to-root map,
+            // since either of these may change during the profiling session
+            // (e.g. when a fiber is re-rendered or when a fiber gets removed).
+
+            displayNamesByRootID = new Map();
+            initialTreeBaseDurationsMap = new Map();
+            hook.getFiberRoots(rendererID).forEach(function (root) {
+              var rootInstance = rootToFiberInstanceMap.get(root);
+              if (rootInstance === undefined) {
+                throw new Error('Expected the root instance to already exist when starting profiling');
+              }
+              var rootID = rootInstance.id;
+              displayNamesByRootID.set(rootID, getDisplayNameForRoot(root.current));
+              var initialTreeBaseDurations = [];
+              snapshotTreeBaseDurations(rootInstance, initialTreeBaseDurations);
+              initialTreeBaseDurationsMap.set(rootID, initialTreeBaseDurations);
+            });
+            isProfiling = true;
+            profilingStartTime = renderer_getCurrentTime();
+            rootToCommitProfilingMetadataMap = new Map();
+            if (toggleProfilingStatus !== null) {
+              toggleProfilingStatus(true, recordTimeline);
+            }
+          }
+          function stopProfiling() {
+            isProfiling = false;
+            recordChangeDescriptions = false;
+            if (toggleProfilingStatus !== null) {
+              toggleProfilingStatus(false, recordTimeline);
+            }
+            recordTimeline = false;
+          } // Automatically start profiling so that we don't miss timing info from initial "mount".
+
+          if (shouldStartProfilingNow) {
+            startProfiling(profilingSettings.recordChangeDescriptions, profilingSettings.recordTimeline);
+          }
+          function getNearestFiber(devtoolsInstance) {
+            if (devtoolsInstance.kind === VIRTUAL_INSTANCE) {
+              var inst = devtoolsInstance;
+              while (inst.kind === VIRTUAL_INSTANCE) {
+                // For virtual instances, we search deeper until we find a Fiber instance.
+                // Then we search upwards from that Fiber. That's because Virtual Instances
+                // will always have an Fiber child filtered or not. If we searched its parents
+                // we might skip through a filtered Error Boundary before we hit a FiberInstance.
+                if (inst.firstChild === null) {
+                  return null;
+                }
+                inst = inst.firstChild;
+              }
+              return inst.data.return;
+            } else {
+              return devtoolsInstance.data;
+            }
+          } // React will switch between these implementations depending on whether
+          // we have any manually suspended/errored-out Fibers or not.
+
+          function shouldErrorFiberAlwaysNull() {
+            return null;
+          } // Map of Fiber and its force error status: true (error), false (toggled off)
+
+          var forceErrorForFibers = new Map();
+          function shouldErrorFiberAccordingToMap(fiber) {
+            if (typeof setErrorHandler !== 'function') {
+              throw new Error('Expected overrideError() to not get called for earlier React versions.');
+            }
+            var status = forceErrorForFibers.get(fiber);
+            if (status === false) {
+              // TRICKY overrideError adds entries to this Map,
+              // so ideally it would be the method that clears them too,
+              // but that would break the functionality of the feature,
+              // since DevTools needs to tell React to act differently than it normally would
+              // (don't just re-render the failed boundary, but reset its errored state too).
+              // So we can only clear it after telling React to reset the state.
+              // Technically this is premature and we should schedule it for later,
+              // since the render could always fail without committing the updated error boundary,
+              // but since this is a DEV-only feature, the simplicity is worth the trade off.
+              forceErrorForFibers.delete(fiber);
+              if (forceErrorForFibers.size === 0) {
+                // Last override is gone. Switch React back to fast path.
+                setErrorHandler(shouldErrorFiberAlwaysNull);
+              }
+              return false;
+            }
+            if (status === undefined && fiber.alternate !== null) {
+              status = forceErrorForFibers.get(fiber.alternate);
+              if (status === false) {
+                forceErrorForFibers.delete(fiber.alternate);
+                if (forceErrorForFibers.size === 0) {
+                  // Last override is gone. Switch React back to fast path.
+                  setErrorHandler(shouldErrorFiberAlwaysNull);
+                }
+              }
+            }
+            if (status === undefined) {
+              return false;
+            }
+            return status;
+          }
+          function overrideError(id, forceError) {
+            if (typeof setErrorHandler !== 'function' || typeof scheduleUpdate !== 'function') {
+              throw new Error('Expected overrideError() to not get called for earlier React versions.');
+            }
+            var devtoolsInstance = idToDevToolsInstanceMap.get(id);
+            if (devtoolsInstance === undefined) {
+              return;
+            }
+            var nearestFiber = getNearestFiber(devtoolsInstance);
+            if (nearestFiber === null) {
+              return;
+            }
+            var fiber = nearestFiber;
+            while (!isErrorBoundary(fiber)) {
+              if (fiber.return === null) {
+                return;
+              }
+              fiber = fiber.return;
+            }
+            forceErrorForFibers.set(fiber, forceError);
+            if (fiber.alternate !== null) {
+              // We only need one of the Fibers in the set.
+              forceErrorForFibers.delete(fiber.alternate);
+            }
+            if (forceErrorForFibers.size === 1) {
+              // First override is added. Switch React to slower path.
+              setErrorHandler(shouldErrorFiberAccordingToMap);
+            }
+            scheduleUpdate(fiber);
+          }
+          function shouldSuspendFiberAlwaysFalse() {
+            return false;
+          }
+          var forceFallbackForFibers = new Set();
+          function shouldSuspendFiberAccordingToSet(fiber) {
+            return forceFallbackForFibers.has(fiber) || fiber.alternate !== null && forceFallbackForFibers.has(fiber.alternate);
+          }
+          function overrideSuspense(id, forceFallback) {
+            if (typeof setSuspenseHandler !== 'function' || typeof scheduleUpdate !== 'function') {
+              throw new Error('Expected overrideSuspense() to not get called for earlier React versions.');
+            }
+            var devtoolsInstance = idToDevToolsInstanceMap.get(id);
+            if (devtoolsInstance === undefined) {
+              return;
+            }
+            var nearestFiber = getNearestFiber(devtoolsInstance);
+            if (nearestFiber === null) {
+              return;
+            }
+            var fiber = nearestFiber;
+            while (fiber.tag !== SuspenseComponent) {
+              if (fiber.return === null) {
+                return;
+              }
+              fiber = fiber.return;
+            }
+            if (fiber.alternate !== null) {
+              // We only need one of the Fibers in the set.
+              forceFallbackForFibers.delete(fiber.alternate);
+            }
+            if (forceFallback) {
+              forceFallbackForFibers.add(fiber);
+              if (forceFallbackForFibers.size === 1) {
+                // First override is added. Switch React to slower path.
+                setSuspenseHandler(shouldSuspendFiberAccordingToSet);
+              }
+            } else {
+              forceFallbackForFibers.delete(fiber);
+              if (forceFallbackForFibers.size === 0) {
+                // Last override is gone. Switch React back to fast path.
+                setSuspenseHandler(shouldSuspendFiberAlwaysFalse);
+              }
+            }
+            scheduleUpdate(fiber);
+          } // Remember if we're trying to restore the selection after reload.
+          // In that case, we'll do some extra checks for matching mounts.
+
+          var trackedPath = null;
+          var trackedPathMatchFiber = null; // This is the deepest unfiltered match of a Fiber.
+
+          var trackedPathMatchInstance = null; // This is the deepest matched filtered Instance.
+
+          var trackedPathMatchDepth = -1;
+          var mightBeOnTrackedPath = false;
+          function setTrackedPath(path) {
+            if (path === null) {
+              trackedPathMatchFiber = null;
+              trackedPathMatchInstance = null;
+              trackedPathMatchDepth = -1;
+              mightBeOnTrackedPath = false;
+            }
+            trackedPath = path;
+          } // We call this before traversing a new mount.
+          // It remembers whether this Fiber is the next best match for tracked path.
+          // The return value signals whether we should keep matching siblings or not.
+
+          function updateTrackedPathStateBeforeMount(fiber, fiberInstance) {
+            if (trackedPath === null || !mightBeOnTrackedPath) {
+              // Fast path: there's nothing to track so do nothing and ignore siblings.
+              return false;
+            }
+            var returnFiber = fiber.return;
+            var returnAlternate = returnFiber !== null ? returnFiber.alternate : null; // By now we know there's some selection to restore, and this is a new Fiber.
+            // Is this newly mounted Fiber a direct child of the current best match?
+            // (This will also be true for new roots if we haven't matched anything yet.)
+
+            if (trackedPathMatchFiber === returnFiber || trackedPathMatchFiber === returnAlternate && returnAlternate !== null) {
+              // Is this the next Fiber we should select? Let's compare the frames.
+              var actualFrame = getPathFrame(fiber); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+              var expectedFrame = trackedPath[trackedPathMatchDepth + 1];
+              if (expectedFrame === undefined) {
+                throw new Error('Expected to see a frame at the next depth.');
+              }
+              if (actualFrame.index === expectedFrame.index && actualFrame.key === expectedFrame.key && actualFrame.displayName === expectedFrame.displayName) {
+                // We have our next match.
+                trackedPathMatchFiber = fiber;
+                if (fiberInstance !== null && fiberInstance.kind === FIBER_INSTANCE) {
+                  trackedPathMatchInstance = fiberInstance;
+                }
+                trackedPathMatchDepth++; // Are we out of frames to match?
+                // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+                if (trackedPathMatchDepth === trackedPath.length - 1) {
+                  // There's nothing that can possibly match afterwards.
+                  // Don't check the children.
+                  mightBeOnTrackedPath = false;
+                } else {
+                  // Check the children, as they might reveal the next match.
+                  mightBeOnTrackedPath = true;
+                } // In either case, since we have a match, we don't need
+                // to check the siblings. They'll never match.
+
+                return false;
+              }
+            }
+            if (trackedPathMatchFiber === null && fiberInstance === null) {
+              // We're now looking for a Virtual Instance. It might be inside filtered Fibers
+              // so we keep looking below.
+              return true;
+            } // This Fiber's parent is on the path, but this Fiber itself isn't.
+            // There's no need to check its children--they won't be on the path either.
+
+            mightBeOnTrackedPath = false; // However, one of its siblings may be on the path so keep searching.
+
+            return true;
+          }
+          function updateVirtualTrackedPathStateBeforeMount(virtualInstance, parentInstance) {
+            if (trackedPath === null || !mightBeOnTrackedPath) {
+              // Fast path: there's nothing to track so do nothing and ignore siblings.
+              return false;
+            } // Check if we've matched our nearest unfiltered parent so far.
+
+            if (trackedPathMatchInstance === parentInstance) {
+              var actualFrame = getVirtualPathFrame(virtualInstance); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+              var expectedFrame = trackedPath[trackedPathMatchDepth + 1];
+              if (expectedFrame === undefined) {
+                throw new Error('Expected to see a frame at the next depth.');
+              }
+              if (actualFrame.index === expectedFrame.index && actualFrame.key === expectedFrame.key && actualFrame.displayName === expectedFrame.displayName) {
+                // We have our next match.
+                trackedPathMatchFiber = null; // Don't bother looking in Fibers anymore. We're deeper now.
+
+                trackedPathMatchInstance = virtualInstance;
+                trackedPathMatchDepth++; // Are we out of frames to match?
+                // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+                if (trackedPathMatchDepth === trackedPath.length - 1) {
+                  // There's nothing that can possibly match afterwards.
+                  // Don't check the children.
+                  mightBeOnTrackedPath = false;
+                } else {
+                  // Check the children, as they might reveal the next match.
+                  mightBeOnTrackedPath = true;
+                } // In either case, since we have a match, we don't need
+                // to check the siblings. They'll never match.
+
+                return false;
+              }
+            }
+            if (trackedPathMatchFiber !== null) {
+              // We're still looking for a Fiber which might be underneath this instance.
+              return true;
+            } // This Instance's parent is on the path, but this Instance itself isn't.
+            // There's no need to check its children--they won't be on the path either.
+
+            mightBeOnTrackedPath = false; // However, one of its siblings may be on the path so keep searching.
+
+            return true;
+          }
+          function updateTrackedPathStateAfterMount(mightSiblingsBeOnTrackedPath) {
+            // updateTrackedPathStateBeforeMount() told us whether to match siblings.
+            // Now that we're entering siblings, let's use that information.
+            mightBeOnTrackedPath = mightSiblingsBeOnTrackedPath;
+          } // Roots don't have a real persistent identity.
+          // A root's "pseudo key" is "childDisplayName:indexWithThatName".
+          // For example, "App:0" or, in case of similar roots, "Story:0", "Story:1", etc.
+          // We will use this to try to disambiguate roots when restoring selection between reloads.
+
+          var rootPseudoKeys = new Map();
+          var rootDisplayNameCounter = new Map();
+          function setRootPseudoKey(id, fiber) {
+            var name = getDisplayNameForRoot(fiber);
+            var counter = rootDisplayNameCounter.get(name) || 0;
+            rootDisplayNameCounter.set(name, counter + 1);
+            var pseudoKey = "".concat(name, ":").concat(counter);
+            rootPseudoKeys.set(id, pseudoKey);
+          }
+          function removeRootPseudoKey(id) {
+            var pseudoKey = rootPseudoKeys.get(id);
+            if (pseudoKey === undefined) {
+              throw new Error('Expected root pseudo key to be known.');
+            }
+            var name = pseudoKey.slice(0, pseudoKey.lastIndexOf(':'));
+            var counter = rootDisplayNameCounter.get(name);
+            if (counter === undefined) {
+              throw new Error('Expected counter to be known.');
+            }
+            if (counter > 1) {
+              rootDisplayNameCounter.set(name, counter - 1);
+            } else {
+              rootDisplayNameCounter.delete(name);
+            }
+            rootPseudoKeys.delete(id);
+          }
+          function getDisplayNameForRoot(fiber) {
+            var preferredDisplayName = null;
+            var fallbackDisplayName = null;
+            var child = fiber.child; // Go at most three levels deep into direct children
+            // while searching for a child that has a displayName.
+
+            for (var i = 0; i < 3; i++) {
+              if (child === null) {
+                break;
+              }
+              var displayName = getDisplayNameForFiber(child);
+              if (displayName !== null) {
+                // Prefer display names that we get from user-defined components.
+                // We want to avoid using e.g. 'Suspense' unless we find nothing else.
+                if (typeof child.type === 'function') {
+                  // There's a few user-defined tags, but we'll prefer the ones
+                  // that are usually explicitly named (function or class components).
+                  preferredDisplayName = displayName;
+                } else if (fallbackDisplayName === null) {
+                  fallbackDisplayName = displayName;
+                }
+              }
+              if (preferredDisplayName !== null) {
+                break;
+              }
+              child = child.child;
+            }
+            return preferredDisplayName || fallbackDisplayName || 'Anonymous';
+          }
+          function getPathFrame(fiber) {
+            var key = fiber.key;
+            var displayName = getDisplayNameForFiber(fiber);
+            var index = fiber.index;
+            switch (fiber.tag) {
+              case HostRoot:
+                // Roots don't have a real displayName, index, or key.
+                // Instead, we'll use the pseudo key (childDisplayName:indexWithThatName).
+                var rootInstance = rootToFiberInstanceMap.get(fiber.stateNode);
+                if (rootInstance === undefined) {
+                  throw new Error('Expected the root instance to exist when computing a path');
+                }
+                var pseudoKey = rootPseudoKeys.get(rootInstance.id);
+                if (pseudoKey === undefined) {
+                  throw new Error('Expected mounted root to have known pseudo key.');
+                }
+                displayName = pseudoKey;
+                break;
+              case HostComponent:
+                displayName = fiber.type;
+                break;
+              default:
+                break;
+            }
+            return {
+              displayName: displayName,
+              key: key,
+              index: index
+            };
+          }
+          function getVirtualPathFrame(virtualInstance) {
+            return {
+              displayName: virtualInstance.data.name || '',
+              key: virtualInstance.data.key == null ? null : virtualInstance.data.key,
+              index: -1 // We use -1 to indicate that this is a virtual path frame.
+            };
+          } // Produces a serializable representation that does a best effort
+          // of identifying a particular Fiber between page reloads.
+          // The return path will contain Fibers that are "invisible" to the store
+          // because their keys and indexes are important to restoring the selection.
+
+          function getPathForElement(id) {
+            var devtoolsInstance = idToDevToolsInstanceMap.get(id);
+            if (devtoolsInstance === undefined) {
+              return null;
+            }
+            var keyPath = [];
+            var inst = devtoolsInstance;
+            while (inst.kind === VIRTUAL_INSTANCE) {
+              keyPath.push(getVirtualPathFrame(inst));
+              if (inst.parent === null) {
+                // This is a bug but non-essential. We should've found a root instance.
+                return null;
+              }
+              inst = inst.parent;
+            }
+            var fiber = inst.data;
+            while (fiber !== null) {
+              // $FlowFixMe[incompatible-call] found when upgrading Flow
+              keyPath.push(getPathFrame(fiber)); // $FlowFixMe[incompatible-use] found when upgrading Flow
+
+              fiber = fiber.return;
+            }
+            keyPath.reverse();
+            return keyPath;
+          }
+          function getBestMatchForTrackedPath() {
+            if (trackedPath === null) {
+              // Nothing to match.
+              return null;
+            }
+            if (trackedPathMatchInstance === null) {
+              // We didn't find anything.
+              return null;
+            }
+            return {
+              id: trackedPathMatchInstance.id,
+              // $FlowFixMe[incompatible-use] found when upgrading Flow
+              isFullMatch: trackedPathMatchDepth === trackedPath.length - 1
+            };
+          }
+          var formatPriorityLevel = function formatPriorityLevel(priorityLevel) {
+            if (priorityLevel == null) {
+              return 'Unknown';
+            }
+            switch (priorityLevel) {
+              case ImmediatePriority:
+                return 'Immediate';
+              case UserBlockingPriority:
+                return 'User-Blocking';
+              case NormalPriority:
+                return 'Normal';
+              case LowPriority:
+                return 'Low';
+              case IdlePriority:
+                return 'Idle';
+              case NoPriority:
+              default:
+                return 'Unknown';
+            }
+          };
+          function setTraceUpdatesEnabled(isEnabled) {
+            traceUpdatesEnabled = isEnabled;
+          }
+          function hasElementWithId(id) {
+            return idToDevToolsInstanceMap.has(id);
+          }
+          function getSourceForFiberInstance(fiberInstance) {
+            // Favor the owner source if we have one.
+            var ownerSource = getSourceForInstance(fiberInstance);
+            if (ownerSource !== null) {
+              return ownerSource;
+            } // Otherwise fallback to the throwing trick.
+
+            var dispatcherRef = getDispatcherRef(renderer);
+            var stackFrame = dispatcherRef == null ? null : getSourceLocationByFiber(ReactTypeOfWork, fiberInstance.data, dispatcherRef);
+            if (stackFrame === null) {
+              return null;
+            }
+            var source = parseSourceFromComponentStack(stackFrame);
+            fiberInstance.source = source;
+            return source;
+          }
+          function getSourceForInstance(instance) {
+            var unresolvedSource = instance.source;
+            if (unresolvedSource === null) {
+              // We don't have any source yet. We can try again later in case an owned child mounts later.
+              // TODO: We won't have any information here if the child is filtered.
+              return null;
+            }
+            if (instance.kind === VIRTUAL_INSTANCE) {
+              // We might have found one on the virtual instance.
+              var debugLocation = instance.data.debugLocation;
+              if (debugLocation != null) {
+                unresolvedSource = debugLocation;
+              }
+            } // If we have the debug stack (the creation stack of the JSX) for any owned child of this
+            // component, then at the bottom of that stack will be a stack frame that is somewhere within
+            // the component's function body. Typically it would be the callsite of the JSX unless there's
+            // any intermediate utility functions. This won't point to the top of the component function
+            // but it's at least somewhere within it.
+
+            if (renderer_isError(unresolvedSource)) {
+              return instance.source = parseSourceFromOwnerStack(unresolvedSource);
+            }
+            if (typeof unresolvedSource === 'string') {
+              var idx = unresolvedSource.lastIndexOf('\n');
+              var lastLine = idx === -1 ? unresolvedSource : unresolvedSource.slice(idx + 1);
+              return instance.source = parseSourceFromComponentStack(lastLine);
+            } // $FlowFixMe: refined.
+
+            return unresolvedSource;
+          }
+          var internalMcpFunctions = {};
+          if (false) {}
+          return renderer_objectSpread({
+            cleanup: cleanup,
+            clearErrorsAndWarnings: clearErrorsAndWarnings,
+            clearErrorsForElementID: clearErrorsForElementID,
+            clearWarningsForElementID: clearWarningsForElementID,
+            getSerializedElementValueByPath: getSerializedElementValueByPath,
+            deletePath: deletePath,
+            findHostInstancesForElementID: findHostInstancesForElementID,
+            flushInitialOperations: flushInitialOperations,
+            getBestMatchForTrackedPath: getBestMatchForTrackedPath,
+            getDisplayNameForElementID: getDisplayNameForElementID,
+            getNearestMountedDOMNode: getNearestMountedDOMNode,
+            getElementIDForHostInstance: getElementIDForHostInstance,
+            getInstanceAndStyle: getInstanceAndStyle,
+            getOwnersList: getOwnersList,
+            getPathForElement: getPathForElement,
+            getProfilingData: getProfilingData,
+            handleCommitFiberRoot: handleCommitFiberRoot,
+            handleCommitFiberUnmount: handleCommitFiberUnmount,
+            handlePostCommitFiberRoot: handlePostCommitFiberRoot,
+            hasElementWithId: hasElementWithId,
+            inspectElement: inspectElement,
+            logElementToConsole: logElementToConsole,
+            getComponentStack: getComponentStack,
+            getElementAttributeByPath: getElementAttributeByPath,
+            getElementSourceFunctionById: getElementSourceFunctionById,
+            onErrorOrWarning: onErrorOrWarning,
+            overrideError: overrideError,
+            overrideSuspense: overrideSuspense,
+            overrideValueAtPath: overrideValueAtPath,
+            renamePath: renamePath,
+            renderer: renderer,
+            setTraceUpdatesEnabled: setTraceUpdatesEnabled,
+            setTrackedPath: setTrackedPath,
+            startProfiling: startProfiling,
+            stopProfiling: stopProfiling,
+            storeAsGlobal: storeAsGlobal,
+            updateComponentFilters: updateComponentFilters,
+            getEnvironmentNames: getEnvironmentNames
+          }, internalMcpFunctions);
+        }
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/legacy/utils.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.
+         *
+         * 
+         */
+        function decorate(object, attr, fn) {
+          var old = object[attr]; // $FlowFixMe[missing-this-annot] webpack config needs to be updated to allow `this` type annotations
+
+          object[attr] = function (instance) {
+            return fn.call(this, old, arguments);
+          };
+          return old;
+        }
+        function decorateMany(source, fns) {
+          var olds = {};
+          for (var name in fns) {
+            olds[name] = decorate(source, name, fns[name]);
+          }
+          return olds;
+        }
+        function restoreMany(source, olds) {
+          for (var name in olds) {
+            source[name] = olds[name];
+          }
+        } // $FlowFixMe[missing-this-annot] webpack config needs to be updated to allow `this` type annotations
+
+        function forceUpdate(instance) {
+          if (typeof instance.forceUpdate === 'function') {
+            instance.forceUpdate();
+          } else if (instance.updater != null && typeof instance.updater.enqueueForceUpdate === 'function') {
+            instance.updater.enqueueForceUpdate(this, function () {}, 'forceUpdate');
+          }
+        }
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/legacy/renderer.js
+        function legacy_renderer_ownKeys(object, enumerableOnly) {
+          var keys = Object.keys(object);
+          if (Object.getOwnPropertySymbols) {
+            var symbols = Object.getOwnPropertySymbols(object);
+            if (enumerableOnly) symbols = symbols.filter(function (sym) {
+              return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+            keys.push.apply(keys, symbols);
+          }
+          return keys;
+        }
+        function legacy_renderer_objectSpread(target) {
+          for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i] != null ? arguments[i] : {};
+            if (i % 2) {
+              legacy_renderer_ownKeys(Object(source), true).forEach(function (key) {
+                legacy_renderer_defineProperty(target, key, source[key]);
+              });
+            } else if (Object.getOwnPropertyDescriptors) {
+              Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+            } else {
+              legacy_renderer_ownKeys(Object(source)).forEach(function (key) {
+                Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+              });
+            }
+          }
+          return target;
+        }
+        function legacy_renderer_defineProperty(obj, key, value) {
+          if (key in obj) {
+            Object.defineProperty(obj, key, {
+              value: value,
+              enumerable: true,
+              configurable: true,
+              writable: true
+            });
+          } else {
+            obj[key] = value;
+          }
+          return obj;
+        }
+        function legacy_renderer_typeof(obj) {
+          "@babel/helpers - typeof";
+
+          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+            legacy_renderer_typeof = function _typeof(obj) {
+              return typeof obj;
+            };
+          } else {
+            legacy_renderer_typeof = function _typeof(obj) {
+              return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+            };
+          }
+          return legacy_renderer_typeof(obj);
+        }
+
+        /**
+         * 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.
+         *
+         * 
+         */
+
+        function getData(internalInstance) {
+          var displayName = null;
+          var key = null; // != used deliberately here to catch undefined and null
+
+          if (internalInstance._currentElement != null) {
+            if (internalInstance._currentElement.key) {
+              key = String(internalInstance._currentElement.key);
+            }
+            var elementType = internalInstance._currentElement.type;
+            if (typeof elementType === 'string') {
+              displayName = elementType;
+            } else if (typeof elementType === 'function') {
+              displayName = getDisplayName(elementType);
+            }
+          }
+          return {
+            displayName: displayName,
+            key: key
+          };
+        }
+        function getElementType(internalInstance) {
+          // != used deliberately here to catch undefined and null
+          if (internalInstance._currentElement != null) {
+            var elementType = internalInstance._currentElement.type;
+            if (typeof elementType === 'function') {
+              var publicInstance = internalInstance.getPublicInstance();
+              if (publicInstance !== null) {
+                return types_ElementTypeClass;
+              } else {
+                return types_ElementTypeFunction;
+              }
+            } else if (typeof elementType === 'string') {
+              return ElementTypeHostComponent;
+            }
+          }
+          return ElementTypeOtherOrUnknown;
+        }
+        function getChildren(internalInstance) {
+          var children = []; // If the parent is a native node without rendered children, but with
+          // multiple string children, then the `element` that gets passed in here is
+          // a plain value -- a string or number.
+
+          if (legacy_renderer_typeof(internalInstance) !== 'object') {// No children
+          } else if (internalInstance._currentElement === null || internalInstance._currentElement === false) {// No children
+          } else if (internalInstance._renderedComponent) {
+            var child = internalInstance._renderedComponent;
+            if (getElementType(child) !== ElementTypeOtherOrUnknown) {
+              children.push(child);
+            }
+          } else if (internalInstance._renderedChildren) {
+            var renderedChildren = internalInstance._renderedChildren;
+            for (var name in renderedChildren) {
+              var _child = renderedChildren[name];
+              if (getElementType(_child) !== ElementTypeOtherOrUnknown) {
+                children.push(_child);
+              }
+            }
+          } // Note: we skip the case where children are just strings or numbers
+          // because the new DevTools skips over host text nodes anyway.
+
+          return children;
+        }
+        function legacy_renderer_attach(hook, rendererID, renderer, global) {
+          var idToInternalInstanceMap = new Map();
+          var internalInstanceToIDMap = new WeakMap();
+          var internalInstanceToRootIDMap = new WeakMap();
+          var getElementIDForHostInstance = null;
+          var findHostInstanceForInternalID;
+          var getNearestMountedDOMNode = function getNearestMountedDOMNode(node) {
+            // Not implemented.
+            return null;
+          };
+          if (renderer.ComponentTree) {
+            getElementIDForHostInstance = function getElementIDForHostInstance(node) {
+              var internalInstance = renderer.ComponentTree.getClosestInstanceFromNode(node);
+              return internalInstanceToIDMap.get(internalInstance) || null;
+            };
+            findHostInstanceForInternalID = function findHostInstanceForInternalID(id) {
+              var internalInstance = idToInternalInstanceMap.get(id);
+              return renderer.ComponentTree.getNodeFromInstance(internalInstance);
+            };
+            getNearestMountedDOMNode = function getNearestMountedDOMNode(node) {
+              var internalInstance = renderer.ComponentTree.getClosestInstanceFromNode(node);
+              if (internalInstance != null) {
+                return renderer.ComponentTree.getNodeFromInstance(internalInstance);
+              }
+              return null;
+            };
+          } else if (renderer.Mount.getID && renderer.Mount.getNode) {
+            getElementIDForHostInstance = function getElementIDForHostInstance(node) {
+              // Not implemented.
+              return null;
+            };
+            findHostInstanceForInternalID = function findHostInstanceForInternalID(id) {
+              // Not implemented.
+              return null;
+            };
+          }
+          function getDisplayNameForElementID(id) {
+            var internalInstance = idToInternalInstanceMap.get(id);
+            return internalInstance ? getData(internalInstance).displayName : null;
+          }
+          function getID(internalInstance) {
+            if (legacy_renderer_typeof(internalInstance) !== 'object' || internalInstance === null) {
+              throw new Error('Invalid internal instance: ' + internalInstance);
+            }
+            if (!internalInstanceToIDMap.has(internalInstance)) {
+              var _id = getUID();
+              internalInstanceToIDMap.set(internalInstance, _id);
+              idToInternalInstanceMap.set(_id, internalInstance);
+            }
+            return internalInstanceToIDMap.get(internalInstance);
+          }
+          function areEqualArrays(a, b) {
+            if (a.length !== b.length) {
+              return false;
+            }
+            for (var i = 0; i < a.length; i++) {
+              if (a[i] !== b[i]) {
+                return false;
+              }
+            }
+            return true;
+          } // This is shared mutable state that lets us keep track of where we are.
+
+          var parentIDStack = [];
+          var oldReconcilerMethods = null;
+          if (renderer.Reconciler) {
+            // React 15
+            oldReconcilerMethods = decorateMany(renderer.Reconciler, {
+              mountComponent: function mountComponent(fn, args) {
+                var internalInstance = args[0];
+                var hostContainerInfo = args[3];
+                if (getElementType(internalInstance) === ElementTypeOtherOrUnknown) {
+                  // $FlowFixMe[object-this-reference] found when upgrading Flow
+                  return fn.apply(this, args);
+                }
+                if (hostContainerInfo._topLevelWrapper === undefined) {
+                  // SSR
+                  // $FlowFixMe[object-this-reference] found when upgrading Flow
+                  return fn.apply(this, args);
+                }
+                var id = getID(internalInstance); // Push the operation.
+
+                var parentID = parentIDStack.length > 0 ? parentIDStack[parentIDStack.length - 1] : 0;
+                recordMount(internalInstance, id, parentID);
+                parentIDStack.push(id); // Remember the root.
+
+                internalInstanceToRootIDMap.set(internalInstance, getID(hostContainerInfo._topLevelWrapper));
+                try {
+                  // $FlowFixMe[object-this-reference] found when upgrading Flow
+                  var result = fn.apply(this, args);
+                  parentIDStack.pop();
+                  return result;
+                } catch (err) {
+                  parentIDStack = [];
+                  throw err;
+                } finally {
+                  if (parentIDStack.length === 0) {
+                    var rootID = internalInstanceToRootIDMap.get(internalInstance);
+                    if (rootID === undefined) {
+                      throw new Error('Expected to find root ID.');
+                    }
+                    flushPendingEvents(rootID);
+                  }
+                }
+              },
+              performUpdateIfNecessary: function performUpdateIfNecessary(fn, args) {
+                var internalInstance = args[0];
+                if (getElementType(internalInstance) === ElementTypeOtherOrUnknown) {
+                  // $FlowFixMe[object-this-reference] found when upgrading Flow
+                  return fn.apply(this, args);
+                }
+                var id = getID(internalInstance);
+                parentIDStack.push(id);
+                var prevChildren = getChildren(internalInstance);
+                try {
+                  // $FlowFixMe[object-this-reference] found when upgrading Flow
+                  var result = fn.apply(this, args);
+                  var nextChildren = getChildren(internalInstance);
+                  if (!areEqualArrays(prevChildren, nextChildren)) {
+                    // Push the operation
+                    recordReorder(internalInstance, id, nextChildren);
+                  }
+                  parentIDStack.pop();
+                  return result;
+                } catch (err) {
+                  parentIDStack = [];
+                  throw err;
+                } finally {
+                  if (parentIDStack.length === 0) {
+                    var rootID = internalInstanceToRootIDMap.get(internalInstance);
+                    if (rootID === undefined) {
+                      throw new Error('Expected to find root ID.');
+                    }
+                    flushPendingEvents(rootID);
+                  }
+                }
+              },
+              receiveComponent: function receiveComponent(fn, args) {
+                var internalInstance = args[0];
+                if (getElementType(internalInstance) === ElementTypeOtherOrUnknown) {
+                  // $FlowFixMe[object-this-reference] found when upgrading Flow
+                  return fn.apply(this, args);
+                }
+                var id = getID(internalInstance);
+                parentIDStack.push(id);
+                var prevChildren = getChildren(internalInstance);
+                try {
+                  // $FlowFixMe[object-this-reference] found when upgrading Flow
+                  var result = fn.apply(this, args);
+                  var nextChildren = getChildren(internalInstance);
+                  if (!areEqualArrays(prevChildren, nextChildren)) {
+                    // Push the operation
+                    recordReorder(internalInstance, id, nextChildren);
+                  }
+                  parentIDStack.pop();
+                  return result;
+                } catch (err) {
+                  parentIDStack = [];
+                  throw err;
+                } finally {
+                  if (parentIDStack.length === 0) {
+                    var rootID = internalInstanceToRootIDMap.get(internalInstance);
+                    if (rootID === undefined) {
+                      throw new Error('Expected to find root ID.');
+                    }
+                    flushPendingEvents(rootID);
+                  }
+                }
+              },
+              unmountComponent: function unmountComponent(fn, args) {
+                var internalInstance = args[0];
+                if (getElementType(internalInstance) === ElementTypeOtherOrUnknown) {
+                  // $FlowFixMe[object-this-reference] found when upgrading Flow
+                  return fn.apply(this, args);
+                }
+                var id = getID(internalInstance);
+                parentIDStack.push(id);
+                try {
+                  // $FlowFixMe[object-this-reference] found when upgrading Flow
+                  var result = fn.apply(this, args);
+                  parentIDStack.pop(); // Push the operation.
+
+                  recordUnmount(internalInstance, id);
+                  return result;
+                } catch (err) {
+                  parentIDStack = [];
+                  throw err;
+                } finally {
+                  if (parentIDStack.length === 0) {
+                    var rootID = internalInstanceToRootIDMap.get(internalInstance);
+                    if (rootID === undefined) {
+                      throw new Error('Expected to find root ID.');
+                    }
+                    flushPendingEvents(rootID);
+                  }
+                }
+              }
+            });
+          }
+          function cleanup() {
+            if (oldReconcilerMethods !== null) {
+              if (renderer.Component) {
+                restoreMany(renderer.Component.Mixin, oldReconcilerMethods);
+              } else {
+                restoreMany(renderer.Reconciler, oldReconcilerMethods);
+              }
+            }
+            oldReconcilerMethods = null;
+          }
+          function recordMount(internalInstance, id, parentID) {
+            var isRoot = parentID === 0;
+            if (__DEBUG__) {
+              console.log('%crecordMount()', 'color: green; font-weight: bold;', id, getData(internalInstance).displayName);
+            }
+            if (isRoot) {
+              // TODO Is this right? For all versions?
+              var hasOwnerMetadata = internalInstance._currentElement != null && internalInstance._currentElement._owner != null;
+              pushOperation(TREE_OPERATION_ADD);
+              pushOperation(id);
+              pushOperation(ElementTypeRoot);
+              pushOperation(0); // StrictMode compliant?
+
+              pushOperation(0); // Profiling flag
+
+              pushOperation(0); // StrictMode supported?
+
+              pushOperation(hasOwnerMetadata ? 1 : 0);
+            } else {
+              var type = getElementType(internalInstance);
+              var _getData = getData(internalInstance),
+                displayName = _getData.displayName,
+                key = _getData.key;
+              var ownerID = internalInstance._currentElement != null && internalInstance._currentElement._owner != null ? getID(internalInstance._currentElement._owner) : 0;
+              var displayNameStringID = getStringID(displayName);
+              var keyStringID = getStringID(key);
+              pushOperation(TREE_OPERATION_ADD);
+              pushOperation(id);
+              pushOperation(type);
+              pushOperation(parentID);
+              pushOperation(ownerID);
+              pushOperation(displayNameStringID);
+              pushOperation(keyStringID);
+            }
+          }
+          function recordReorder(internalInstance, id, nextChildren) {
+            pushOperation(TREE_OPERATION_REORDER_CHILDREN);
+            pushOperation(id);
+            var nextChildIDs = nextChildren.map(getID);
+            pushOperation(nextChildIDs.length);
+            for (var i = 0; i < nextChildIDs.length; i++) {
+              pushOperation(nextChildIDs[i]);
+            }
+          }
+          function recordUnmount(internalInstance, id) {
+            pendingUnmountedIDs.push(id);
+            idToInternalInstanceMap.delete(id);
+          }
+          function crawlAndRecordInitialMounts(id, parentID, rootID) {
+            if (__DEBUG__) {
+              console.group('crawlAndRecordInitialMounts() id:', id);
+            }
+            var internalInstance = idToInternalInstanceMap.get(id);
+            if (internalInstance != null) {
+              internalInstanceToRootIDMap.set(internalInstance, rootID);
+              recordMount(internalInstance, id, parentID);
+              getChildren(internalInstance).forEach(function (child) {
+                return crawlAndRecordInitialMounts(getID(child), id, rootID);
+              });
+            }
+            if (__DEBUG__) {
+              console.groupEnd();
+            }
+          }
+          function flushInitialOperations() {
+            // Crawl roots though and register any nodes that mounted before we were injected.
+            var roots = renderer.Mount._instancesByReactRootID || renderer.Mount._instancesByContainerID;
+            for (var key in roots) {
+              var internalInstance = roots[key];
+              var _id2 = getID(internalInstance);
+              crawlAndRecordInitialMounts(_id2, 0, _id2);
+              flushPendingEvents(_id2);
+            }
+          }
+          var pendingOperations = [];
+          var pendingStringTable = new Map();
+          var pendingUnmountedIDs = [];
+          var pendingStringTableLength = 0;
+          var pendingUnmountedRootID = null;
+          function flushPendingEvents(rootID) {
+            if (pendingOperations.length === 0 && pendingUnmountedIDs.length === 0 && pendingUnmountedRootID === null) {
+              return;
+            }
+            var numUnmountIDs = pendingUnmountedIDs.length + (pendingUnmountedRootID === null ? 0 : 1);
+            var operations = new Array(
+            // Identify which renderer this update is coming from.
+            2 +
+            // [rendererID, rootFiberID]
+            // How big is the string table?
+            1 +
+            // [stringTableLength]
+            // Then goes the actual string table.
+            pendingStringTableLength + (
+            // All unmounts are batched in a single message.
+            // [TREE_OPERATION_REMOVE, removedIDLength, ...ids]
+            numUnmountIDs > 0 ? 2 + numUnmountIDs : 0) +
+            // Mount operations
+            pendingOperations.length); // Identify which renderer this update is coming from.
+            // This enables roots to be mapped to renderers,
+            // Which in turn enables fiber properations, states, and hooks to be inspected.
+
+            var i = 0;
+            operations[i++] = rendererID;
+            operations[i++] = rootID; // Now fill in the string table.
+            // [stringTableLength, str1Length, ...str1, str2Length, ...str2, ...]
+
+            operations[i++] = pendingStringTableLength;
+            pendingStringTable.forEach(function (value, key) {
+              operations[i++] = key.length;
+              var encodedKey = utfEncodeString(key);
+              for (var j = 0; j < encodedKey.length; j++) {
+                operations[i + j] = encodedKey[j];
+              }
+              i += key.length;
+            });
+            if (numUnmountIDs > 0) {
+              // All unmounts except roots are batched in a single message.
+              operations[i++] = TREE_OPERATION_REMOVE; // The first number is how many unmounted IDs we're gonna send.
+
+              operations[i++] = numUnmountIDs; // Fill in the unmounts
+
+              for (var j = 0; j < pendingUnmountedIDs.length; j++) {
+                operations[i++] = pendingUnmountedIDs[j];
+              } // The root ID should always be unmounted last.
+
+              if (pendingUnmountedRootID !== null) {
+                operations[i] = pendingUnmountedRootID;
+                i++;
+              }
+            } // Fill in the rest of the operations.
+
+            for (var _j = 0; _j < pendingOperations.length; _j++) {
+              operations[i + _j] = pendingOperations[_j];
+            }
+            i += pendingOperations.length;
+            if (__DEBUG__) {
+              printOperationsArray(operations);
+            } // If we've already connected to the frontend, just pass the operations through.
+
+            hook.emit('operations', operations);
+            pendingOperations.length = 0;
+            pendingUnmountedIDs = [];
+            pendingUnmountedRootID = null;
+            pendingStringTable.clear();
+            pendingStringTableLength = 0;
+          }
+          function pushOperation(op) {
+            if (false) {}
+            pendingOperations.push(op);
+          }
+          function getStringID(str) {
+            if (str === null) {
+              return 0;
+            }
+            var existingID = pendingStringTable.get(str);
+            if (existingID !== undefined) {
+              return existingID;
+            }
+            var stringID = pendingStringTable.size + 1;
+            pendingStringTable.set(str, stringID); // The string table total length needs to account
+            // both for the string length, and for the array item
+            // that contains the length itself. Hence + 1.
+
+            pendingStringTableLength += str.length + 1;
+            return stringID;
+          }
+          var currentlyInspectedElementID = null;
+          var currentlyInspectedPaths = {}; // Track the intersection of currently inspected paths,
+          // so that we can send their data along if the element is re-rendered.
+
+          function mergeInspectedPaths(path) {
+            var current = currentlyInspectedPaths;
+            path.forEach(function (key) {
+              if (!current[key]) {
+                current[key] = {};
+              }
+              current = current[key];
+            });
+          }
+          function createIsPathAllowed(key) {
+            // This function helps prevent previously-inspected paths from being dehydrated in updates.
+            // This is important to avoid a bad user experience where expanded toggles collapse on update.
+            return function isPathAllowed(path) {
+              var current = currentlyInspectedPaths[key];
+              if (!current) {
+                return false;
+              }
+              for (var i = 0; i < path.length; i++) {
+                current = current[path[i]];
+                if (!current) {
+                  return false;
+                }
+              }
+              return true;
+            };
+          } // Fast path props lookup for React Native style editor.
+
+          function getInstanceAndStyle(id) {
+            var instance = null;
+            var style = null;
+            var internalInstance = idToInternalInstanceMap.get(id);
+            if (internalInstance != null) {
+              instance = internalInstance._instance || null;
+              var element = internalInstance._currentElement;
+              if (element != null && element.props != null) {
+                style = element.props.style || null;
+              }
+            }
+            return {
+              instance: instance,
+              style: style
+            };
+          }
+          function updateSelectedElement(id) {
+            var internalInstance = idToInternalInstanceMap.get(id);
+            if (internalInstance == null) {
+              console.warn("Could not find instance with id \"".concat(id, "\""));
+              return;
+            }
+            switch (getElementType(internalInstance)) {
+              case types_ElementTypeClass:
+                global.$r = internalInstance._instance;
+                break;
+              case types_ElementTypeFunction:
+                var element = internalInstance._currentElement;
+                if (element == null) {
+                  console.warn("Could not find element with id \"".concat(id, "\""));
+                  return;
+                }
+                global.$r = {
+                  props: element.props,
+                  type: element.type
+                };
+                break;
+              default:
+                global.$r = null;
+                break;
+            }
+          }
+          function storeAsGlobal(id, path, count) {
+            var inspectedElement = inspectElementRaw(id);
+            if (inspectedElement !== null) {
+              var value = utils_getInObject(inspectedElement, path);
+              var key = "$reactTemp".concat(count);
+              window[key] = value;
+              console.log(key);
+              console.log(value);
+            }
+          }
+          function getSerializedElementValueByPath(id, path) {
+            var inspectedElement = inspectElementRaw(id);
+            if (inspectedElement !== null) {
+              var valueToCopy = utils_getInObject(inspectedElement, path);
+              return serializeToString(valueToCopy);
+            }
+          }
+          function inspectElement(requestID, id, path, forceFullData) {
+            if (forceFullData || currentlyInspectedElementID !== id) {
+              currentlyInspectedElementID = id;
+              currentlyInspectedPaths = {};
+            }
+            var inspectedElement = inspectElementRaw(id);
+            if (inspectedElement === null) {
+              return {
+                id: id,
+                responseID: requestID,
+                type: 'not-found'
+              };
+            }
+            if (path !== null) {
+              mergeInspectedPaths(path);
+            } // Any time an inspected element has an update,
+            // we should update the selected $r value as wel.
+            // Do this before dehydration (cleanForBridge).
+
+            updateSelectedElement(id);
+            inspectedElement.context = cleanForBridge(inspectedElement.context, createIsPathAllowed('context'));
+            inspectedElement.props = cleanForBridge(inspectedElement.props, createIsPathAllowed('props'));
+            inspectedElement.state = cleanForBridge(inspectedElement.state, createIsPathAllowed('state'));
+            return {
+              id: id,
+              responseID: requestID,
+              type: 'full-data',
+              value: inspectedElement
+            };
+          }
+          function inspectElementRaw(id) {
+            var internalInstance = idToInternalInstanceMap.get(id);
+            if (internalInstance == null) {
+              return null;
+            }
+            var _getData2 = getData(internalInstance),
+              key = _getData2.key;
+            var type = getElementType(internalInstance);
+            var context = null;
+            var owners = null;
+            var props = null;
+            var state = null;
+            var element = internalInstance._currentElement;
+            if (element !== null) {
+              props = element.props;
+              var owner = element._owner;
+              if (owner) {
+                owners = [];
+                while (owner != null) {
+                  owners.push({
+                    displayName: getData(owner).displayName || 'Unknown',
+                    id: getID(owner),
+                    key: element.key,
+                    type: getElementType(owner)
+                  });
+                  if (owner._currentElement) {
+                    owner = owner._currentElement._owner;
+                  }
+                }
+              }
+            }
+            var publicInstance = internalInstance._instance;
+            if (publicInstance != null) {
+              context = publicInstance.context || null;
+              state = publicInstance.state || null;
+            } // Not implemented
+
+            var errors = [];
+            var warnings = [];
+            return {
+              id: id,
+              // Does the current renderer support editable hooks and function props?
+              canEditHooks: false,
+              canEditFunctionProps: false,
+              // Does the current renderer support advanced editing interface?
+              canEditHooksAndDeletePaths: false,
+              canEditHooksAndRenamePaths: false,
+              canEditFunctionPropsDeletePaths: false,
+              canEditFunctionPropsRenamePaths: false,
+              // Toggle error boundary did not exist in legacy versions
+              canToggleError: false,
+              isErrored: false,
+              // Suspense did not exist in legacy versions
+              canToggleSuspense: false,
+              // Can view component source location.
+              canViewSource: type === types_ElementTypeClass || type === types_ElementTypeFunction,
+              source: null,
+              // Only legacy context exists in legacy versions.
+              hasLegacyContext: true,
+              type: type,
+              key: key != null ? key : null,
+              // Inspectable properties.
+              context: context,
+              hooks: null,
+              props: props,
+              state: state,
+              errors: errors,
+              warnings: warnings,
+              // List of owners
+              owners: owners,
+              rootType: null,
+              rendererPackageName: null,
+              rendererVersion: null,
+              plugins: {
+                stylex: null
+              },
+              nativeTag: null
+            };
+          }
+          function logElementToConsole(id) {
+            var result = inspectElementRaw(id);
+            if (result === null) {
+              console.warn("Could not find element with id \"".concat(id, "\""));
+              return;
+            }
+            var displayName = getDisplayNameForElementID(id);
+            var supportsGroup = typeof console.groupCollapsed === 'function';
+            if (supportsGroup) {
+              console.groupCollapsed("[Click to expand] %c<".concat(displayName || 'Component', " />"),
+              // --dom-tag-name-color is the CSS variable Chrome styles HTML elements with in the console.
+              'color: var(--dom-tag-name-color); font-weight: normal;');
+            }
+            if (result.props !== null) {
+              console.log('Props:', result.props);
+            }
+            if (result.state !== null) {
+              console.log('State:', result.state);
+            }
+            if (result.context !== null) {
+              console.log('Context:', result.context);
+            }
+            var hostInstance = findHostInstanceForInternalID(id);
+            if (hostInstance !== null) {
+              console.log('Node:', hostInstance);
+            }
+            if (window.chrome || /firefox/i.test(navigator.userAgent)) {
+              console.log('Right-click any value to save it as a global variable for further inspection.');
+            }
+            if (supportsGroup) {
+              console.groupEnd();
+            }
+          }
+          function getElementAttributeByPath(id, path) {
+            var inspectedElement = inspectElementRaw(id);
+            if (inspectedElement !== null) {
+              return utils_getInObject(inspectedElement, path);
+            }
+            return undefined;
+          }
+          function getElementSourceFunctionById(id) {
+            var internalInstance = idToInternalInstanceMap.get(id);
+            if (internalInstance == null) {
+              console.warn("Could not find instance with id \"".concat(id, "\""));
+              return null;
+            }
+            var element = internalInstance._currentElement;
+            if (element == null) {
+              console.warn("Could not find element with id \"".concat(id, "\""));
+              return null;
+            }
+            return element.type;
+          }
+          function deletePath(type, id, hookID, path) {
+            var internalInstance = idToInternalInstanceMap.get(id);
+            if (internalInstance != null) {
+              var publicInstance = internalInstance._instance;
+              if (publicInstance != null) {
+                switch (type) {
+                  case 'context':
+                    deletePathInObject(publicInstance.context, path);
+                    forceUpdate(publicInstance);
+                    break;
+                  case 'hooks':
+                    throw new Error('Hooks not supported by this renderer');
+                  case 'props':
+                    var element = internalInstance._currentElement;
+                    internalInstance._currentElement = legacy_renderer_objectSpread(legacy_renderer_objectSpread({}, element), {}, {
+                      props: copyWithDelete(element.props, path)
+                    });
+                    forceUpdate(publicInstance);
+                    break;
+                  case 'state':
+                    deletePathInObject(publicInstance.state, path);
+                    forceUpdate(publicInstance);
+                    break;
+                }
+              }
+            }
+          }
+          function renamePath(type, id, hookID, oldPath, newPath) {
+            var internalInstance = idToInternalInstanceMap.get(id);
+            if (internalInstance != null) {
+              var publicInstance = internalInstance._instance;
+              if (publicInstance != null) {
+                switch (type) {
+                  case 'context':
+                    renamePathInObject(publicInstance.context, oldPath, newPath);
+                    forceUpdate(publicInstance);
+                    break;
+                  case 'hooks':
+                    throw new Error('Hooks not supported by this renderer');
+                  case 'props':
+                    var element = internalInstance._currentElement;
+                    internalInstance._currentElement = legacy_renderer_objectSpread(legacy_renderer_objectSpread({}, element), {}, {
+                      props: copyWithRename(element.props, oldPath, newPath)
+                    });
+                    forceUpdate(publicInstance);
+                    break;
+                  case 'state':
+                    renamePathInObject(publicInstance.state, oldPath, newPath);
+                    forceUpdate(publicInstance);
+                    break;
+                }
+              }
+            }
+          }
+          function overrideValueAtPath(type, id, hookID, path, value) {
+            var internalInstance = idToInternalInstanceMap.get(id);
+            if (internalInstance != null) {
+              var publicInstance = internalInstance._instance;
+              if (publicInstance != null) {
+                switch (type) {
+                  case 'context':
+                    utils_setInObject(publicInstance.context, path, value);
+                    forceUpdate(publicInstance);
+                    break;
+                  case 'hooks':
+                    throw new Error('Hooks not supported by this renderer');
+                  case 'props':
+                    var element = internalInstance._currentElement;
+                    internalInstance._currentElement = legacy_renderer_objectSpread(legacy_renderer_objectSpread({}, element), {}, {
+                      props: copyWithSet(element.props, path, value)
+                    });
+                    forceUpdate(publicInstance);
+                    break;
+                  case 'state':
+                    utils_setInObject(publicInstance.state, path, value);
+                    forceUpdate(publicInstance);
+                    break;
+                }
+              }
+            }
+          } // v16+ only features
+
+          var getProfilingData = function getProfilingData() {
+            throw new Error('getProfilingData not supported by this renderer');
+          };
+          var handleCommitFiberRoot = function handleCommitFiberRoot() {
+            throw new Error('handleCommitFiberRoot not supported by this renderer');
+          };
+          var handleCommitFiberUnmount = function handleCommitFiberUnmount() {
+            throw new Error('handleCommitFiberUnmount not supported by this renderer');
+          };
+          var handlePostCommitFiberRoot = function handlePostCommitFiberRoot() {
+            throw new Error('handlePostCommitFiberRoot not supported by this renderer');
+          };
+          var overrideError = function overrideError() {
+            throw new Error('overrideError not supported by this renderer');
+          };
+          var overrideSuspense = function overrideSuspense() {
+            throw new Error('overrideSuspense not supported by this renderer');
+          };
+          var startProfiling = function startProfiling() {// Do not throw, since this would break a multi-root scenario where v15 and v16 were both present.
+          };
+          var stopProfiling = function stopProfiling() {// Do not throw, since this would break a multi-root scenario where v15 and v16 were both present.
+          };
+          function getBestMatchForTrackedPath() {
+            // Not implemented.
+            return null;
+          }
+          function getPathForElement(id) {
+            // Not implemented.
+            return null;
+          }
+          function updateComponentFilters(componentFilters) {// Not implemented.
+          }
+          function getEnvironmentNames() {
+            // No RSC support.
+            return [];
+          }
+          function setTraceUpdatesEnabled(enabled) {// Not implemented.
+          }
+          function setTrackedPath(path) {// Not implemented.
+          }
+          function getOwnersList(id) {
+            // Not implemented.
+            return null;
+          }
+          function clearErrorsAndWarnings() {// Not implemented
+          }
+          function clearErrorsForElementID(id) {// Not implemented
+          }
+          function clearWarningsForElementID(id) {// Not implemented
+          }
+          function hasElementWithId(id) {
+            return idToInternalInstanceMap.has(id);
+          }
+          return {
+            clearErrorsAndWarnings: clearErrorsAndWarnings,
+            clearErrorsForElementID: clearErrorsForElementID,
+            clearWarningsForElementID: clearWarningsForElementID,
+            cleanup: cleanup,
+            getSerializedElementValueByPath: getSerializedElementValueByPath,
+            deletePath: deletePath,
+            flushInitialOperations: flushInitialOperations,
+            getBestMatchForTrackedPath: getBestMatchForTrackedPath,
+            getDisplayNameForElementID: getDisplayNameForElementID,
+            getNearestMountedDOMNode: getNearestMountedDOMNode,
+            getElementIDForHostInstance: getElementIDForHostInstance,
+            getInstanceAndStyle: getInstanceAndStyle,
+            findHostInstancesForElementID: function findHostInstancesForElementID(id) {
+              var hostInstance = findHostInstanceForInternalID(id);
+              return hostInstance == null ? null : [hostInstance];
+            },
+            getOwnersList: getOwnersList,
+            getPathForElement: getPathForElement,
+            getProfilingData: getProfilingData,
+            handleCommitFiberRoot: handleCommitFiberRoot,
+            handleCommitFiberUnmount: handleCommitFiberUnmount,
+            handlePostCommitFiberRoot: handlePostCommitFiberRoot,
+            hasElementWithId: hasElementWithId,
+            inspectElement: inspectElement,
+            logElementToConsole: logElementToConsole,
+            overrideError: overrideError,
+            overrideSuspense: overrideSuspense,
+            overrideValueAtPath: overrideValueAtPath,
+            renamePath: renamePath,
+            getElementAttributeByPath: getElementAttributeByPath,
+            getElementSourceFunctionById: getElementSourceFunctionById,
+            renderer: renderer,
+            setTraceUpdatesEnabled: setTraceUpdatesEnabled,
+            setTrackedPath: setTrackedPath,
+            startProfiling: startProfiling,
+            stopProfiling: stopProfiling,
+            storeAsGlobal: storeAsGlobal,
+            updateComponentFilters: updateComponentFilters,
+            getEnvironmentNames: getEnvironmentNames
+          };
+        }
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/attachRenderer.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.
+         *
+         * 
+         */
+
+        // this is the backend that is compatible with all older React versions
+
+        function isMatchingRender(version) {
+          return !hasAssignedBackend(version);
+        }
+        function attachRenderer(hook, id, renderer, global, shouldStartProfilingNow, profilingSettings) {
+          // only attach if the renderer is compatible with the current version of the backend
+          if (!isMatchingRender(renderer.reconcilerVersion || renderer.version)) {
+            return;
+          }
+          var rendererInterface = hook.rendererInterfaces.get(id); // Inject any not-yet-injected renderers (if we didn't reload-and-profile)
+
+          if (rendererInterface == null) {
+            if (typeof renderer.getCurrentComponentInfo === 'function') {
+              // react-flight/client
+              rendererInterface = attach(hook, id, renderer, global);
+            } else if (
+            // v16-19
+            typeof renderer.findFiberByHostInstance === 'function' ||
+            // v16.8+
+            renderer.currentDispatcherRef != null) {
+              // react-reconciler v16+
+              rendererInterface = renderer_attach(hook, id, renderer, global, shouldStartProfilingNow, profilingSettings);
+            } else if (renderer.ComponentTree) {
+              // react-dom v15
+              rendererInterface = legacy_renderer_attach(hook, id, renderer, global);
+            } else {// Older react-dom or other unsupported renderer version
+            }
+          }
+          return rendererInterface;
+        }
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/utils/formatConsoleArguments.js
+        function formatConsoleArguments_toConsumableArray(arr) {
+          return formatConsoleArguments_arrayWithoutHoles(arr) || formatConsoleArguments_iterableToArray(arr) || formatConsoleArguments_unsupportedIterableToArray(arr) || formatConsoleArguments_nonIterableSpread();
+        }
+        function formatConsoleArguments_nonIterableSpread() {
+          throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+        }
+        function formatConsoleArguments_iterableToArray(iter) {
+          if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
+        }
+        function formatConsoleArguments_arrayWithoutHoles(arr) {
+          if (Array.isArray(arr)) return formatConsoleArguments_arrayLikeToArray(arr);
+        }
+        function formatConsoleArguments_slicedToArray(arr, i) {
+          return formatConsoleArguments_arrayWithHoles(arr) || formatConsoleArguments_iterableToArrayLimit(arr, i) || formatConsoleArguments_unsupportedIterableToArray(arr, i) || formatConsoleArguments_nonIterableRest();
+        }
+        function formatConsoleArguments_nonIterableRest() {
+          throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+        }
+        function formatConsoleArguments_unsupportedIterableToArray(o, minLen) {
+          if (!o) return;
+          if (typeof o === "string") return formatConsoleArguments_arrayLikeToArray(o, minLen);
+          var n = Object.prototype.toString.call(o).slice(8, -1);
+          if (n === "Object" && o.constructor) n = o.constructor.name;
+          if (n === "Map" || n === "Set") return Array.from(o);
+          if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return formatConsoleArguments_arrayLikeToArray(o, minLen);
+        }
+        function formatConsoleArguments_arrayLikeToArray(arr, len) {
+          if (len == null || len > arr.length) len = arr.length;
+          for (var i = 0, arr2 = new Array(len); i < len; i++) {
+            arr2[i] = arr[i];
+          }
+          return arr2;
+        }
+        function formatConsoleArguments_iterableToArrayLimit(arr, i) {
+          if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
+          var _arr = [];
+          var _n = true;
+          var _d = false;
+          var _e = undefined;
+          try {
+            for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+              _arr.push(_s.value);
+              if (i && _arr.length === i) break;
+            }
+          } catch (err) {
+            _d = true;
+            _e = err;
+          } finally {
+            try {
+              if (!_n && _i["return"] != null) _i["return"]();
+            } finally {
+              if (_d) throw _e;
+            }
+          }
+          return _arr;
+        }
+        function formatConsoleArguments_arrayWithHoles(arr) {
+          if (Array.isArray(arr)) return arr;
+        }
+
+        /**
+         * 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.
+         *
+         * 
+         */
+        // Do not add / import anything to this file.
+        // This function could be used from multiple places, including hook.
+        // Skips CSS and object arguments, inlines other in the first argument as a template string
+        function formatConsoleArguments(maybeMessage) {
+          for (var _len = arguments.length, inputArgs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+            inputArgs[_key - 1] = arguments[_key];
+          }
+          if (inputArgs.length === 0 || typeof maybeMessage !== 'string') {
+            return [maybeMessage].concat(inputArgs);
+          }
+          var args = inputArgs.slice();
+          var template = '';
+          var argumentsPointer = 0;
+          for (var i = 0; i < maybeMessage.length; ++i) {
+            var currentChar = maybeMessage[i];
+            if (currentChar !== '%') {
+              template += currentChar;
+              continue;
+            }
+            var nextChar = maybeMessage[i + 1];
+            ++i; // Only keep CSS and objects, inline other arguments
+
+            switch (nextChar) {
+              case 'c':
+              case 'O':
+              case 'o':
+                {
+                  ++argumentsPointer;
+                  template += "%".concat(nextChar);
+                  break;
+                }
+              case 'd':
+              case 'i':
+                {
+                  var _args$splice = args.splice(argumentsPointer, 1),
+                    _args$splice2 = formatConsoleArguments_slicedToArray(_args$splice, 1),
+                    arg = _args$splice2[0];
+                  template += parseInt(arg, 10).toString();
+                  break;
+                }
+              case 'f':
+                {
+                  var _args$splice3 = args.splice(argumentsPointer, 1),
+                    _args$splice4 = formatConsoleArguments_slicedToArray(_args$splice3, 1),
+                    _arg = _args$splice4[0];
+                  template += parseFloat(_arg).toString();
+                  break;
+                }
+              case 's':
+                {
+                  var _args$splice5 = args.splice(argumentsPointer, 1),
+                    _args$splice6 = formatConsoleArguments_slicedToArray(_args$splice5, 1),
+                    _arg2 = _args$splice6[0];
+                  template += String(_arg2);
+                  break;
+                }
+              default:
+                template += "%".concat(nextChar);
+            }
+          }
+          return [template].concat(formatConsoleArguments_toConsumableArray(args));
+        }
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/hook.js
+        function hook_createForOfIteratorHelper(o, allowArrayLike) {
+          var it;
+          if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
+            if (Array.isArray(o) || (it = hook_unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+              if (it) o = it;
+              var i = 0;
+              var F = function F() {};
+              return {
+                s: F,
+                n: function n() {
+                  if (i >= o.length) return {
+                    done: true
+                  };
+                  return {
+                    done: false,
+                    value: o[i++]
+                  };
+                },
+                e: function e(_e) {
+                  throw _e;
+                },
+                f: F
+              };
+            }
+            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 normalCompletion = true,
+            didErr = false,
+            err;
+          return {
+            s: function s() {
+              it = o[Symbol.iterator]();
+            },
+            n: function n() {
+              var step = it.next();
+              normalCompletion = step.done;
+              return step;
+            },
+            e: function e(_e2) {
+              didErr = true;
+              err = _e2;
+            },
+            f: function f() {
+              try {
+                if (!normalCompletion && it.return != null) it.return();
+              } finally {
+                if (didErr) throw err;
+              }
+            }
+          };
+        }
+        function hook_toConsumableArray(arr) {
+          return hook_arrayWithoutHoles(arr) || hook_iterableToArray(arr) || hook_unsupportedIterableToArray(arr) || hook_nonIterableSpread();
+        }
+        function hook_nonIterableSpread() {
+          throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+        }
+        function hook_unsupportedIterableToArray(o, minLen) {
+          if (!o) return;
+          if (typeof o === "string") return hook_arrayLikeToArray(o, minLen);
+          var n = Object.prototype.toString.call(o).slice(8, -1);
+          if (n === "Object" && o.constructor) n = o.constructor.name;
+          if (n === "Map" || n === "Set") return Array.from(o);
+          if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return hook_arrayLikeToArray(o, minLen);
+        }
+        function hook_iterableToArray(iter) {
+          if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
+        }
+        function hook_arrayWithoutHoles(arr) {
+          if (Array.isArray(arr)) return hook_arrayLikeToArray(arr);
+        }
+        function hook_arrayLikeToArray(arr, len) {
+          if (len == null || len > arr.length) len = arr.length;
+          for (var i = 0, arr2 = new Array(len); i < len; i++) {
+            arr2[i] = arr[i];
+          }
+          return arr2;
+        }
+
+        /**
+         * Install the hook on window, which is an event emitter.
+         * Note: this global hook __REACT_DEVTOOLS_GLOBAL_HOOK__ is a de facto public API.
+         * It's especially important to avoid creating direct dependency on the DevTools Backend.
+         * That's why we still inline the whole event emitter implementation,
+         * the string format implementation, and part of the console implementation here.
+         *
+         * 
+         */
+
+        // React's custom built component stack strings match "\s{4}in"
+        // Chrome's prefix matches "\s{4}at"
+
+        var PREFIX_REGEX = /\s{4}(in|at)\s{1}/; // Firefox and Safari have no prefix ("")
+        // but we can fallback to looking for location info (e.g. "foo.js:12:345")
+
+        var ROW_COLUMN_NUMBER_REGEX = /:\d+:\d+(\n|$)/;
+        function isStringComponentStack(text) {
+          return PREFIX_REGEX.test(text) || ROW_COLUMN_NUMBER_REGEX.test(text);
+        } // We add a suffix to some frames that older versions of React didn't do.
+        // To compare if it's equivalent we strip out the suffix to see if they're
+        // still equivalent. Similarly, we sometimes use [] and sometimes () so we
+        // strip them to for the comparison.
+
+        var frameDiffs = / \(\<anonymous\>\)$|\@unknown\:0\:0$|\(|\)|\[|\]/gm;
+        function areStackTracesEqual(a, b) {
+          return a.replace(frameDiffs, '') === b.replace(frameDiffs, '');
+        }
+        var targetConsole = console;
+        var defaultProfilingSettings = {
+          recordChangeDescriptions: false,
+          recordTimeline: false
+        };
+        function installHook(target, maybeSettingsOrSettingsPromise) {
+          var shouldStartProfilingNow = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+          var profilingSettings = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : defaultProfilingSettings;
+          if (target.hasOwnProperty('__REACT_DEVTOOLS_GLOBAL_HOOK__')) {
+            return null;
+          }
+          function detectReactBuildType(renderer) {
+            try {
+              if (typeof renderer.version === 'string') {
+                // React DOM Fiber (16+)
+                if (renderer.bundleType > 0) {
+                  // This is not a production build.
+                  // We are currently only using 0 (PROD) and 1 (DEV)
+                  // but might add 2 (PROFILE) in the future.
+                  return 'development';
+                } // React 16 uses flat bundles. If we report the bundle as production
+                // version, it means we also minified and envified it ourselves.
+
+                return 'production'; // Note: There is still a risk that the CommonJS entry point has not
+                // been envified or uglified. In this case the user would have *both*
+                // development and production bundle, but only the prod one would run.
+                // This would be really bad. We have a separate check for this because
+                // it happens *outside* of the renderer injection. See `checkDCE` below.
+              } // $FlowFixMe[method-unbinding]
+
+              var _toString = Function.prototype.toString;
+              if (renderer.Mount && renderer.Mount._renderNewRootComponent) {
+                // React DOM Stack
+                var renderRootCode = _toString.call(renderer.Mount._renderNewRootComponent); // Filter out bad results (if that is even possible):
+
+                if (renderRootCode.indexOf('function') !== 0) {
+                  // Hope for the best if we're not sure.
+                  return 'production';
+                } // Check for React DOM Stack < 15.1.0 in development.
+                // If it contains "storedMeasure" call, it's wrapped in ReactPerf (DEV only).
+                // This would be true even if it's minified, as method name still matches.
+
+                if (renderRootCode.indexOf('storedMeasure') !== -1) {
+                  return 'development';
+                } // For other versions (and configurations) it's not so easy.
+                // Let's quickly exclude proper production builds.
+                // If it contains a warning message, it's either a DEV build,
+                // or an PROD build without proper dead code elimination.
+
+                if (renderRootCode.indexOf('should be a pure function') !== -1) {
+                  // Now how do we tell a DEV build from a bad PROD build?
+                  // If we see NODE_ENV, we're going to assume this is a dev build
+                  // because most likely it is referring to an empty shim.
+                  if (renderRootCode.indexOf('NODE_ENV') !== -1) {
+                    return 'development';
+                  } // If we see "development", we're dealing with an envified DEV build
+                  // (such as the official React DEV UMD).
+
+                  if (renderRootCode.indexOf('development') !== -1) {
+                    return 'development';
+                  } // I've seen process.env.NODE_ENV !== 'production' being smartly
+                  // replaced by `true` in DEV by Webpack. I don't know how that
+                  // works but we can safely guard against it because `true` was
+                  // never used in the function source since it was written.
+
+                  if (renderRootCode.indexOf('true') !== -1) {
+                    return 'development';
+                  } // By now either it is a production build that has not been minified,
+                  // or (worse) this is a minified development build using non-standard
+                  // environment (e.g. "staging"). We're going to look at whether
+                  // the function argument name is mangled:
+
+                  if (
+                  // 0.13 to 15
+                  renderRootCode.indexOf('nextElement') !== -1 ||
+                  // 0.12
+                  renderRootCode.indexOf('nextComponent') !== -1) {
+                    // We can't be certain whether this is a development build or not,
+                    // but it is definitely unminified.
+                    return 'unminified';
+                  } else {
+                    // This is likely a minified development build.
+                    return 'development';
+                  }
+                } // By now we know that it's envified and dead code elimination worked,
+                // but what if it's still not minified? (Is this even possible?)
+                // Let's check matches for the first argument name.
+
+                if (
+                // 0.13 to 15
+                renderRootCode.indexOf('nextElement') !== -1 ||
+                // 0.12
+                renderRootCode.indexOf('nextComponent') !== -1) {
+                  return 'unminified';
+                } // Seems like we're using the production version.
+                // However, the branch above is Stack-only so this is 15 or earlier.
+
+                return 'outdated';
+              }
+            } catch (err) {// Weird environments may exist.
+              // This code needs a higher fault tolerance
+              // because it runs even with closed DevTools.
+              // TODO: should we catch errors in all injected code, and not just this part?
+            }
+            return 'production';
+          }
+          function checkDCE(fn) {
+            // This runs for production versions of React.
+            // Needs to be super safe.
+            try {
+              // $FlowFixMe[method-unbinding]
+              var _toString2 = Function.prototype.toString;
+              var code = _toString2.call(fn); // This is a string embedded in the passed function under DEV-only
+              // condition. However the function executes only in PROD. Therefore,
+              // if we see it, dead code elimination did not work.
+
+              if (code.indexOf('^_^') > -1) {
+                // Remember to report during next injection.
+                hasDetectedBadDCE = true; // Bonus: throw an exception hoping that it gets picked up by a reporting system.
+                // Not synchronously so that it doesn't break the calling code.
+
+                setTimeout(function () {
+                  throw new Error('React is running in production mode, but dead code ' + 'elimination has not been applied. Read how to correctly ' + 'configure React for production: ' + 'https://react.dev/link/perf-use-production-build');
+                });
+              }
+            } catch (err) {}
+          } // TODO: isProfiling should be stateful, and we should update it once profiling is finished
+
+          var isProfiling = shouldStartProfilingNow;
+          var uidCounter = 0;
+          function inject(renderer) {
+            var id = ++uidCounter;
+            renderers.set(id, renderer);
+            var reactBuildType = hasDetectedBadDCE ? 'deadcode' : detectReactBuildType(renderer);
+            hook.emit('renderer', {
+              id: id,
+              renderer: renderer,
+              reactBuildType: reactBuildType
+            });
+            var rendererInterface = attachRenderer(hook, id, renderer, target, isProfiling, profilingSettings);
+            if (rendererInterface != null) {
+              hook.rendererInterfaces.set(id, rendererInterface);
+              hook.emit('renderer-attached', {
+                id: id,
+                rendererInterface: rendererInterface
+              });
+            } else {
+              hook.hasUnsupportedRendererAttached = true;
+              hook.emit('unsupported-renderer-version');
+            }
+            return id;
+          }
+          var hasDetectedBadDCE = false;
+          function sub(event, fn) {
+            hook.on(event, fn);
+            return function () {
+              return hook.off(event, fn);
+            };
+          }
+          function on(event, fn) {
+            if (!listeners[event]) {
+              listeners[event] = [];
+            }
+            listeners[event].push(fn);
+          }
+          function off(event, fn) {
+            if (!listeners[event]) {
+              return;
+            }
+            var index = listeners[event].indexOf(fn);
+            if (index !== -1) {
+              listeners[event].splice(index, 1);
+            }
+            if (!listeners[event].length) {
+              delete listeners[event];
+            }
+          }
+          function emit(event, data) {
+            if (listeners[event]) {
+              listeners[event].map(function (fn) {
+                return fn(data);
+              });
+            }
+          }
+          function getFiberRoots(rendererID) {
+            var roots = fiberRoots;
+            if (!roots[rendererID]) {
+              roots[rendererID] = new Set();
+            }
+            return roots[rendererID];
+          }
+          function onCommitFiberUnmount(rendererID, fiber) {
+            var rendererInterface = rendererInterfaces.get(rendererID);
+            if (rendererInterface != null) {
+              rendererInterface.handleCommitFiberUnmount(fiber);
+            }
+          }
+          function onCommitFiberRoot(rendererID, root, priorityLevel) {
+            var mountedRoots = hook.getFiberRoots(rendererID);
+            var current = root.current;
+            var isKnownRoot = mountedRoots.has(root);
+            var isUnmounting = current.memoizedState == null || current.memoizedState.element == null; // Keep track of mounted roots so we can hydrate when DevTools connect.
+
+            if (!isKnownRoot && !isUnmounting) {
+              mountedRoots.add(root);
+            } else if (isKnownRoot && isUnmounting) {
+              mountedRoots.delete(root);
+            }
+            var rendererInterface = rendererInterfaces.get(rendererID);
+            if (rendererInterface != null) {
+              rendererInterface.handleCommitFiberRoot(root, priorityLevel);
+            }
+          }
+          function onPostCommitFiberRoot(rendererID, root) {
+            var rendererInterface = rendererInterfaces.get(rendererID);
+            if (rendererInterface != null) {
+              rendererInterface.handlePostCommitFiberRoot(root);
+            }
+          }
+          var isRunningDuringStrictModeInvocation = false;
+          function setStrictMode(rendererID, isStrictMode) {
+            isRunningDuringStrictModeInvocation = isStrictMode;
+            if (isStrictMode) {
+              patchConsoleForStrictMode();
+            } else {
+              unpatchConsoleForStrictMode();
+            }
+          }
+          var unpatchConsoleCallbacks = []; // For StrictMode we patch console once we are running in StrictMode and unpatch right after it
+          // So patching could happen multiple times during the runtime
+          // Notice how we don't patch error or warn methods, because they are already patched in patchConsoleForErrorsAndWarnings
+          // This will only happen once, when hook is installed
+
+          function patchConsoleForStrictMode() {
+            // Don't patch console in case settings were not injected
+            if (!hook.settings) {
+              return;
+            } // Don't patch twice
+
+            if (unpatchConsoleCallbacks.length > 0) {
+              return;
+            } // At this point 'error', 'warn', and 'trace' methods are already patched
+            // by React DevTools hook to append component stacks and other possible features.
+
+            var consoleMethodsToOverrideForStrictMode = ['group', 'groupCollapsed', 'info', 'log']; // eslint-disable-next-line no-for-of-loops/no-for-of-loops
+
+            var _loop = function _loop() {
+              var method = _consoleMethodsToOver[_i];
+              var originalMethod = targetConsole[method];
+              var overrideMethod = function overrideMethod() {
+                var settings = hook.settings; // Something unexpected happened, fallback to just printing the console message.
+
+                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+                  args[_key] = arguments[_key];
+                }
+                if (settings == null) {
+                  originalMethod.apply(void 0, args);
+                  return;
+                }
+                if (settings.hideConsoleLogsInStrictMode) {
+                  return;
+                } // Dim the text color of the double logs if we're not hiding them.
+                // Firefox doesn't support ANSI escape sequences
+
+                if (false) {} else {
+                  originalMethod.apply(void 0, [ANSI_STYLE_DIMMING_TEMPLATE].concat(hook_toConsumableArray(formatConsoleArguments.apply(void 0, args))));
+                }
+              };
+              targetConsole[method] = overrideMethod;
+              unpatchConsoleCallbacks.push(function () {
+                targetConsole[method] = originalMethod;
+              });
+            };
+            for (var _i = 0, _consoleMethodsToOver = consoleMethodsToOverrideForStrictMode; _i < _consoleMethodsToOver.length; _i++) {
+              _loop();
+            }
+          }
+          function unpatchConsoleForStrictMode() {
+            unpatchConsoleCallbacks.forEach(function (callback) {
+              return callback();
+            });
+            unpatchConsoleCallbacks.length = 0;
+          }
+          var openModuleRangesStack = [];
+          var moduleRanges = [];
+          function getTopStackFrameString(error) {
+            var frames = error.stack.split('\n');
+            var frame = frames.length > 1 ? frames[1] : null;
+            return frame;
+          }
+          function getInternalModuleRanges() {
+            return moduleRanges;
+          }
+          function registerInternalModuleStart(error) {
+            var startStackFrame = getTopStackFrameString(error);
+            if (startStackFrame !== null) {
+              openModuleRangesStack.push(startStackFrame);
+            }
+          }
+          function registerInternalModuleStop(error) {
+            if (openModuleRangesStack.length > 0) {
+              var startStackFrame = openModuleRangesStack.pop();
+              var stopStackFrame = getTopStackFrameString(error);
+              if (stopStackFrame !== null) {
+                // $FlowFixMe[incompatible-call]
+                moduleRanges.push([startStackFrame, stopStackFrame]);
+              }
+            }
+          } // For Errors and Warnings we only patch console once
+
+          function patchConsoleForErrorsAndWarnings() {
+            // Don't patch console in case settings were not injected
+            if (!hook.settings) {
+              return;
+            }
+            var consoleMethodsToOverrideForErrorsAndWarnings = ['error', 'trace', 'warn']; // eslint-disable-next-line no-for-of-loops/no-for-of-loops
+
+            var _loop2 = function _loop2() {
+              var method = _consoleMethodsToOver2[_i2];
+              var originalMethod = targetConsole[method];
+              var overrideMethod = function overrideMethod() {
+                var settings = hook.settings; // Something unexpected happened, fallback to just printing the console message.
+
+                for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+                  args[_key2] = arguments[_key2];
+                }
+                if (settings == null) {
+                  originalMethod.apply(void 0, args);
+                  return;
+                }
+                if (isRunningDuringStrictModeInvocation && settings.hideConsoleLogsInStrictMode) {
+                  return;
+                }
+                var injectedComponentStackAsFakeError = false;
+                var alreadyHasComponentStack = false;
+                if (settings.appendComponentStack) {
+                  var lastArg = args.length > 0 ? args[args.length - 1] : null;
+                  alreadyHasComponentStack = typeof lastArg === 'string' && isStringComponentStack(lastArg); // The last argument should be a component stack.
+                }
+                var shouldShowInlineWarningsAndErrors = settings.showInlineWarningsAndErrors && (method === 'error' || method === 'warn'); // Search for the first renderer that has a current Fiber.
+                // We don't handle the edge case of stacks for more than one (e.g. interleaved renderers?)
+                // eslint-disable-next-line no-for-of-loops/no-for-of-loops
+
+                var _iterator = hook_createForOfIteratorHelper(hook.rendererInterfaces.values()),
+                  _step;
+                try {
+                  var _loop3 = function _loop3() {
+                      rendererInterface = _step.value;
+                      onErrorOrWarning = rendererInterface.onErrorOrWarning, getComponentStack = rendererInterface.getComponentStack;
+                      try {
+                        if (shouldShowInlineWarningsAndErrors) {
+                          // patch() is called by two places: (1) the hook and (2) the renderer backend.
+                          // The backend is what implements a message queue, so it's the only one that injects onErrorOrWarning.
+                          if (onErrorOrWarning != null) {
+                            onErrorOrWarning(method, args.slice());
+                          }
+                        }
+                      } catch (error) {
+                        // Don't let a DevTools or React internal error interfere with logging.
+                        setTimeout(function () {
+                          throw error;
+                        }, 0);
+                      }
+                      try {
+                        if (settings.appendComponentStack && getComponentStack != null) {
+                          // This needs to be directly in the wrapper so we can pop exactly one frame.
+                          topFrame = Error('react-stack-top-frame');
+                          match = getComponentStack(topFrame);
+                          if (match !== null) {
+                            enableOwnerStacks = match.enableOwnerStacks, componentStack = match.componentStack; // Empty string means we have a match but no component stack.
+                            // We don't need to look in other renderers but we also don't add anything.
+                            if (componentStack !== '') {
+                              // Create a fake Error so that when we print it we get native source maps. Every
+                              // browser will print the .stack property of the error and then parse it back for source
+                              // mapping. Rather than print the internal slot. So it doesn't matter that the internal
+                              // slot doesn't line up.
+                              fakeError = new Error(''); // In Chromium, only the stack property is printed but in Firefox the <name>:<message>
+                              // gets printed so to make the colon make sense, we name it so we print Stack:
+                              // and similarly Safari leave an expandable slot.
+                              if (false) {} else {
+                                fakeError.name = enableOwnerStacks ? 'Stack' : 'Component Stack'; // This gets printed
+                              } // In Chromium, the stack property needs to start with ^[\w.]*Error\b to trigger stack
+                              // formatting. Otherwise it is left alone. So we prefix it. Otherwise we just override it
+                              // to our own stack.
+
+                              fakeError.stack = true ? (enableOwnerStacks ? 'Error Stack:' : 'Error Component Stack:') + componentStack : 0;
+                              if (alreadyHasComponentStack) {
+                                // Only modify the component stack if it matches what we would've added anyway.
+                                // Otherwise we assume it was a non-React stack.
+                                if (areStackTracesEqual(args[args.length - 1], componentStack)) {
+                                  firstArg = args[0];
+                                  if (args.length > 1 && typeof firstArg === 'string' && firstArg.endsWith('%s')) {
+                                    args[0] = firstArg.slice(0, firstArg.length - 2); // Strip the %s param
+                                  }
+                                  args[args.length - 1] = fakeError;
+                                  injectedComponentStackAsFakeError = true;
+                                }
+                              } else {
+                                args.push(fakeError);
+                                injectedComponentStackAsFakeError = true;
+                              }
+                            } // Don't add stacks from other renderers.
+                            return 1; // break
+                          }
+                        }
+                      } catch (error) {
+                        // Don't let a DevTools or React internal error interfere with logging.
+                        setTimeout(function () {
+                          throw error;
+                        }, 0);
+                      }
+                    },
+                    rendererInterface,
+                    onErrorOrWarning,
+                    getComponentStack,
+                    topFrame,
+                    match,
+                    enableOwnerStacks,
+                    componentStack,
+                    fakeError,
+                    firstArg;
+                  for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                    if (_loop3()) break;
+                  }
+                } catch (err) {
+                  _iterator.e(err);
+                } finally {
+                  _iterator.f();
+                }
+                if (settings.breakOnConsoleErrors) {
+                  // --- Welcome to debugging with React DevTools ---
+                  // This debugger statement means that you've enabled the "break on warnings" feature.
+                  // Use the browser's Call Stack panel to step out of this override function
+                  // to where the original warning or error was logged.
+                  // eslint-disable-next-line no-debugger
+                  debugger;
+                }
+                if (isRunningDuringStrictModeInvocation) {
+                  // Dim the text color of the double logs if we're not hiding them.
+                  // Firefox doesn't support ANSI escape sequences
+                  if (false) {
+                    var argsWithCSSStyles;
+                  } else {
+                    originalMethod.apply(void 0, [injectedComponentStackAsFakeError ? ANSI_STYLE_DIMMING_TEMPLATE_WITH_COMPONENT_STACK : ANSI_STYLE_DIMMING_TEMPLATE].concat(hook_toConsumableArray(formatConsoleArguments.apply(void 0, args))));
+                  }
+                } else {
+                  originalMethod.apply(void 0, args);
+                }
+              };
+              targetConsole[method] = overrideMethod;
+            };
+            for (var _i2 = 0, _consoleMethodsToOver2 = consoleMethodsToOverrideForErrorsAndWarnings; _i2 < _consoleMethodsToOver2.length; _i2++) {
+              _loop2();
+            }
+          } // TODO: More meaningful names for "rendererInterfaces" and "renderers".
+
+          var fiberRoots = {};
+          var rendererInterfaces = new Map();
+          var listeners = {};
+          var renderers = new Map();
+          var backends = new Map();
+          var hook = {
+            rendererInterfaces: rendererInterfaces,
+            listeners: listeners,
+            backends: backends,
+            // Fast Refresh for web relies on this.
+            renderers: renderers,
+            hasUnsupportedRendererAttached: false,
+            emit: emit,
+            getFiberRoots: getFiberRoots,
+            inject: inject,
+            on: on,
+            off: off,
+            sub: sub,
+            // This is a legacy flag.
+            // React v16 checks the hook for this to ensure DevTools is new enough.
+            supportsFiber: true,
+            // React Flight Client checks the hook for this to ensure DevTools is new enough.
+            supportsFlight: true,
+            // React calls these methods.
+            checkDCE: checkDCE,
+            onCommitFiberUnmount: onCommitFiberUnmount,
+            onCommitFiberRoot: onCommitFiberRoot,
+            // React v18.0+
+            onPostCommitFiberRoot: onPostCommitFiberRoot,
+            setStrictMode: setStrictMode,
+            // Schedule Profiler runtime helpers.
+            // These internal React modules to report their own boundaries
+            // which in turn enables the profiler to dim or filter internal frames.
+            getInternalModuleRanges: getInternalModuleRanges,
+            registerInternalModuleStart: registerInternalModuleStart,
+            registerInternalModuleStop: registerInternalModuleStop
+          };
+          if (maybeSettingsOrSettingsPromise == null) {
+            // Set default settings
+            hook.settings = {
+              appendComponentStack: true,
+              breakOnConsoleErrors: false,
+              showInlineWarningsAndErrors: true,
+              hideConsoleLogsInStrictMode: false
+            };
+            patchConsoleForErrorsAndWarnings();
+          } else {
+            Promise.resolve(maybeSettingsOrSettingsPromise).then(function (settings) {
+              hook.settings = settings;
+              hook.emit('settingsInitialized', settings);
+              patchConsoleForErrorsAndWarnings();
+            }).catch(function () {
+              targetConsole.error("React DevTools failed to get Console Patching settings. Console won't be patched and some console features will not work.");
+            });
+          }
+          Object.defineProperty(target, '__REACT_DEVTOOLS_GLOBAL_HOOK__', {
+            // This property needs to be configurable for the test environment,
+            // else we won't be able to delete and recreate it between tests.
+            configurable: false,
+            enumerable: false,
+            get: function get() {
+              return hook;
+            }
+          });
+          return hook;
+        }
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/index.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.
+         *
+         * 
+         */
+
+        function initBackend(hook, agent, global, isReloadAndProfileSupported) {
+          if (hook == null) {
+            // DevTools didn't get injected into this page (maybe b'c of the contentType).
+            return function () {};
+          }
+          function registerRendererInterface(id, rendererInterface) {
+            agent.registerRendererInterface(id, rendererInterface); // Now that the Store and the renderer interface are connected,
+            // it's time to flush the pending operation codes to the frontend.
+
+            rendererInterface.flushInitialOperations();
+          }
+          var subs = [hook.sub('renderer-attached', function (_ref) {
+            var id = _ref.id,
+              rendererInterface = _ref.rendererInterface;
+            registerRendererInterface(id, rendererInterface);
+          }), hook.sub('unsupported-renderer-version', function () {
+            agent.onUnsupportedRenderer();
+          }), hook.sub('fastRefreshScheduled', agent.onFastRefreshScheduled), hook.sub('operations', agent.onHookOperations), hook.sub('traceUpdates', agent.onTraceUpdates), hook.sub('settingsInitialized', agent.onHookSettings) // TODO Add additional subscriptions required for profiling mode
+          ];
+          agent.addListener('getIfHasUnsupportedRendererVersion', function () {
+            if (hook.hasUnsupportedRendererAttached) {
+              agent.onUnsupportedRenderer();
+            }
+          });
+          hook.rendererInterfaces.forEach(function (rendererInterface, id) {
+            registerRendererInterface(id, rendererInterface);
+          });
+          hook.emit('react-devtools', agent);
+          hook.reactDevtoolsAgent = agent;
+          var onAgentShutdown = function onAgentShutdown() {
+            subs.forEach(function (fn) {
+              return fn();
+            });
+            hook.rendererInterfaces.forEach(function (rendererInterface) {
+              rendererInterface.cleanup();
+            });
+            hook.reactDevtoolsAgent = null;
+          }; // Agent's event listeners are cleaned up by Agent in `shutdown` implementation.
+
+          agent.addListener('shutdown', onAgentShutdown);
+          agent.addListener('updateHookSettings', function (settings) {
+            hook.settings = settings;
+          });
+          agent.addListener('getHookSettings', function () {
+            if (hook.settings != null) {
+              agent.onHookSettings(hook.settings);
+            }
+          });
+          if (isReloadAndProfileSupported) {
+            agent.onReloadAndProfileSupportedByHost();
+          }
+          return function () {
+            subs.forEach(function (fn) {
+              return fn();
+            });
+          };
+        }
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/NativeStyleEditor/resolveBoxStyle.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.
+         *
+         * 
+         */
+
+        /**
+         * This mirrors react-native/Libraries/Inspector/resolveBoxStyle.js (but without RTL support).
+         *
+         * Resolve a style property into it's component parts, e.g.
+         *
+         * resolveBoxStyle('margin', {margin: 5, marginBottom: 10})
+         * -> {top: 5, left: 5, right: 5, bottom: 10}
+         */
+        function resolveBoxStyle(prefix, style) {
+          var hasParts = false;
+          var result = {
+            bottom: 0,
+            left: 0,
+            right: 0,
+            top: 0
+          };
+          var styleForAll = style[prefix];
+          if (styleForAll != null) {
+            // eslint-disable-next-line no-for-of-loops/no-for-of-loops
+            for (var _i = 0, _Object$keys = Object.keys(result); _i < _Object$keys.length; _i++) {
+              var key = _Object$keys[_i];
+              result[key] = styleForAll;
+            }
+            hasParts = true;
+          }
+          var styleForHorizontal = style[prefix + 'Horizontal'];
+          if (styleForHorizontal != null) {
+            result.left = styleForHorizontal;
+            result.right = styleForHorizontal;
+            hasParts = true;
+          } else {
+            var styleForLeft = style[prefix + 'Left'];
+            if (styleForLeft != null) {
+              result.left = styleForLeft;
+              hasParts = true;
+            }
+            var styleForRight = style[prefix + 'Right'];
+            if (styleForRight != null) {
+              result.right = styleForRight;
+              hasParts = true;
+            }
+            var styleForEnd = style[prefix + 'End'];
+            if (styleForEnd != null) {
+              // TODO RTL support
+              result.right = styleForEnd;
+              hasParts = true;
+            }
+            var styleForStart = style[prefix + 'Start'];
+            if (styleForStart != null) {
+              // TODO RTL support
+              result.left = styleForStart;
+              hasParts = true;
+            }
+          }
+          var styleForVertical = style[prefix + 'Vertical'];
+          if (styleForVertical != null) {
+            result.bottom = styleForVertical;
+            result.top = styleForVertical;
+            hasParts = true;
+          } else {
+            var styleForBottom = style[prefix + 'Bottom'];
+            if (styleForBottom != null) {
+              result.bottom = styleForBottom;
+              hasParts = true;
+            }
+            var styleForTop = style[prefix + 'Top'];
+            if (styleForTop != null) {
+              result.top = styleForTop;
+              hasParts = true;
+            }
+          }
+          return hasParts ? result : null;
+        }
+        ; // CONCATENATED MODULE: ../react-devtools-shared/src/backend/NativeStyleEditor/setupNativeStyleEditor.js
+        function setupNativeStyleEditor_typeof(obj) {
+          "@babel/helpers - typeof";
+
+          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+            setupNativeStyleEditor_typeof = function _typeof(obj) {
+              return typeof obj;
+            };
+          } else {
+            setupNativeStyleEditor_typeof = function _typeof(obj) {
+              return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+            };
+          }
+          return setupNativeStyleEditor_typeof(obj);
+        }
+        function setupNativeStyleEditor_defineProperty(obj, key, value) {
+          if (key in obj) {
+            Object.defineProperty(obj, key, {
+              value: value,
+              enumerable: true,
+              configurable: true,
+              writable: true
+            });
+          } else {
+            obj[key] = value;
+          }
+          return obj;
+        }
+
+        /**
+         * 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.
+         *
+         * 
+         */
+
+        function setupNativeStyleEditor(bridge, agent, resolveNativeStyle, validAttributes) {
+          bridge.addListener('NativeStyleEditor_measure', function (_ref) {
+            var id = _ref.id,
+              rendererID = _ref.rendererID;
+            measureStyle(agent, bridge, resolveNativeStyle, id, rendererID);
+          });
+          bridge.addListener('NativeStyleEditor_renameAttribute', function (_ref2) {
+            var id = _ref2.id,
+              rendererID = _ref2.rendererID,
+              oldName = _ref2.oldName,
+              newName = _ref2.newName,
+              value = _ref2.value;
+            renameStyle(agent, id, rendererID, oldName, newName, value);
+            setTimeout(function () {
+              return measureStyle(agent, bridge, resolveNativeStyle, id, rendererID);
+            });
+          });
+          bridge.addListener('NativeStyleEditor_setValue', function (_ref3) {
+            var id = _ref3.id,
+              rendererID = _ref3.rendererID,
+              name = _ref3.name,
+              value = _ref3.value;
+            setStyle(agent, id, rendererID, name, value);
+            setTimeout(function () {
+              return measureStyle(agent, bridge, resolveNativeStyle, id, rendererID);
+            });
+          });
+          bridge.send('isNativeStyleEditorSupported', {
+            isSupported: true,
+            validAttributes: validAttributes
+          });
+        }
+        var EMPTY_BOX_STYLE = {
+          top: 0,
+          left: 0,
+          right: 0,
+          bottom: 0
+        };
+        var componentIDToStyleOverrides = new Map();
+        function measureStyle(agent, bridge, resolveNativeStyle, id, rendererID) {
+          var data = agent.getInstanceAndStyle({
+            id: id,
+            rendererID: rendererID
+          });
+          if (!data || !data.style) {
+            bridge.send('NativeStyleEditor_styleAndLayout', {
+              id: id,
+              layout: null,
+              style: null
+            });
+            return;
+          }
+          var instance = data.instance,
+            style = data.style;
+          var resolvedStyle = resolveNativeStyle(style); // If it's a host component we edited before, amend styles.
+
+          var styleOverrides = componentIDToStyleOverrides.get(id);
+          if (styleOverrides != null) {
+            resolvedStyle = Object.assign({}, resolvedStyle, styleOverrides);
+          }
+          if (!instance || typeof instance.measure !== 'function') {
+            bridge.send('NativeStyleEditor_styleAndLayout', {
+              id: id,
+              layout: null,
+              style: resolvedStyle || null
+            });
+            return;
+          }
+          instance.measure(function (x, y, width, height, left, top) {
+            // RN Android sometimes returns undefined here. Don't send measurements in this case.
+            // https://github.com/jhen0409/react-native-debugger/issues/84#issuecomment-304611817
+            if (typeof x !== 'number') {
+              bridge.send('NativeStyleEditor_styleAndLayout', {
+                id: id,
+                layout: null,
+                style: resolvedStyle || null
+              });
+              return;
+            }
+            var margin = resolvedStyle != null && resolveBoxStyle('margin', resolvedStyle) || EMPTY_BOX_STYLE;
+            var padding = resolvedStyle != null && resolveBoxStyle('padding', resolvedStyle) || EMPTY_BOX_STYLE;
+            bridge.send('NativeStyleEditor_styleAndLayout', {
+              id: id,
+              layout: {
+                x: x,
+                y: y,
+                width: width,
+                height: height,
+                left: left,
+                top: top,
+                margin: margin,
+                padding: padding
+              },
+              style: resolvedStyle || null
+            });
+          });
+        }
+        function shallowClone(object) {
+          var cloned = {};
+          for (var n in object) {
+            cloned[n] = object[n];
+          }
+          return cloned;
+        }
+        function renameStyle(agent, id, rendererID, oldName, newName, value) {
+          var _ref4;
+          var data = agent.getInstanceAndStyle({
+            id: id,
+            rendererID: rendererID
+          });
+          if (!data || !data.style) {
+            return;
+          }
+          var instance = data.instance,
+            style = data.style;
+          var newStyle = newName ? (_ref4 = {}, setupNativeStyleEditor_defineProperty(_ref4, oldName, undefined), setupNativeStyleEditor_defineProperty(_ref4, newName, value), _ref4) : setupNativeStyleEditor_defineProperty({}, oldName, undefined);
+          var customStyle; // TODO It would be nice if the renderer interface abstracted this away somehow.
+
+          if (instance !== null && typeof instance.setNativeProps === 'function') {
+            // In the case of a host component, we need to use setNativeProps().
+            // Remember to "correct" resolved styles when we read them next time.
+            var styleOverrides = componentIDToStyleOverrides.get(id);
+            if (!styleOverrides) {
+              componentIDToStyleOverrides.set(id, newStyle);
+            } else {
+              Object.assign(styleOverrides, newStyle);
+            } // TODO Fabric does not support setNativeProps; chat with Sebastian or Eli
+
+            instance.setNativeProps({
+              style: newStyle
+            });
+          } else if (src_isArray(style)) {
+            var lastIndex = style.length - 1;
+            if (setupNativeStyleEditor_typeof(style[lastIndex]) === 'object' && !src_isArray(style[lastIndex])) {
+              customStyle = shallowClone(style[lastIndex]);
+              delete customStyle[oldName];
+              if (newName) {
+                customStyle[newName] = value;
+              } else {
+                customStyle[oldName] = undefined;
+              }
+              agent.overrideValueAtPath({
+                type: 'props',
+                id: id,
+                rendererID: rendererID,
+                path: ['style', lastIndex],
+                value: customStyle
+              });
+            } else {
+              agent.overrideValueAtPath({
+                type: 'props',
+                id: id,
+                rendererID: rendererID,
+                path: ['style'],
+                value: style.concat([newStyle])
+              });
+            }
+          } else if (setupNativeStyleEditor_typeof(style) === 'object') {
+            customStyle = shallowClone(style);
+            delete customStyle[oldName];
+            if (newName) {
+              customStyle[newName] = value;
+            } else {
+              customStyle[oldName] = undefined;
+            }
+            agent.overrideValueAtPath({
+              type: 'props',
+              id: id,
+              rendererID: rendererID,
+              path: ['style'],
+              value: customStyle
+            });
+          } else {
+            agent.overrideValueAtPath({
+              type: 'props',
+              id: id,
+              rendererID: rendererID,
+              path: ['style'],
+              value: [style, newStyle]
+            });
+          }
+          agent.emit('hideNativeHighlight');
+        }
+        function setStyle(agent, id, rendererID, name, value) {
+          var data = agent.getInstanceAndStyle({
+            id: id,
+            rendererID: rendererID
+          });
+          if (!data || !data.style) {
+            return;
+          }
+          var instance = data.instance,
+            style = data.style;
+          var newStyle = setupNativeStyleEditor_defineProperty({}, name, value); // TODO It would be nice if the renderer interface abstracted this away somehow.
+
+          if (instance !== null && typeof instance.setNativeProps === 'function') {
+            // In the case of a host component, we need to use setNativeProps().
+            // Remember to "correct" resolved styles when we read them next time.
+            var styleOverrides = componentIDToStyleOverrides.get(id);
+            if (!styleOverrides) {
+              componentIDToStyleOverrides.set(id, newStyle);
+            } else {
+              Object.assign(styleOverrides, newStyle);
+            } // TODO Fabric does not support setNativeProps; chat with Sebastian or Eli
+
+            instance.setNativeProps({
+              style: newStyle
+            });
+          } else if (src_isArray(style)) {
+            var lastLength = style.length - 1;
+            if (setupNativeStyleEditor_typeof(style[lastLength]) === 'object' && !src_isArray(style[lastLength])) {
+              agent.overrideValueAtPath({
+                type: 'props',
+                id: id,
+                rendererID: rendererID,
+                path: ['style', lastLength, name],
+                value: value
+              });
+            } else {
+              agent.overrideValueAtPath({
+                type: 'props',
+                id: id,
+                rendererID: rendererID,
+                path: ['style'],
+                value: style.concat([newStyle])
+              });
+            }
+          } else {
+            agent.overrideValueAtPath({
+              type: 'props',
+              id: id,
+              rendererID: rendererID,
+              path: ['style'],
+              value: [style, newStyle]
+            });
+          }
+          agent.emit('hideNativeHighlight');
+        }
+        ; // CONCATENATED MODULE: ./src/backend.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.
+         *
+         * 
+         */
+
+        var savedComponentFilters = getDefaultComponentFilters();
+        function backend_debug(methodName) {
+          if (__DEBUG__) {
+            var _console;
+            for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+              args[_key - 1] = arguments[_key];
+            }
+            (_console = console).log.apply(_console, ["%c[core/backend] %c".concat(methodName), 'color: teal; font-weight: bold;', 'font-weight: bold;'].concat(args));
+          }
+        }
+        function backend_initialize(maybeSettingsOrSettingsPromise) {
+          var shouldStartProfilingNow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+          var profilingSettings = arguments.length > 2 ? arguments[2] : undefined;
+          installHook(window, maybeSettingsOrSettingsPromise, shouldStartProfilingNow, profilingSettings);
+        }
+        function _connectToDevTools(options) {
+          var hook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+          if (hook == null) {
+            // DevTools didn't get injected into this page (maybe b'c of the contentType).
+            return;
+          }
+          var _ref = options || {},
+            _ref$host = _ref.host,
+            host = _ref$host === void 0 ? 'localhost' : _ref$host,
+            nativeStyleEditorValidAttributes = _ref.nativeStyleEditorValidAttributes,
+            _ref$useHttps = _ref.useHttps,
+            useHttps = _ref$useHttps === void 0 ? false : _ref$useHttps,
+            _ref$port = _ref.port,
+            port = _ref$port === void 0 ? 8097 : _ref$port,
+            websocket = _ref.websocket,
+            _ref$resolveRNStyle = _ref.resolveRNStyle,
+            resolveRNStyle = _ref$resolveRNStyle === void 0 ? null : _ref$resolveRNStyle,
+            _ref$retryConnectionD = _ref.retryConnectionDelay,
+            retryConnectionDelay = _ref$retryConnectionD === void 0 ? 2000 : _ref$retryConnectionD,
+            _ref$isAppActive = _ref.isAppActive,
+            isAppActive = _ref$isAppActive === void 0 ? function () {
+              return true;
+            } : _ref$isAppActive,
+            onSettingsUpdated = _ref.onSettingsUpdated,
+            _ref$isReloadAndProfi = _ref.isReloadAndProfileSupported,
+            isReloadAndProfileSupported = _ref$isReloadAndProfi === void 0 ? getIsReloadAndProfileSupported() : _ref$isReloadAndProfi,
+            isProfiling = _ref.isProfiling,
+            onReloadAndProfile = _ref.onReloadAndProfile,
+            onReloadAndProfileFlagsReset = _ref.onReloadAndProfileFlagsReset;
+          var protocol = useHttps ? 'wss' : 'ws';
+          var retryTimeoutID = null;
+          function scheduleRetry() {
+            if (retryTimeoutID === null) {
+              // Two seconds because RN had issues with quick retries.
+              retryTimeoutID = setTimeout(function () {
+                return _connectToDevTools(options);
+              }, retryConnectionDelay);
+            }
+          }
+          if (!isAppActive()) {
+            // If the app is in background, maybe retry later.
+            // Don't actually attempt to connect until we're in foreground.
+            scheduleRetry();
+            return;
+          }
+          var bridge = null;
+          var messageListeners = [];
+          var uri = protocol + '://' + host + ':' + port; // If existing websocket is passed, use it.
+          // This is necessary to support our custom integrations.
+          // See D6251744.
+
+          var ws = websocket ? websocket : new window.WebSocket(uri);
+          ws.onclose = handleClose;
+          ws.onerror = handleFailed;
+          ws.onmessage = handleMessage;
+          ws.onopen = function () {
+            bridge = new src_bridge({
+              listen: function listen(fn) {
+                messageListeners.push(fn);
+                return function () {
+                  var index = messageListeners.indexOf(fn);
+                  if (index >= 0) {
+                    messageListeners.splice(index, 1);
+                  }
+                };
+              },
+              send: function send(event, payload, transferable) {
+                if (ws.readyState === ws.OPEN) {
+                  if (__DEBUG__) {
+                    backend_debug('wall.send()', event, payload);
+                  }
+                  ws.send(JSON.stringify({
+                    event: event,
+                    payload: payload
+                  }));
+                } else {
+                  if (__DEBUG__) {
+                    backend_debug('wall.send()', 'Shutting down bridge because of closed WebSocket connection');
+                  }
+                  if (bridge !== null) {
+                    bridge.shutdown();
+                  }
+                  scheduleRetry();
+                }
+              }
+            });
+            bridge.addListener('updateComponentFilters', function (componentFilters) {
+              // Save filter changes in memory, in case DevTools is reloaded.
+              // In that case, the renderer will already be using the updated values.
+              // We'll lose these in between backend reloads but that can't be helped.
+              savedComponentFilters = componentFilters;
+            }); // The renderer interface doesn't read saved component filters directly,
+            // because they are generally stored in localStorage within the context of the extension.
+            // Because of this it relies on the extension to pass filters.
+            // In the case of the standalone DevTools being used with a website,
+            // saved filters are injected along with the backend script tag so we shouldn't override them here.
+            // This injection strategy doesn't work for React Native though.
+            // Ideally the backend would save the filters itself, but RN doesn't provide a sync storage solution.
+            // So for now we just fall back to using the default filters...
+
+            if (window.__REACT_DEVTOOLS_COMPONENT_FILTERS__ == null) {
+              // $FlowFixMe[incompatible-use] found when upgrading Flow
+              bridge.send('overrideComponentFilters', savedComponentFilters);
+            } // TODO (npm-packages) Warn if "isBackendStorageAPISupported"
+            // $FlowFixMe[incompatible-call] found when upgrading Flow
+
+            var agent = new Agent(bridge, isProfiling, onReloadAndProfile);
+            if (typeof onReloadAndProfileFlagsReset === 'function') {
+              onReloadAndProfileFlagsReset();
+            }
+            if (onSettingsUpdated != null) {
+              agent.addListener('updateHookSettings', onSettingsUpdated);
+            }
+            agent.addListener('shutdown', function () {
+              if (onSettingsUpdated != null) {
+                agent.removeListener('updateHookSettings', onSettingsUpdated);
+              } // If we received 'shutdown' from `agent`, we assume the `bridge` is already shutting down,
+              // and that caused the 'shutdown' event on the `agent`, so we don't need to call `bridge.shutdown()` here.
+
+              hook.emit('shutdown');
+            });
+            initBackend(hook, agent, window, isReloadAndProfileSupported); // Setup React Native style editor if the environment supports it.
+
+            if (resolveRNStyle != null || hook.resolveRNStyle != null) {
+              setupNativeStyleEditor(
+              // $FlowFixMe[incompatible-call] found when upgrading Flow
+              bridge, agent, resolveRNStyle || hook.resolveRNStyle, nativeStyleEditorValidAttributes || hook.nativeStyleEditorValidAttributes || null);
+            } else {
+              // Otherwise listen to detect if the environment later supports it.
+              // For example, Flipper does not eagerly inject these values.
+              // Instead it relies on the React Native Inspector to lazily inject them.
+              var lazyResolveRNStyle;
+              var lazyNativeStyleEditorValidAttributes;
+              var initAfterTick = function initAfterTick() {
+                if (bridge !== null) {
+                  setupNativeStyleEditor(bridge, agent, lazyResolveRNStyle, lazyNativeStyleEditorValidAttributes);
+                }
+              };
+              if (!hook.hasOwnProperty('resolveRNStyle')) {
+                Object.defineProperty(hook, 'resolveRNStyle', {
+                  enumerable: false,
+                  get: function get() {
+                    return lazyResolveRNStyle;
+                  },
+                  set: function set(value) {
+                    lazyResolveRNStyle = value;
+                    initAfterTick();
+                  }
+                });
+              }
+              if (!hook.hasOwnProperty('nativeStyleEditorValidAttributes')) {
+                Object.defineProperty(hook, 'nativeStyleEditorValidAttributes', {
+                  enumerable: false,
+                  get: function get() {
+                    return lazyNativeStyleEditorValidAttributes;
+                  },
+                  set: function set(value) {
+                    lazyNativeStyleEditorValidAttributes = value;
+                    initAfterTick();
+                  }
+                });
+              }
+            }
+          };
+          function handleClose() {
+            if (__DEBUG__) {
+              backend_debug('WebSocket.onclose');
+            }
+            if (bridge !== null) {
+              bridge.emit('shutdown');
+            }
+            scheduleRetry();
+          }
+          function handleFailed() {
+            if (__DEBUG__) {
+              backend_debug('WebSocket.onerror');
+            }
+            scheduleRetry();
+          }
+          function handleMessage(event) {
+            var data;
+            try {
+              if (typeof event.data === 'string') {
+                data = JSON.parse(event.data);
+                if (__DEBUG__) {
+                  backend_debug('WebSocket.onmessage', data);
+                }
+              } else {
+                throw Error();
+              }
+            } catch (e) {
+              console.error('[React DevTools] Failed to parse JSON: ' + event.data);
+              return;
+            }
+            messageListeners.forEach(function (fn) {
+              try {
+                fn(data);
+              } catch (error) {
+                // jsc doesn't play so well with tracebacks that go into eval'd code,
+                // so the stack trace here will stop at the `eval()` call. Getting the
+                // message that caused the error is the best we can do for now.
+                console.log('[React DevTools] Error calling listener', data);
+                console.log('error:', error);
+                throw error;
+              }
+            });
+          }
+        }
+        function _connectWithCustomMessagingProtocol(_ref2) {
+          var onSubscribe = _ref2.onSubscribe,
+            onUnsubscribe = _ref2.onUnsubscribe,
+            onMessage = _ref2.onMessage,
+            nativeStyleEditorValidAttributes = _ref2.nativeStyleEditorValidAttributes,
+            resolveRNStyle = _ref2.resolveRNStyle,
+            onSettingsUpdated = _ref2.onSettingsUpdated,
+            _ref2$isReloadAndProf = _ref2.isReloadAndProfileSupported,
+            isReloadAndProfileSupported = _ref2$isReloadAndProf === void 0 ? getIsReloadAndProfileSupported() : _ref2$isReloadAndProf,
+            isProfiling = _ref2.isProfiling,
+            onReloadAndProfile = _ref2.onReloadAndProfile,
+            onReloadAndProfileFlagsReset = _ref2.onReloadAndProfileFlagsReset;
+          var hook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+          if (hook == null) {
+            // DevTools didn't get injected into this page (maybe b'c of the contentType).
+            return;
+          }
+          var wall = {
+            listen: function listen(fn) {
+              onSubscribe(fn);
+              return function () {
+                onUnsubscribe(fn);
+              };
+            },
+            send: function send(event, payload) {
+              onMessage(event, payload);
+            }
+          };
+          var bridge = new src_bridge(wall);
+          bridge.addListener('updateComponentFilters', function (componentFilters) {
+            // Save filter changes in memory, in case DevTools is reloaded.
+            // In that case, the renderer will already be using the updated values.
+            // We'll lose these in between backend reloads but that can't be helped.
+            savedComponentFilters = componentFilters;
+          });
+          if (window.__REACT_DEVTOOLS_COMPONENT_FILTERS__ == null) {
+            bridge.send('overrideComponentFilters', savedComponentFilters);
+          }
+          var agent = new Agent(bridge, isProfiling, onReloadAndProfile);
+          if (typeof onReloadAndProfileFlagsReset === 'function') {
+            onReloadAndProfileFlagsReset();
+          }
+          if (onSettingsUpdated != null) {
+            agent.addListener('updateHookSettings', onSettingsUpdated);
+          }
+          agent.addListener('shutdown', function () {
+            if (onSettingsUpdated != null) {
+              agent.removeListener('updateHookSettings', onSettingsUpdated);
+            } // If we received 'shutdown' from `agent`, we assume the `bridge` is already shutting down,
+            // and that caused the 'shutdown' event on the `agent`, so we don't need to call `bridge.shutdown()` here.
+
+            hook.emit('shutdown');
+          });
+          var unsubscribeBackend = initBackend(hook, agent, window, isReloadAndProfileSupported);
+          var nativeStyleResolver = resolveRNStyle || hook.resolveRNStyle;
+          if (nativeStyleResolver != null) {
+            var validAttributes = nativeStyleEditorValidAttributes || hook.nativeStyleEditorValidAttributes || null;
+            setupNativeStyleEditor(bridge, agent, nativeStyleResolver, validAttributes);
+          }
+          return unsubscribeBackend;
+        }
+      })();
+
+      /******/
+      return __webpack_exports__;
+      /******/
+    }();
+  });
+},204,[205],"../../node_modules/react-devtools-core/dist/backend.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  // TODO(Babel 8): Remove this file.
+
+  var runtime = _$$_REQUIRE(_dependencyMap[0], "../helpers/regeneratorRuntime")();
+  module.exports = runtime;
+
+  // Copied from https://github.com/facebook/regenerator/blob/main/packages/runtime/runtime.js#L736=
+  try {
+    regeneratorRuntime = runtime;
+  } catch (accidentalStrictMode) {
+    if (typeof globalThis === "object") {
+      globalThis.regeneratorRuntime = runtime;
+    } else {
+      Function("r", "regeneratorRuntime = r")(runtime);
+    }
+  }
+},205,[206],"../../node_modules/@babel/runtime/regenerator/index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _regeneratorRuntime() {
+    "use strict";
+
+    var r = _$$_REQUIRE(_dependencyMap[0], "./regenerator.js")(),
+      e = r.m(_regeneratorRuntime),
+      t = (Object.getPrototypeOf ? Object.getPrototypeOf(e) : e.__proto__).constructor;
+    function n(r) {
+      var e = "function" == typeof r && r.constructor;
+      return !!e && (e === t || "GeneratorFunction" === (e.displayName || e.name));
+    }
+    var o = {
+      "throw": 1,
+      "return": 2,
+      "break": 3,
+      "continue": 3
+    };
+    function a(r) {
+      var e, t;
+      return function (n) {
+        e || (e = {
+          stop: function stop() {
+            return t(n.a, 2);
+          },
+          "catch": function _catch() {
+            return n.v;
+          },
+          abrupt: function abrupt(r, e) {
+            return t(n.a, o[r], e);
+          },
+          delegateYield: function delegateYield(r, o, a) {
+            return e.resultName = o, t(n.d, _$$_REQUIRE(_dependencyMap[1], "./regeneratorValues.js")(r), a);
+          },
+          finish: function finish(r) {
+            return t(n.f, r);
+          }
+        }, t = function t(r, _t, o) {
+          n.p = e.prev, n.n = e.next;
+          try {
+            return r(_t, o);
+          } finally {
+            e.next = n.n;
+          }
+        }), e.resultName && (e[e.resultName] = n.v, e.resultName = void 0), e.sent = n.v, e.next = n.n;
+        try {
+          return r.call(this, e);
+        } finally {
+          n.p = e.prev, n.n = e.next;
+        }
+      };
+    }
+    return (module.exports = _regeneratorRuntime = function _regeneratorRuntime() {
+      return {
+        wrap: function wrap(e, t, n, o) {
+          return r.w(a(e), t, n, o && o.reverse());
+        },
+        isGeneratorFunction: n,
+        mark: r.m,
+        awrap: function awrap(r, e) {
+          return new (_$$_REQUIRE(_dependencyMap[2], "./OverloadYield.js"))(r, e);
+        },
+        AsyncIterator: _$$_REQUIRE(_dependencyMap[3], "./regeneratorAsyncIterator.js"),
+        async: function async(r, e, t, o, u) {
+          return (n(e) ? _$$_REQUIRE(_dependencyMap[4], "./regeneratorAsyncGen.js") : _$$_REQUIRE(_dependencyMap[5], "./regeneratorAsync.js"))(a(r), e, t, o, u);
+        },
+        keys: _$$_REQUIRE(_dependencyMap[6], "./regeneratorKeys.js"),
+        values: _$$_REQUIRE(_dependencyMap[1], "./regeneratorValues.js")
+      };
+    }, module.exports.__esModule = true, module.exports["default"] = module.exports)();
+  }
+  module.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},206,[207,209,210,211,212,213,214],"../../node_modules/@babel/runtime/helpers/regeneratorRuntime.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _regenerator() {
+    /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */
+    var e,
+      t,
+      r = "function" == typeof Symbol ? Symbol : {},
+      n = r.iterator || "@@iterator",
+      o = r.toStringTag || "@@toStringTag";
+    function i(r, n, o, i) {
+      var c = n && n.prototype instanceof Generator ? n : Generator,
+        u = Object.create(c.prototype);
+      return _$$_REQUIRE(_dependencyMap[0], "./regeneratorDefine.js")(u, "_invoke", function (r, n, o) {
+        var i,
+          c,
+          u,
+          f = 0,
+          p = o || [],
+          y = !1,
+          G = {
+            p: 0,
+            n: 0,
+            v: e,
+            a: d,
+            f: d.bind(e, 4),
+            d: function d(t, r) {
+              return i = t, c = 0, u = e, G.n = r, a;
+            }
+          };
+        function d(r, n) {
+          for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) {
+            var o,
+              i = p[t],
+              d = G.p,
+              l = i[2];
+            r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0));
+          }
+          if (o || r > 1) return a;
+          throw y = !0, n;
+        }
+        return function (o, p, l) {
+          if (f > 1) throw TypeError("Generator is already running");
+          for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) {
+            i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u);
+            try {
+              if (f = 2, i) {
+                if (c || (o = "next"), t = i[o]) {
+                  if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object");
+                  if (!t.done) return t;
+                  u = t.value, c < 2 && (c = 0);
+                } else 1 === c && (t = i["return"]) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1);
+                i = e;
+              } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break;
+            } catch (t) {
+              i = e, c = 1, u = t;
+            } finally {
+              f = 1;
+            }
+          }
+          return {
+            value: t,
+            done: y
+          };
+        };
+      }(r, o, i), !0), u;
+    }
+    var a = {};
+    function Generator() {}
+    function GeneratorFunction() {}
+    function GeneratorFunctionPrototype() {}
+    t = Object.getPrototypeOf;
+    var c = [][n] ? t(t([][n]())) : (_$$_REQUIRE(_dependencyMap[0], "./regeneratorDefine.js")(t = {}, n, function () {
+        return this;
+      }), t),
+      u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c);
+    function f(e) {
+      return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _$$_REQUIRE(_dependencyMap[0], "./regeneratorDefine.js")(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e;
+    }
+    return GeneratorFunction.prototype = GeneratorFunctionPrototype, _$$_REQUIRE(_dependencyMap[0], "./regeneratorDefine.js")(u, "constructor", GeneratorFunctionPrototype), _$$_REQUIRE(_dependencyMap[0], "./regeneratorDefine.js")(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _$$_REQUIRE(_dependencyMap[0], "./regeneratorDefine.js")(GeneratorFunctionPrototype, o, "GeneratorFunction"), _$$_REQUIRE(_dependencyMap[0], "./regeneratorDefine.js")(u), _$$_REQUIRE(_dependencyMap[0], "./regeneratorDefine.js")(u, o, "Generator"), _$$_REQUIRE(_dependencyMap[0], "./regeneratorDefine.js")(u, n, function () {
+      return this;
+    }), _$$_REQUIRE(_dependencyMap[0], "./regeneratorDefine.js")(u, "toString", function () {
+      return "[object Generator]";
+    }), (module.exports = _regenerator = function _regenerator() {
+      return {
+        w: i,
+        m: f
+      };
+    }, module.exports.__esModule = true, module.exports["default"] = module.exports)();
+  }
+  module.exports = _regenerator, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},207,[208],"../../node_modules/@babel/runtime/helpers/regenerator.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _regeneratorDefine(e, r, n, t) {
+    var i = Object.defineProperty;
+    try {
+      i({}, "", {});
+    } catch (e) {
+      i = 0;
+    }
+    module.exports = _regeneratorDefine = function regeneratorDefine(e, r, n, t) {
+      function o(r, n) {
+        _regeneratorDefine(e, r, function (e) {
+          return this._invoke(r, n, e);
+        });
+      }
+      r ? i ? i(e, r, {
+        value: n,
+        enumerable: !t,
+        configurable: !t,
+        writable: !t
+      }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2));
+    }, module.exports.__esModule = true, module.exports["default"] = module.exports, _regeneratorDefine(e, r, n, t);
+  }
+  module.exports = _regeneratorDefine, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},208,[],"../../node_modules/@babel/runtime/helpers/regeneratorDefine.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _regeneratorValues(e) {
+    if (null != e) {
+      var t = e["function" == typeof Symbol && Symbol.iterator || "@@iterator"],
+        r = 0;
+      if (t) return t.call(e);
+      if ("function" == typeof e.next) return e;
+      if (!isNaN(e.length)) return {
+        next: function next() {
+          return e && r >= e.length && (e = void 0), {
+            value: e && e[r++],
+            done: !e
+          };
+        }
+      };
+    }
+    throw new TypeError(_$$_REQUIRE(_dependencyMap[0], "./typeof.js")["default"](e) + " is not iterable");
+  }
+  module.exports = _regeneratorValues, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},209,[15],"../../node_modules/@babel/runtime/helpers/regeneratorValues.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _OverloadYield(e, d) {
+    this.v = e, this.k = d;
+  }
+  module.exports = _OverloadYield, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},210,[],"../../node_modules/@babel/runtime/helpers/OverloadYield.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function AsyncIterator(t, e) {
+    function n(r, o, i, f) {
+      try {
+        var c = t[r](o),
+          u = c.value;
+        return u instanceof _$$_REQUIRE(_dependencyMap[0], "./OverloadYield.js") ? e.resolve(u.v).then(function (t) {
+          n("next", t, i, f);
+        }, function (t) {
+          n("throw", t, i, f);
+        }) : e.resolve(u).then(function (t) {
+          c.value = t, i(c);
+        }, function (t) {
+          return n("throw", t, i, f);
+        });
+      } catch (t) {
+        f(t);
+      }
+    }
+    var r;
+    this.next || (_$$_REQUIRE(_dependencyMap[1], "./regeneratorDefine.js")(AsyncIterator.prototype), _$$_REQUIRE(_dependencyMap[1], "./regeneratorDefine.js")(AsyncIterator.prototype, "function" == typeof Symbol && Symbol.asyncIterator || "@asyncIterator", function () {
+      return this;
+    })), _$$_REQUIRE(_dependencyMap[1], "./regeneratorDefine.js")(this, "_invoke", function (t, o, i) {
+      function f() {
+        return new e(function (e, r) {
+          n(t, i, e, r);
+        });
+      }
+      return r = r ? r.then(f, f) : f();
+    }, !0);
+  }
+  module.exports = AsyncIterator, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},211,[210,208],"../../node_modules/@babel/runtime/helpers/regeneratorAsyncIterator.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _regeneratorAsyncGen(r, e, t, o, n) {
+    return new (_$$_REQUIRE(_dependencyMap[0], "./regeneratorAsyncIterator.js"))(_$$_REQUIRE(_dependencyMap[1], "./regenerator.js")().w(r, e, t, o), n || Promise);
+  }
+  module.exports = _regeneratorAsyncGen, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},212,[211,207],"../../node_modules/@babel/runtime/helpers/regeneratorAsyncGen.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _regeneratorAsync(n, e, r, t, o) {
+    var a = _$$_REQUIRE(_dependencyMap[0], "./regeneratorAsyncGen.js")(n, e, r, t, o);
+    return a.next().then(function (n) {
+      return n.done ? n.value : a.next();
+    });
+  }
+  module.exports = _regeneratorAsync, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},213,[212],"../../node_modules/@babel/runtime/helpers/regeneratorAsync.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function _regeneratorKeys(e) {
+    var n = Object(e),
+      r = [];
+    for (var t in n) r.unshift(t);
+    return function e() {
+      for (; r.length;) if ((t = r.pop()) in n) return e.value = t, e.done = !1, e;
+      return e.done = !0, e;
+    };
+  }
+  module.exports = _regeneratorKeys, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},214,[],"../../node_modules/@babel/runtime/helpers/regeneratorKeys.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty"));
+  var _Settings = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../../../Libraries/Settings/Settings"));
+  var GLOBAL_HOOK_SETTINGS = 'ReactDevTools::HookSettings';
+  var ReactDevToolsSettingsManager = {
+    setGlobalHookSettings: function setGlobalHookSettings(settings) {
+      _Settings.default.set((0, _defineProperty2.default)({}, GLOBAL_HOOK_SETTINGS, settings));
+    },
+    getGlobalHookSettings: function getGlobalHookSettings() {
+      var value = _Settings.default.get(GLOBAL_HOOK_SETTINGS);
+      if (typeof value === 'string') {
+        return value;
+      }
+      return null;
+    }
+  };
+  module.exports = ReactDevToolsSettingsManager;
+},215,[1,65,216],"../../node_modules/react-native/src/private/devsupport/rndevtools/ReactDevToolsSettingsManager.ios.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _RCTDeviceEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../EventEmitter/RCTDeviceEventEmitter"));
+  var _NativeSettingsManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./NativeSettingsManager"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "invariant"));
+  var subscriptions = [];
+  var Settings = {
+    _settings: _NativeSettingsManager.default && _NativeSettingsManager.default.getConstants().settings,
+    get: function get(key) {
+      return this._settings[key];
+    },
+    set: function set(settings) {
+      this._settings = Object.assign(this._settings, settings);
+      _NativeSettingsManager.default.setValues(settings);
+    },
+    watchKeys: function watchKeys(keys, callback) {
+      if (typeof keys === 'string') {
+        keys = [keys];
+      }
+      (0, _invariant.default)(Array.isArray(keys), 'keys should be a string or array of strings');
+      var sid = subscriptions.length;
+      subscriptions.push({
+        keys: keys,
+        callback: callback
+      });
+      return sid;
+    },
+    clearWatch: function clearWatch(watchId) {
+      if (watchId < subscriptions.length) {
+        subscriptions[watchId] = {
+          keys: [],
+          callback: null
+        };
+      }
+    },
+    _sendObservations: function _sendObservations(body) {
+      var _this = this;
+      Object.keys(body).forEach(function (key) {
+        var newValue = body[key];
+        var didChange = _this._settings[key] !== newValue;
+        _this._settings[key] = newValue;
+        if (didChange) {
+          subscriptions.forEach(function (sub) {
+            if (sub.keys.indexOf(key) !== -1 && sub.callback) {
+              sub.callback();
+            }
+          });
+        }
+      });
+    }
+  };
+  _RCTDeviceEventEmitter.default.addListener('settingsUpdated', Settings._sendObservations.bind(Settings));
+  var _default = exports.default = Settings;
+},216,[1,17,217,32],"../../node_modules/react-native/Libraries/Settings/Settings.ios.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeSettingsManager = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativeSettingsManager"));
+  Object.keys(_NativeSettingsManager).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeSettingsManager[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeSettingsManager[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeSettingsManager.default;
+},217,[218],"../../node_modules/react-native/Libraries/Settings/NativeSettingsManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.getEnforcing('SettingsManager');
+},218,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeSettingsManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.get('ReactDevToolsRuntimeSettingsModule');
+},219,[31],"../../node_modules/react-native/src/private/devsupport/rndevtools/specs/NativeReactDevToolsRuntimeSettingsModule.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _NativeEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../EventEmitter/NativeEventEmitter"));
+  var _logError = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../Utilities/logError"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../Utilities/Platform"));
+  var _NativeAppState = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./NativeAppState"));
+  var AppStateImpl = /*#__PURE__*/function () {
+    function AppStateImpl() {
+      var _this = this;
+      (0, _classCallCheck2.default)(this, AppStateImpl);
+      this.currentState = null;
+      if (_NativeAppState.default == null) {
+        this.isAvailable = false;
+      } else {
+        this.isAvailable = true;
+        var emitter = new _NativeEventEmitter.default(_Platform.default.OS !== 'ios' ? null : _NativeAppState.default);
+        this._emitter = emitter;
+        this.currentState = _NativeAppState.default.getConstants().initialAppState;
+        var eventUpdated = false;
+        emitter.addListener('appStateDidChange', function (appStateData) {
+          eventUpdated = true;
+          _this.currentState = appStateData.app_state;
+        });
+        _NativeAppState.default.getCurrentAppState(function (appStateData) {
+          if (!eventUpdated && _this.currentState !== appStateData.app_state) {
+            _this.currentState = appStateData.app_state;
+            emitter.emit('appStateDidChange', appStateData);
+          }
+        }, _logError.default);
+      }
+    }
+    return (0, _createClass2.default)(AppStateImpl, [{
+      key: "addEventListener",
+      value: function addEventListener(type, handler) {
+        var emitter = this._emitter;
+        if (emitter == null) {
+          throw new Error('Cannot use AppState when `isAvailable` is false.');
+        }
+        switch (type) {
+          case 'change':
+            var changeHandler = handler;
+            return emitter.addListener('appStateDidChange', function (appStateData) {
+              changeHandler(appStateData.app_state);
+            });
+          case 'memoryWarning':
+            var memoryWarningHandler = handler;
+            return emitter.addListener('memoryWarning', memoryWarningHandler);
+          case 'blur':
+          case 'focus':
+            var focusOrBlurHandler = handler;
+            return emitter.addListener('appStateFocusChange', function (hasFocus) {
+              if (type === 'blur' && !hasFocus) {
+                focusOrBlurHandler();
+              }
+              if (type === 'focus' && hasFocus) {
+                focusOrBlurHandler();
+              }
+            });
+        }
+        throw new Error('Trying to subscribe to unknown event: ' + type);
+      }
+    }]);
+  }();
+  var AppState = new AppStateImpl();
+  var _default = exports.default = AppState;
+},220,[1,11,12,221,222,68,223],"../../node_modules/react-native/Libraries/AppState/AppState.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../Utilities/Platform"));
+  var _RCTDeviceEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./RCTDeviceEventEmitter"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "invariant"));
+  var NativeEventEmitter = exports.default = /*#__PURE__*/function () {
+    function NativeEventEmitter(nativeModule) {
+      (0, _classCallCheck2.default)(this, NativeEventEmitter);
+      if (_Platform.default.OS === 'ios') {
+        (0, _invariant.default)(nativeModule != null, '`new NativeEventEmitter()` requires a non-null argument.');
+      }
+      var hasAddListener = !!nativeModule && typeof nativeModule.addListener === 'function';
+      var hasRemoveListeners = !!nativeModule && typeof nativeModule.removeListeners === 'function';
+      if (nativeModule && hasAddListener && hasRemoveListeners) {
+        this._nativeModule = nativeModule;
+      } else if (nativeModule != null) {
+        if (!hasAddListener) {
+          console.warn('`new NativeEventEmitter()` was called with a non-null argument without the required `addListener` method.');
+        }
+        if (!hasRemoveListeners) {
+          console.warn('`new NativeEventEmitter()` was called with a non-null argument without the required `removeListeners` method.');
+        }
+      }
+    }
+    return (0, _createClass2.default)(NativeEventEmitter, [{
+      key: "addListener",
+      value: function addListener(eventType, listener, context) {
+        var _this$_nativeModule,
+          _this = this;
+        (_this$_nativeModule = this._nativeModule) == null || _this$_nativeModule.addListener(eventType);
+        var subscription = _RCTDeviceEventEmitter.default.addListener(eventType, listener, context);
+        return {
+          remove: function remove() {
+            if (subscription != null) {
+              var _this$_nativeModule2;
+              (_this$_nativeModule2 = _this._nativeModule) == null || _this$_nativeModule2.removeListeners(1);
+              subscription.remove();
+              subscription = null;
+            }
+          }
+        };
+      }
+    }, {
+      key: "emit",
+      value: function emit(eventType) {
+        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+          args[_key - 1] = arguments[_key];
+        }
+        _RCTDeviceEventEmitter.default.emit.apply(_RCTDeviceEventEmitter.default, [eventType].concat(args));
+      }
+    }, {
+      key: "removeAllListeners",
+      value: function removeAllListeners(eventType) {
+        var _this$_nativeModule3;
+        (0, _invariant.default)(eventType != null, '`NativeEventEmitter.removeAllListener()` requires a non-null argument.');
+        (_this$_nativeModule3 = this._nativeModule) == null || _this$_nativeModule3.removeListeners(this.listenerCount(eventType));
+        _RCTDeviceEventEmitter.default.removeAllListeners(eventType);
+      }
+    }, {
+      key: "listenerCount",
+      value: function listenerCount(eventType) {
+        return _RCTDeviceEventEmitter.default.listenerCount(eventType);
+      }
+    }]);
+  }();
+},221,[1,11,12,68,17,32],"../../node_modules/react-native/Libraries/EventEmitter/NativeEventEmitter.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var logError = function logError() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    if (args.length === 1 && args[0] instanceof Error) {
+      var err = args[0];
+      console.error('Error: "' + err.message + '".  Stack:\n' + err.stack);
+    } else {
+      console.error.apply(console, args);
+    }
+  };
+  var _default = exports.default = logError;
+},222,[],"../../node_modules/react-native/Libraries/Utilities/logError.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeAppState = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativeAppState"));
+  Object.keys(_NativeAppState).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeAppState[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeAppState[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeAppState.default;
+},223,[224],"../../node_modules/react-native/Libraries/AppState/NativeAppState.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.getEnforcing('AppState');
+},224,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeAppState.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _Event = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../../src/private/webapis/dom/events/Event"));
+  var _EventTarget2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../../src/private/webapis/dom/events/EventTarget"));
+  var _MessageEvent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "../../src/private/webapis/html/events/MessageEvent"));
+  var _CloseEvent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "../../src/private/webapis/websockets/events/CloseEvent"));
+  var _Blob = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "../Blob/Blob"));
+  var _BlobManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "../Blob/BlobManager"));
+  var _NativeEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[13], "../EventEmitter/NativeEventEmitter"));
+  var _binaryToBase = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[14], "../Utilities/binaryToBase64"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[15], "../Utilities/Platform"));
+  var _NativeWebSocketModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[16], "./NativeWebSocketModule"));
+  var _base64Js = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[17], "base64-js"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[18], "invariant"));
+  var _excluded = ["headers"];
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var CONNECTING = 0;
+  var OPEN = 1;
+  var CLOSING = 2;
+  var CLOSED = 3;
+  var CLOSE_NORMAL = 1000;
+  var CLOSE_ABNORMAL = 1006;
+  var nextWebSocketId = 0;
+  var WebSocket = /*#__PURE__*/function (_EventTarget) {
+    function WebSocket(url, protocols, options) {
+      var _this;
+      (0, _classCallCheck2.default)(this, WebSocket);
+      _this = _callSuper(this, WebSocket);
+      _this.CONNECTING = CONNECTING;
+      _this.OPEN = OPEN;
+      _this.CLOSING = CLOSING;
+      _this.CLOSED = CLOSED;
+      _this.readyState = CONNECTING;
+      _this.url = url;
+      if (typeof protocols === 'string') {
+        protocols = [protocols];
+      }
+      var _ref = options || {},
+        _ref$headers = _ref.headers,
+        headers = _ref$headers === void 0 ? {} : _ref$headers,
+        unrecognized = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+      if (unrecognized && typeof unrecognized.origin === 'string') {
+        console.warn('Specifying `origin` as a WebSocket connection option is deprecated. Include it under `headers` instead.');
+        headers.origin = unrecognized.origin;
+        delete unrecognized.origin;
+      }
+      if (Object.keys(unrecognized).length > 0) {
+        console.warn('Unrecognized WebSocket connection option(s) `' + Object.keys(unrecognized).join('`, `') + '`. ' + 'Did you mean to put these under `headers`?');
+      }
+      if (!Array.isArray(protocols)) {
+        protocols = null;
+      }
+      _this._eventEmitter = new _NativeEventEmitter.default(_Platform.default.OS !== 'ios' ? null : _NativeWebSocketModule.default);
+      _this._socketId = nextWebSocketId++;
+      _this._registerEvents();
+      _NativeWebSocketModule.default.connect(url, protocols, {
+        headers: headers
+      }, _this._socketId);
+      return _this;
+    }
+    (0, _inherits2.default)(WebSocket, _EventTarget);
+    return (0, _createClass2.default)(WebSocket, [{
+      key: "binaryType",
+      get: function get() {
+        return this._binaryType;
+      },
+      set: function set(binaryType) {
+        if (binaryType !== 'blob' && binaryType !== 'arraybuffer') {
+          throw new Error("binaryType must be either 'blob' or 'arraybuffer'");
+        }
+        if (this._binaryType === 'blob' || binaryType === 'blob') {
+          (0, _invariant.default)(_BlobManager.default.isAvailable, 'Native module BlobModule is required for blob support');
+          if (binaryType === 'blob') {
+            _BlobManager.default.addWebSocketHandler(this._socketId);
+          } else {
+            _BlobManager.default.removeWebSocketHandler(this._socketId);
+          }
+        }
+        this._binaryType = binaryType;
+      }
+    }, {
+      key: "close",
+      value: function close(code, reason) {
+        if (this.readyState === this.CLOSING || this.readyState === this.CLOSED) {
+          return;
+        }
+        this.readyState = this.CLOSING;
+        this._close(code, reason);
+      }
+    }, {
+      key: "send",
+      value: function send(data) {
+        if (this.readyState === this.CONNECTING) {
+          throw new Error('INVALID_STATE_ERR');
+        }
+        if (data instanceof _Blob.default) {
+          (0, _invariant.default)(_BlobManager.default.isAvailable, 'Native module BlobModule is required for blob support');
+          _BlobManager.default.sendOverSocket(data, this._socketId);
+          return;
+        }
+        if (typeof data === 'string') {
+          _NativeWebSocketModule.default.send(data, this._socketId);
+          return;
+        }
+        if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+          _NativeWebSocketModule.default.sendBinary((0, _binaryToBase.default)(data), this._socketId);
+          return;
+        }
+        throw new Error('Unsupported data type');
+      }
+    }, {
+      key: "ping",
+      value: function ping() {
+        if (this.readyState === this.CONNECTING) {
+          throw new Error('INVALID_STATE_ERR');
+        }
+        _NativeWebSocketModule.default.ping(this._socketId);
+      }
+    }, {
+      key: "_close",
+      value: function _close(code, reason) {
+        var statusCode = typeof code === 'number' ? code : CLOSE_NORMAL;
+        var closeReason = typeof reason === 'string' ? reason : '';
+        _NativeWebSocketModule.default.close(statusCode, closeReason, this._socketId);
+        if (_BlobManager.default.isAvailable && this._binaryType === 'blob') {
+          _BlobManager.default.removeWebSocketHandler(this._socketId);
+        }
+      }
+    }, {
+      key: "_unregisterEvents",
+      value: function _unregisterEvents() {
+        this._subscriptions.forEach(function (e) {
+          return e.remove();
+        });
+        this._subscriptions = [];
+      }
+    }, {
+      key: "_registerEvents",
+      value: function _registerEvents() {
+        var _this2 = this;
+        this._subscriptions = [this._eventEmitter.addListener('websocketMessage', function (ev) {
+          if (ev.id !== _this2._socketId) {
+            return;
+          }
+          var data = ev.data;
+          switch (ev.type) {
+            case 'binary':
+              data = _base64Js.default.toByteArray(ev.data).buffer;
+              break;
+            case 'blob':
+              data = _BlobManager.default.createFromOptions(ev.data);
+              break;
+          }
+          _this2.dispatchEvent(new _MessageEvent.default('message', {
+            data: data
+          }));
+        }), this._eventEmitter.addListener('websocketOpen', function (ev) {
+          if (ev.id !== _this2._socketId) {
+            return;
+          }
+          _this2.readyState = _this2.OPEN;
+          _this2.protocol = ev.protocol;
+          _this2.dispatchEvent(new _Event.default('open'));
+        }), this._eventEmitter.addListener('websocketClosed', function (ev) {
+          if (ev.id !== _this2._socketId) {
+            return;
+          }
+          _this2.readyState = _this2.CLOSED;
+          _this2.dispatchEvent(new _CloseEvent.default('close', {
+            code: ev.code,
+            reason: ev.reason
+          }));
+          _this2._unregisterEvents();
+          _this2.close();
+        }), this._eventEmitter.addListener('websocketFailed', function (ev) {
+          if (ev.id !== _this2._socketId) {
+            return;
+          }
+          _this2.readyState = _this2.CLOSED;
+          _this2.dispatchEvent(new _Event.default('error'));
+          _this2.dispatchEvent(new _CloseEvent.default('close', {
+            code: CLOSE_ABNORMAL,
+            reason: ev.message
+          }));
+          _this2._unregisterEvents();
+          _this2.close();
+        })];
+      }
+    }, {
+      key: "onclose",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[19], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'close');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[19], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'close', listener);
+      }
+    }, {
+      key: "onerror",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[19], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'error');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[19], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'error', listener);
+      }
+    }, {
+      key: "onmessage",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[19], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'message');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[19], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'message', listener);
+      }
+    }, {
+      key: "onopen",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[19], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'open');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[19], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'open', listener);
+      }
+    }]);
+  }(_EventTarget2.default);
+  WebSocket.CONNECTING = CONNECTING;
+  WebSocket.OPEN = OPEN;
+  WebSocket.CLOSING = CLOSING;
+  WebSocket.CLOSED = CLOSED;
+  var _default = exports.default = WebSocket;
+},225,[1,4,11,12,18,20,23,226,228,230,231,232,233,221,237,68,239,238,32,241],"../../node_modules/react-native/Libraries/WebSocket/WebSocket.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var Event = exports.default = /*#__PURE__*/function () {
+    function Event(type, options) {
+      (0, _classCallCheck2.default)(this, Event);
+      this._defaultPrevented = false;
+      this._timeStamp = performance.now();
+      this[_$$_REQUIRE(_dependencyMap[3], "./internals/EventInternals").COMPOSED_PATH_KEY] = [];
+      this[_$$_REQUIRE(_dependencyMap[3], "./internals/EventInternals").CURRENT_TARGET_KEY] = null;
+      this[_$$_REQUIRE(_dependencyMap[3], "./internals/EventInternals").EVENT_PHASE_KEY] = Event.NONE;
+      this[_$$_REQUIRE(_dependencyMap[3], "./internals/EventInternals").IN_PASSIVE_LISTENER_FLAG_KEY] = false;
+      this[_$$_REQUIRE(_dependencyMap[3], "./internals/EventInternals").IS_TRUSTED_KEY] = false;
+      this[_$$_REQUIRE(_dependencyMap[3], "./internals/EventInternals").STOP_IMMEDIATE_PROPAGATION_FLAG_KEY] = false;
+      this[_$$_REQUIRE(_dependencyMap[3], "./internals/EventInternals").STOP_PROPAGATION_FLAG_KEY] = false;
+      this[_$$_REQUIRE(_dependencyMap[3], "./internals/EventInternals").TARGET_KEY] = null;
+      if (arguments.length < 1) {
+        throw new TypeError("Failed to construct 'Event': 1 argument required, but only 0 present.");
+      }
+      var typeOfOptions = typeof options;
+      if (options != null && typeOfOptions !== 'object' && typeOfOptions !== 'function') {
+        throw new TypeError("Failed to construct 'Event': The provided value is not of type 'EventInit'.");
+      }
+      this._type = String(type);
+      this._bubbles = Boolean(options == null ? void 0 : options.bubbles);
+      this._cancelable = Boolean(options == null ? void 0 : options.cancelable);
+      this._composed = Boolean(options == null ? void 0 : options.composed);
+    }
+    return (0, _createClass2.default)(Event, [{
+      key: "bubbles",
+      get: function get() {
+        return this._bubbles;
+      }
+    }, {
+      key: "cancelable",
+      get: function get() {
+        return this._cancelable;
+      }
+    }, {
+      key: "composed",
+      get: function get() {
+        return this._composed;
+      }
+    }, {
+      key: "currentTarget",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[3], "./internals/EventInternals").getCurrentTarget)(this);
+      }
+    }, {
+      key: "defaultPrevented",
+      get: function get() {
+        return this._defaultPrevented;
+      }
+    }, {
+      key: "eventPhase",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[3], "./internals/EventInternals").getEventPhase)(this);
+      }
+    }, {
+      key: "isTrusted",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[3], "./internals/EventInternals").getIsTrusted)(this);
+      }
+    }, {
+      key: "target",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[3], "./internals/EventInternals").getTarget)(this);
+      }
+    }, {
+      key: "timeStamp",
+      get: function get() {
+        return this._timeStamp;
+      }
+    }, {
+      key: "type",
+      get: function get() {
+        return this._type;
+      }
+    }, {
+      key: "composedPath",
+      value: function composedPath() {
+        return (0, _$$_REQUIRE(_dependencyMap[3], "./internals/EventInternals").getComposedPath)(this).slice();
+      }
+    }, {
+      key: "preventDefault",
+      value: function preventDefault() {
+        if (!this._cancelable) {
+          return;
+        }
+        if ((0, _$$_REQUIRE(_dependencyMap[3], "./internals/EventInternals").getInPassiveListenerFlag)(this)) {
+          console.error(new Error('Unable to preventDefault inside passive event listener invocation.'));
+          return;
+        }
+        this._defaultPrevented = true;
+      }
+    }, {
+      key: "stopImmediatePropagation",
+      value: function stopImmediatePropagation() {
+        (0, _$$_REQUIRE(_dependencyMap[3], "./internals/EventInternals").setStopPropagationFlag)(this, true);
+        (0, _$$_REQUIRE(_dependencyMap[3], "./internals/EventInternals").setStopImmediatePropagationFlag)(this, true);
+      }
+    }, {
+      key: "stopPropagation",
+      value: function stopPropagation() {
+        (0, _$$_REQUIRE(_dependencyMap[3], "./internals/EventInternals").setStopPropagationFlag)(this, true);
+      }
+    }]);
+  }();
+  Object.defineProperty(Event, 'NONE', {
+    enumerable: true,
+    value: 0
+  });
+  Object.defineProperty(Event.prototype, 'NONE', {
+    enumerable: true,
+    value: 0
+  });
+  Object.defineProperty(Event, 'CAPTURING_PHASE', {
+    enumerable: true,
+    value: 1
+  });
+  Object.defineProperty(Event.prototype, 'CAPTURING_PHASE', {
+    enumerable: true,
+    value: 1
+  });
+  Object.defineProperty(Event, 'AT_TARGET', {
+    enumerable: true,
+    value: 2
+  });
+  Object.defineProperty(Event.prototype, 'AT_TARGET', {
+    enumerable: true,
+    value: 2
+  });
+  Object.defineProperty(Event, 'BUBBLING_PHASE', {
+    enumerable: true,
+    value: 3
+  });
+  Object.defineProperty(Event.prototype, 'BUBBLING_PHASE', {
+    enumerable: true,
+    value: 3
+  });
+},226,[1,11,12,227],"../../node_modules/react-native/src/private/webapis/dom/events/Event.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.TARGET_KEY = exports.STOP_PROPAGATION_FLAG_KEY = exports.STOP_IMMEDIATE_PROPAGATION_FLAG_KEY = exports.IS_TRUSTED_KEY = exports.IN_PASSIVE_LISTENER_FLAG_KEY = exports.EVENT_PHASE_KEY = exports.CURRENT_TARGET_KEY = exports.COMPOSED_PATH_KEY = void 0;
+  exports.getComposedPath = getComposedPath;
+  exports.getCurrentTarget = getCurrentTarget;
+  exports.getEventPhase = getEventPhase;
+  exports.getInPassiveListenerFlag = getInPassiveListenerFlag;
+  exports.getIsTrusted = getIsTrusted;
+  exports.getStopImmediatePropagationFlag = getStopImmediatePropagationFlag;
+  exports.getStopPropagationFlag = getStopPropagationFlag;
+  exports.getTarget = getTarget;
+  exports.setComposedPath = setComposedPath;
+  exports.setCurrentTarget = setCurrentTarget;
+  exports.setEventPhase = setEventPhase;
+  exports.setInPassiveListenerFlag = setInPassiveListenerFlag;
+  exports.setIsTrusted = setIsTrusted;
+  exports.setStopImmediatePropagationFlag = setStopImmediatePropagationFlag;
+  exports.setStopPropagationFlag = setStopPropagationFlag;
+  exports.setTarget = setTarget;
+  var COMPOSED_PATH_KEY = exports.COMPOSED_PATH_KEY = Symbol('composedPath');
+  var CURRENT_TARGET_KEY = exports.CURRENT_TARGET_KEY = Symbol('currentTarget');
+  var EVENT_PHASE_KEY = exports.EVENT_PHASE_KEY = Symbol('eventPhase');
+  var IN_PASSIVE_LISTENER_FLAG_KEY = exports.IN_PASSIVE_LISTENER_FLAG_KEY = Symbol('inPassiveListenerFlag');
+  var IS_TRUSTED_KEY = exports.IS_TRUSTED_KEY = Symbol('isTrusted');
+  var STOP_IMMEDIATE_PROPAGATION_FLAG_KEY = exports.STOP_IMMEDIATE_PROPAGATION_FLAG_KEY = Symbol('stopPropagationFlag');
+  var STOP_PROPAGATION_FLAG_KEY = exports.STOP_PROPAGATION_FLAG_KEY = Symbol('stopPropagationFlag');
+  var TARGET_KEY = exports.TARGET_KEY = Symbol('target');
+  function getCurrentTarget(event) {
+    return event[CURRENT_TARGET_KEY];
+  }
+  function setCurrentTarget(event, currentTarget) {
+    event[CURRENT_TARGET_KEY] = currentTarget;
+  }
+  function getComposedPath(event) {
+    return event[COMPOSED_PATH_KEY];
+  }
+  function setComposedPath(event, composedPath) {
+    event[COMPOSED_PATH_KEY] = composedPath;
+  }
+  function getEventPhase(event) {
+    return event[EVENT_PHASE_KEY];
+  }
+  function setEventPhase(event, eventPhase) {
+    event[EVENT_PHASE_KEY] = eventPhase;
+  }
+  function getInPassiveListenerFlag(event) {
+    return event[IN_PASSIVE_LISTENER_FLAG_KEY];
+  }
+  function setInPassiveListenerFlag(event, value) {
+    event[IN_PASSIVE_LISTENER_FLAG_KEY] = value;
+  }
+  function getIsTrusted(event) {
+    return event[IS_TRUSTED_KEY];
+  }
+  function setIsTrusted(event, isTrusted) {
+    event[IS_TRUSTED_KEY] = isTrusted;
+  }
+  function getStopImmediatePropagationFlag(event) {
+    return event[STOP_IMMEDIATE_PROPAGATION_FLAG_KEY];
+  }
+  function setStopImmediatePropagationFlag(event, value) {
+    event[STOP_IMMEDIATE_PROPAGATION_FLAG_KEY] = value;
+  }
+  function getStopPropagationFlag(event) {
+    return event[STOP_PROPAGATION_FLAG_KEY];
+  }
+  function setStopPropagationFlag(event, value) {
+    event[STOP_PROPAGATION_FLAG_KEY] = value;
+  }
+  function getTarget(event) {
+    return event[TARGET_KEY];
+  }
+  function setTarget(event, target) {
+    event[TARGET_KEY] = target;
+  }
+},227,[],"../../node_modules/react-native/src/private/webapis/dom/events/internals/EventInternals.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _Event = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./Event"));
+  var EventTarget = exports.default = /*#__PURE__*/function () {
+    function EventTarget() {
+      (0, _classCallCheck2.default)(this, EventTarget);
+    }
+    return (0, _createClass2.default)(EventTarget, [{
+      key: "addEventListener",
+      value: function addEventListener(type, callback) {
+        var _signal, _listenersByType;
+        var optionsOrUseCapture = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        if (arguments.length < 2) {
+          throw new TypeError(`Failed to execute 'addEventListener' on 'EventTarget': 2 arguments required, but only ${arguments.length} present.`);
+        }
+        if (callback == null) {
+          return;
+        }
+        validateCallback(callback, 'addEventListener');
+        var processedType = String(type);
+        var capture;
+        var passive;
+        var once;
+        var signal;
+        if (optionsOrUseCapture != null && (typeof optionsOrUseCapture === 'object' || typeof optionsOrUseCapture === 'function')) {
+          capture = Boolean(optionsOrUseCapture.capture);
+          passive = optionsOrUseCapture.passive == null ? getDefaultPassiveValue(processedType, this) : Boolean(optionsOrUseCapture.passive);
+          once = Boolean(optionsOrUseCapture.once);
+          signal = optionsOrUseCapture.signal;
+          if (signal !== undefined && !(signal instanceof AbortSignal)) {
+            throw new TypeError("Failed to execute 'addEventListener' on 'EventTarget': Failed to read the 'signal' property from 'AddEventListenerOptions': Failed to convert value to 'AbortSignal'.");
+          }
+        } else {
+          capture = Boolean(optionsOrUseCapture);
+          passive = false;
+          once = false;
+          signal = null;
+        }
+        if ((_signal = signal) != null && _signal.aborted) {
+          return;
+        }
+        var listenersByType = getListenersForPhase(this, capture);
+        var listeners = (_listenersByType = listenersByType) == null ? void 0 : _listenersByType.get(processedType);
+        if (listeners == null) {
+          if (listenersByType == null) {
+            listenersByType = new Map();
+            setListenersMap(this, capture, listenersByType);
+          }
+          listeners = new Map();
+          listenersByType.set(processedType, listeners);
+        } else if (listeners.has(callback)) {
+          return;
+        }
+        var listener = {
+          callback: callback,
+          passive: passive,
+          once: once,
+          removed: false
+        };
+        listeners.set(callback, listener);
+        var nonNullListeners = listeners;
+        if (signal != null) {
+          signal.addEventListener('abort', function () {
+            listener.removed = true;
+            if (nonNullListeners.get(callback) === listener) {
+              nonNullListeners.delete(callback);
+            }
+          }, {
+            once: true
+          });
+        }
+      }
+    }, {
+      key: "removeEventListener",
+      value: function removeEventListener(type, callback) {
+        var optionsOrUseCapture = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        if (arguments.length < 2) {
+          throw new TypeError(`Failed to execute 'removeEventListener' on 'EventTarget': 2 arguments required, but only ${arguments.length} present.`);
+        }
+        if (callback == null) {
+          return;
+        }
+        validateCallback(callback, 'removeEventListener');
+        var processedType = String(type);
+        var capture = typeof optionsOrUseCapture === 'boolean' ? optionsOrUseCapture : Boolean(optionsOrUseCapture.capture);
+        var listenersByType = getListenersForPhase(this, capture);
+        var listeners = listenersByType == null ? void 0 : listenersByType.get(processedType);
+        if (listeners == null) {
+          return;
+        }
+        var listener = listeners.get(callback);
+        if (listener != null) {
+          listener.removed = true;
+          listeners.delete(callback);
+        }
+      }
+    }, {
+      key: "dispatchEvent",
+      value: function dispatchEvent(event) {
+        if (!(event instanceof _Event.default)) {
+          throw new TypeError("Failed to execute 'dispatchEvent' on 'EventTarget': parameter 1 is not of type 'Event'.");
+        }
+        if (getEventDispatchFlag(event)) {
+          throw new Error("Failed to execute 'dispatchEvent' on 'EventTarget': The event is already being dispatched.");
+        }
+        (0, _$$_REQUIRE(_dependencyMap[4], "./internals/EventInternals").setIsTrusted)(event, false);
+        dispatch(this, event);
+        return !event.defaultPrevented;
+      }
+    }, {
+      key: _$$_REQUIRE(_dependencyMap[5], "./internals/EventTargetInternals").EVENT_TARGET_GET_THE_PARENT_KEY,
+      value: function value() {
+        return null;
+      }
+    }, {
+      key: _$$_REQUIRE(_dependencyMap[5], "./internals/EventTargetInternals").INTERNAL_DISPATCH_METHOD_KEY,
+      value: function value(event) {
+        dispatch(this, event);
+      }
+    }]);
+  }();
+  function validateCallback(callback, methodName) {
+    if (typeof callback !== 'function' && typeof callback !== 'object') {
+      throw new TypeError(`Failed to execute '${methodName}' on 'EventTarget': parameter 2 is not of type 'Object'.`);
+    }
+  }
+  function getDefaultPassiveValue(type, eventTarget) {
+    return false;
+  }
+  function dispatch(eventTarget, event) {
+    setEventDispatchFlag(event, true);
+    var eventPath = getEventPath(eventTarget, event);
+    (0, _$$_REQUIRE(_dependencyMap[4], "./internals/EventInternals").setComposedPath)(event, eventPath);
+    (0, _$$_REQUIRE(_dependencyMap[4], "./internals/EventInternals").setTarget)(event, eventTarget);
+    for (var i = eventPath.length - 1; i >= 0; i--) {
+      if ((0, _$$_REQUIRE(_dependencyMap[4], "./internals/EventInternals").getStopPropagationFlag)(event)) {
+        break;
+      }
+      var target = eventPath[i];
+      (0, _$$_REQUIRE(_dependencyMap[4], "./internals/EventInternals").setEventPhase)(event, target === eventTarget ? _Event.default.AT_TARGET : _Event.default.CAPTURING_PHASE);
+      invoke(target, event, _Event.default.CAPTURING_PHASE);
+    }
+    for (var _target of eventPath) {
+      if ((0, _$$_REQUIRE(_dependencyMap[4], "./internals/EventInternals").getStopPropagationFlag)(event)) {
+        break;
+      }
+      if (!event.bubbles && _target !== eventTarget) {
+        break;
+      }
+      (0, _$$_REQUIRE(_dependencyMap[4], "./internals/EventInternals").setEventPhase)(event, _target === eventTarget ? _Event.default.AT_TARGET : _Event.default.BUBBLING_PHASE);
+      invoke(_target, event, _Event.default.BUBBLING_PHASE);
+    }
+    (0, _$$_REQUIRE(_dependencyMap[4], "./internals/EventInternals").setEventPhase)(event, _Event.default.NONE);
+    (0, _$$_REQUIRE(_dependencyMap[4], "./internals/EventInternals").setCurrentTarget)(event, null);
+    (0, _$$_REQUIRE(_dependencyMap[4], "./internals/EventInternals").setComposedPath)(event, []);
+    setEventDispatchFlag(event, false);
+    (0, _$$_REQUIRE(_dependencyMap[4], "./internals/EventInternals").setStopImmediatePropagationFlag)(event, false);
+    (0, _$$_REQUIRE(_dependencyMap[4], "./internals/EventInternals").setStopPropagationFlag)(event, false);
+  }
+  function getEventPath(eventTarget, event) {
+    var path = [];
+    var target = eventTarget;
+    while (target != null) {
+      path.push(target);
+      target = target[_$$_REQUIRE(_dependencyMap[5], "./internals/EventTargetInternals").EVENT_TARGET_GET_THE_PARENT_KEY]();
+    }
+    return path;
+  }
+  function invoke(eventTarget, event, eventPhase) {
+    var listenersByType = getListenersForPhase(eventTarget, eventPhase === _Event.default.CAPTURING_PHASE);
+    (0, _$$_REQUIRE(_dependencyMap[4], "./internals/EventInternals").setCurrentTarget)(event, eventTarget);
+    var maybeListeners = listenersByType == null ? void 0 : listenersByType.get(event.type);
+    if (maybeListeners == null) {
+      return;
+    }
+    var listeners = Array.from(maybeListeners.values());
+    (0, _$$_REQUIRE(_dependencyMap[4], "./internals/EventInternals").setCurrentTarget)(event, eventTarget);
+    for (var listener of listeners) {
+      if (listener.removed) {
+        continue;
+      }
+      if (listener.once) {
+        eventTarget.removeEventListener(event.type, listener.callback, eventPhase === _Event.default.CAPTURING_PHASE);
+      }
+      if (listener.passive) {
+        (0, _$$_REQUIRE(_dependencyMap[4], "./internals/EventInternals").setInPassiveListenerFlag)(event, true);
+      }
+      var currentEvent = global.event;
+      global.event = event;
+      var callback = listener.callback;
+      try {
+        if (typeof callback === 'function') {
+          callback.call(eventTarget, event);
+        } else if (typeof callback.handleEvent === 'function') {
+          callback.handleEvent(event);
+        }
+      } catch (error) {
+        console.error(error);
+      }
+      if (listener.passive) {
+        (0, _$$_REQUIRE(_dependencyMap[4], "./internals/EventInternals").setInPassiveListenerFlag)(event, false);
+      }
+      global.event = currentEvent;
+      if ((0, _$$_REQUIRE(_dependencyMap[4], "./internals/EventInternals").getStopImmediatePropagationFlag)(event)) {
+        break;
+      }
+    }
+  }
+  var CAPTURING_LISTENERS_KEY = Symbol('capturingListeners');
+  var BUBBLING_LISTENERS_KEY = Symbol('bubblingListeners');
+  function getListenersForPhase(eventTarget, isCapture) {
+    return isCapture ? eventTarget[CAPTURING_LISTENERS_KEY] : eventTarget[BUBBLING_LISTENERS_KEY];
+  }
+  function setListenersMap(eventTarget, isCapture, listenersMap) {
+    if (isCapture) {
+      eventTarget[CAPTURING_LISTENERS_KEY] = listenersMap;
+    } else {
+      eventTarget[BUBBLING_LISTENERS_KEY] = listenersMap;
+    }
+  }
+  var EVENT_DISPATCH_FLAG = Symbol('Event.dispatch');
+  function getEventDispatchFlag(event) {
+    return event[EVENT_DISPATCH_FLAG];
+  }
+  function setEventDispatchFlag(event, value) {
+    event[EVENT_DISPATCH_FLAG] = value;
+  }
+},228,[1,11,12,226,227,229],"../../node_modules/react-native/src/private/webapis/dom/events/EventTarget.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.INTERNAL_DISPATCH_METHOD_KEY = exports.EVENT_TARGET_GET_THE_PARENT_KEY = void 0;
+  exports.dispatchTrustedEvent = dispatchTrustedEvent;
+  var EVENT_TARGET_GET_THE_PARENT_KEY = exports.EVENT_TARGET_GET_THE_PARENT_KEY = Symbol('EventTarget[get the parent]');
+  var INTERNAL_DISPATCH_METHOD_KEY = exports.INTERNAL_DISPATCH_METHOD_KEY = Symbol('EventTarget[dispatch]');
+  function dispatchTrustedEvent(eventTarget, event) {
+    (0, _$$_REQUIRE(_dependencyMap[0], "./EventInternals").setIsTrusted)(event, true);
+    return eventTarget[INTERNAL_DISPATCH_METHOD_KEY](event);
+  }
+},229,[227],"../../node_modules/react-native/src/private/webapis/dom/events/internals/EventTargetInternals.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var _Event2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../../dom/events/Event"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var MessageEvent = exports.default = /*#__PURE__*/function (_Event) {
+    function MessageEvent(type, options) {
+      var _options$origin, _options$lastEventId;
+      var _this;
+      (0, _classCallCheck2.default)(this, MessageEvent);
+      _this = _callSuper(this, MessageEvent, [type, options]);
+      _this._data = options == null ? void 0 : options.data;
+      _this._origin = String((_options$origin = options == null ? void 0 : options.origin) != null ? _options$origin : '');
+      _this._lastEventId = String((_options$lastEventId = options == null ? void 0 : options.lastEventId) != null ? _options$lastEventId : '');
+      return _this;
+    }
+    (0, _inherits2.default)(MessageEvent, _Event);
+    return (0, _createClass2.default)(MessageEvent, [{
+      key: "data",
+      get: function get() {
+        return this._data;
+      }
+    }, {
+      key: "origin",
+      get: function get() {
+        return this._origin;
+      }
+    }, {
+      key: "lastEventId",
+      get: function get() {
+        return this._lastEventId;
+      }
+    }]);
+  }(_Event2.default);
+},230,[1,11,12,18,20,23,226],"../../node_modules/react-native/src/private/webapis/html/events/MessageEvent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var _Event2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../../dom/events/Event"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var CloseEvent = exports.default = /*#__PURE__*/function (_Event) {
+    function CloseEvent(type, options) {
+      var _this;
+      (0, _classCallCheck2.default)(this, CloseEvent);
+      _this = _callSuper(this, CloseEvent, [type, options]);
+      _this._wasClean = Boolean(options == null ? void 0 : options.wasClean);
+      _this._code = Number(options == null ? void 0 : options.code) || 0;
+      _this._reason = (options == null ? void 0 : options.reason) != null ? String(options.reason) : '';
+      return _this;
+    }
+    (0, _inherits2.default)(CloseEvent, _Event);
+    return (0, _createClass2.default)(CloseEvent, [{
+      key: "wasClean",
+      get: function get() {
+        return this._wasClean;
+      }
+    }, {
+      key: "code",
+      get: function get() {
+        return this._code;
+      }
+    }, {
+      key: "reason",
+      get: function get() {
+        return this._reason;
+      }
+    }]);
+  }(_Event2.default);
+},231,[1,11,12,18,20,23,226],"../../node_modules/react-native/src/private/webapis/websockets/events/CloseEvent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var Blob = /*#__PURE__*/function () {
+    function Blob() {
+      var parts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      var options = arguments.length > 1 ? arguments[1] : undefined;
+      (0, _classCallCheck2.default)(this, Blob);
+      var BlobManager = _$$_REQUIRE(_dependencyMap[3], "./BlobManager").default;
+      this.data = BlobManager.createFromParts(parts, options).data;
+    }
+    return (0, _createClass2.default)(Blob, [{
+      key: "data",
+      get: function get() {
+        if (!this._data) {
+          throw new Error('Blob has been closed and is no longer available');
+        }
+        return this._data;
+      },
+      set: function set(data) {
+        this._data = data;
+      }
+    }, {
+      key: "slice",
+      value: function slice(start, end) {
+        var contentType = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+        var BlobManager = _$$_REQUIRE(_dependencyMap[3], "./BlobManager").default;
+        var _this$data = this.data,
+          offset = _this$data.offset,
+          size = _this$data.size;
+        if (typeof start === 'number') {
+          if (start > size) {
+            start = size;
+          }
+          offset += start;
+          size -= start;
+          if (typeof end === 'number') {
+            if (end < 0) {
+              end = this.size + end;
+            }
+            if (end > this.size) {
+              end = this.size;
+            }
+            size = end - start;
+          }
+        }
+        return BlobManager.createFromOptions({
+          blobId: this.data.blobId,
+          offset: offset,
+          size: size,
+          type: contentType,
+          __collector: this.data.__collector
+        });
+      }
+    }, {
+      key: "close",
+      value: function close() {
+        var BlobManager = _$$_REQUIRE(_dependencyMap[3], "./BlobManager").default;
+        BlobManager.release(this.data.blobId);
+        this.data = null;
+      }
+    }, {
+      key: "size",
+      get: function get() {
+        return this.data.size;
+      }
+    }, {
+      key: "type",
+      get: function get() {
+        return this.data.type || '';
+      }
+    }]);
+  }();
+  var _default = exports.default = Blob;
+},232,[1,11,12,233],"../../node_modules/react-native/Libraries/Blob/Blob.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _NativeBlobModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./NativeBlobModule"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "invariant"));
+  function uuidv4() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+      var r = Math.random() * 16 | 0,
+        v = c == 'x' ? r : r & 0x3 | 0x8;
+      return v.toString(16);
+    });
+  }
+  function createBlobCollector(blobId) {
+    if (global.__blobCollectorProvider == null) {
+      return null;
+    } else {
+      return global.__blobCollectorProvider(blobId);
+    }
+  }
+  var BlobManager = /*#__PURE__*/function () {
+    function BlobManager() {
+      (0, _classCallCheck2.default)(this, BlobManager);
+    }
+    return (0, _createClass2.default)(BlobManager, null, [{
+      key: "createFromParts",
+      value: function createFromParts(parts, options) {
+        (0, _invariant.default)(_NativeBlobModule.default, 'NativeBlobModule is available.');
+        var blobId = uuidv4();
+        var items = parts.map(function (part) {
+          if (part instanceof ArrayBuffer || ArrayBuffer.isView(part)) {
+            throw new Error("Creating blobs from 'ArrayBuffer' and 'ArrayBufferView' are not supported");
+          }
+          if (part instanceof _$$_REQUIRE(_dependencyMap[5], "./Blob").default) {
+            return {
+              data: part.data,
+              type: 'blob'
+            };
+          } else {
+            return {
+              data: String(part),
+              type: 'string'
+            };
+          }
+        });
+        var size = items.reduce(function (acc, curr) {
+          if (curr.type === 'string') {
+            return acc + global.unescape(encodeURI(curr.data)).length;
+          } else {
+            return acc + curr.data.size;
+          }
+        }, 0);
+        _NativeBlobModule.default.createFromParts(items, blobId);
+        return BlobManager.createFromOptions({
+          blobId: blobId,
+          offset: 0,
+          size: size,
+          type: options ? options.type : '',
+          lastModified: options ? options.lastModified : Date.now()
+        });
+      }
+    }, {
+      key: "createFromOptions",
+      value: function createFromOptions(options) {
+        _$$_REQUIRE(_dependencyMap[6], "./BlobRegistry").register(options.blobId);
+        return Object.assign(Object.create(_$$_REQUIRE(_dependencyMap[5], "./Blob").default.prototype), {
+          data: options.__collector == null ? Object.assign({}, options, {
+            __collector: createBlobCollector(options.blobId)
+          }) : options
+        });
+      }
+    }, {
+      key: "release",
+      value: function release(blobId) {
+        (0, _invariant.default)(_NativeBlobModule.default, 'NativeBlobModule is available.');
+        _$$_REQUIRE(_dependencyMap[6], "./BlobRegistry").unregister(blobId);
+        if (_$$_REQUIRE(_dependencyMap[6], "./BlobRegistry").has(blobId)) {
+          return;
+        }
+        _NativeBlobModule.default.release(blobId);
+      }
+    }, {
+      key: "addNetworkingHandler",
+      value: function addNetworkingHandler() {
+        (0, _invariant.default)(_NativeBlobModule.default, 'NativeBlobModule is available.');
+        _NativeBlobModule.default.addNetworkingHandler();
+      }
+    }, {
+      key: "addWebSocketHandler",
+      value: function addWebSocketHandler(socketId) {
+        (0, _invariant.default)(_NativeBlobModule.default, 'NativeBlobModule is available.');
+        _NativeBlobModule.default.addWebSocketHandler(socketId);
+      }
+    }, {
+      key: "removeWebSocketHandler",
+      value: function removeWebSocketHandler(socketId) {
+        (0, _invariant.default)(_NativeBlobModule.default, 'NativeBlobModule is available.');
+        _NativeBlobModule.default.removeWebSocketHandler(socketId);
+      }
+    }, {
+      key: "sendOverSocket",
+      value: function sendOverSocket(blob, socketId) {
+        (0, _invariant.default)(_NativeBlobModule.default, 'NativeBlobModule is available.');
+        _NativeBlobModule.default.sendOverSocket(blob.data, socketId);
+      }
+    }]);
+  }();
+  BlobManager.isAvailable = !!_NativeBlobModule.default;
+  var _default = exports.default = BlobManager;
+},233,[1,11,12,234,32,232,236],"../../node_modules/react-native/Libraries/Blob/BlobManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeBlobModule = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativeBlobModule"));
+  Object.keys(_NativeBlobModule).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeBlobModule[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeBlobModule[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeBlobModule.default;
+},234,[235],"../../node_modules/react-native/Libraries/Blob/NativeBlobModule.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var NativeModule = TurboModuleRegistry.get('BlobModule');
+  var constants = null;
+  var NativeBlobModule = null;
+  if (NativeModule != null) {
+    NativeBlobModule = {
+      getConstants: function getConstants() {
+        if (constants == null) {
+          constants = NativeModule.getConstants();
+        }
+        return constants;
+      },
+      addNetworkingHandler: function addNetworkingHandler() {
+        NativeModule.addNetworkingHandler();
+      },
+      addWebSocketHandler: function addWebSocketHandler(id) {
+        NativeModule.addWebSocketHandler(id);
+      },
+      removeWebSocketHandler: function removeWebSocketHandler(id) {
+        NativeModule.removeWebSocketHandler(id);
+      },
+      sendOverSocket: function sendOverSocket(blob, socketID) {
+        NativeModule.sendOverSocket(blob, socketID);
+      },
+      createFromParts: function createFromParts(parts, withId) {
+        NativeModule.createFromParts(parts, withId);
+      },
+      release: function release(blobId) {
+        NativeModule.release(blobId);
+      }
+    };
+  }
+  var _default = exports.default = NativeBlobModule;
+},235,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeBlobModule.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.unregister = exports.register = exports.has = void 0;
+  var registry = new Map();
+  var register = exports.register = function register(id) {
+    var used = registry.get(id);
+    if (used != null) {
+      registry.set(id, used + 1);
+    } else {
+      registry.set(id, 1);
+    }
+  };
+  var unregister = exports.unregister = function unregister(id) {
+    var used = registry.get(id);
+    if (used != null) {
+      if (used <= 1) {
+        registry.delete(id);
+      } else {
+        registry.set(id, used - 1);
+      }
+    }
+  };
+  var has = exports.has = function has(id) {
+    return registry.get(id) || false;
+  };
+},236,[],"../../node_modules/react-native/Libraries/Blob/BlobRegistry.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  function binaryToBase64(data) {
+    if (data instanceof ArrayBuffer) {
+      data = new Uint8Array(data);
+    }
+    if (data instanceof Uint8Array) {
+      return _$$_REQUIRE(_dependencyMap[0], "base64-js").fromByteArray(data);
+    }
+    if (!ArrayBuffer.isView(data)) {
+      throw new Error('data must be ArrayBuffer or typed array');
+    }
+    var _ref = data,
+      buffer = _ref.buffer,
+      byteOffset = _ref.byteOffset,
+      byteLength = _ref.byteLength;
+    return _$$_REQUIRE(_dependencyMap[0], "base64-js").fromByteArray(new Uint8Array(buffer, byteOffset, byteLength));
+  }
+  var _default = exports.default = binaryToBase64;
+},237,[238],"../../node_modules/react-native/Libraries/Utilities/binaryToBase64.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  exports.byteLength = byteLength;
+  exports.toByteArray = toByteArray;
+  exports.fromByteArray = fromByteArray;
+  var lookup = [];
+  var revLookup = [];
+  var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
+  var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+  for (var i = 0, len = code.length; i < len; ++i) {
+    lookup[i] = code[i];
+    revLookup[code.charCodeAt(i)] = i;
+  }
+
+  // Support decoding URL-safe base64 strings, as Node.js does.
+  // See: https://en.wikipedia.org/wiki/Base64#URL_applications
+  revLookup['-'.charCodeAt(0)] = 62;
+  revLookup['_'.charCodeAt(0)] = 63;
+  function getLens(b64) {
+    var len = b64.length;
+    if (len % 4 > 0) {
+      throw new Error('Invalid string. Length must be a multiple of 4');
+    }
+
+    // Trim off extra bytes after placeholder bytes are found
+    // See: https://github.com/beatgammit/base64-js/issues/42
+    var validLen = b64.indexOf('=');
+    if (validLen === -1) validLen = len;
+    var placeHoldersLen = validLen === len ? 0 : 4 - validLen % 4;
+    return [validLen, placeHoldersLen];
+  }
+
+  // base64 is 4/3 + up to two characters of the original data
+  function byteLength(b64) {
+    var lens = getLens(b64);
+    var validLen = lens[0];
+    var placeHoldersLen = lens[1];
+    return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+  }
+  function _byteLength(b64, validLen, placeHoldersLen) {
+    return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+  }
+  function toByteArray(b64) {
+    var tmp;
+    var lens = getLens(b64);
+    var validLen = lens[0];
+    var placeHoldersLen = lens[1];
+    var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+    var curByte = 0;
+
+    // if there are placeholders, only get up to the last complete 4 chars
+    var len = placeHoldersLen > 0 ? validLen - 4 : validLen;
+    var i;
+    for (i = 0; i < len; i += 4) {
+      tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];
+      arr[curByte++] = tmp >> 16 & 0xFF;
+      arr[curByte++] = tmp >> 8 & 0xFF;
+      arr[curByte++] = tmp & 0xFF;
+    }
+    if (placeHoldersLen === 2) {
+      tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;
+      arr[curByte++] = tmp & 0xFF;
+    }
+    if (placeHoldersLen === 1) {
+      tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2;
+      arr[curByte++] = tmp >> 8 & 0xFF;
+      arr[curByte++] = tmp & 0xFF;
+    }
+    return arr;
+  }
+  function tripletToBase64(num) {
+    return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F];
+  }
+  function encodeChunk(uint8, start, end) {
+    var tmp;
+    var output = [];
+    for (var i = start; i < end; i += 3) {
+      tmp = (uint8[i] << 16 & 0xFF0000) + (uint8[i + 1] << 8 & 0xFF00) + (uint8[i + 2] & 0xFF);
+      output.push(tripletToBase64(tmp));
+    }
+    return output.join('');
+  }
+  function fromByteArray(uint8) {
+    var tmp;
+    var len = uint8.length;
+    var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
+    var parts = [];
+    var maxChunkLength = 16383; // must be multiple of 3
+
+    // go through the array every three bytes, we'll deal with trailing stuff later
+    for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+      parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));
+    }
+
+    // pad the end with zeros, but make sure to not forget the extra bytes
+    if (extraBytes === 1) {
+      tmp = uint8[len - 1];
+      parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 0x3F] + '==');
+    } else if (extraBytes === 2) {
+      tmp = (uint8[len - 2] << 8) + uint8[len - 1];
+      parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 0x3F] + lookup[tmp << 2 & 0x3F] + '=');
+    }
+    return parts.join('');
+  }
+},238,[],"../../node_modules/base64-js/index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeWebSocketModule = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativeWebSocketModule"));
+  Object.keys(_NativeWebSocketModule).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeWebSocketModule[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeWebSocketModule[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeWebSocketModule.default;
+},239,[240],"../../node_modules/react-native/Libraries/WebSocket/NativeWebSocketModule.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.getEnforcing('WebSocketModule');
+},240,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeWebSocketModule.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.getEventHandlerAttribute = getEventHandlerAttribute;
+  exports.setEventHandlerAttribute = setEventHandlerAttribute;
+  var EVENT_HANDLER_CONTENT_ATTRIBUTE_MAP_KEY = Symbol('eventHandlerAttributeMap');
+  function getEventHandlerAttributeMap(target) {
+    return target[EVENT_HANDLER_CONTENT_ATTRIBUTE_MAP_KEY];
+  }
+  function setEventHandlerAttributeMap(target, map) {
+    target[EVENT_HANDLER_CONTENT_ATTRIBUTE_MAP_KEY] = map;
+  }
+  function getEventHandlerAttribute(target, type) {
+    var _getEventHandlerAttri;
+    var listener = (_getEventHandlerAttri = getEventHandlerAttributeMap(target)) == null ? void 0 : _getEventHandlerAttri.get(type);
+    return listener != null ? listener.handleEvent : null;
+  }
+  function setEventHandlerAttribute(target, type, callback) {
+    var map = getEventHandlerAttributeMap(target);
+    if (map != null) {
+      var currentListener = map.get(type);
+      if (currentListener) {
+        target.removeEventListener(type, currentListener);
+        map.delete(type);
+      }
+    }
+    if (callback != null && (typeof callback === 'function' || typeof callback === 'object')) {
+      var listener = {
+        handleEvent: callback
+      };
+      try {
+        target.addEventListener(type, listener);
+        if (map == null) {
+          map = new Map();
+          setEventHandlerAttributeMap(target, map);
+        }
+        map.set(type, listener);
+      } catch (e) {}
+    }
+    if (map != null && map.size === 0) {
+      setEventHandlerAttributeMap(target, null);
+    }
+  }
+},241,[],"../../node_modules/react-native/src/private/webapis/dom/events/EventHandlerAttributes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _RCTDeviceEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./RCTDeviceEventEmitter"));
+  var RCTNativeAppEventEmitter = _RCTDeviceEventEmitter.default;
+  var _default = exports.default = RCTNativeAppEventEmitter;
+},242,[1,17],"../../node_modules/react-native/Libraries/EventEmitter/RCTNativeAppEventEmitter.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  if (global.RN$useAlwaysAvailableJSErrorHandling !== true) {
+    var ExceptionsManager = _$$_REQUIRE(_dependencyMap[0], "./ExceptionsManager").default;
+    ExceptionsManager.installConsoleErrorReporter();
+    if (!global.__fbDisableExceptionsManager) {
+      var handleError = function handleError(e, isFatal) {
+        try {
+          ExceptionsManager.handleException(e, isFatal);
+        } catch (ee) {
+          console.log('Failed to print error: ', ee.message);
+          throw e;
+        }
+      };
+      var ErrorUtils = _$$_REQUIRE(_dependencyMap[1], "../vendor/core/ErrorUtils").default;
+      ErrorUtils.setGlobalHandler(handleError);
+    }
+  }
+},243,[174,49],"../../node_modules/react-native/Libraries/Core/setUpErrorHandling.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var hasNativeGenerator;
+  try {
+    hasNativeGenerator = _$$_REQUIRE(_dependencyMap[0], "../Utilities/FeatureDetection").hasNativeConstructor(function* () {}, 'GeneratorFunction');
+  } catch (_unused) {
+    hasNativeGenerator = false;
+  }
+  if (!hasNativeGenerator) {
+    _$$_REQUIRE(_dependencyMap[1], "../Utilities/PolyfillFunctions").polyfillGlobal('regeneratorRuntime', function () {
+      delete global.regeneratorRuntime;
+      return _$$_REQUIRE(_dependencyMap[2], "regenerator-runtime/runtime");
+    });
+  }
+},244,[245,114,246],"../../node_modules/react-native/Libraries/Core/setUpRegeneratorRuntime.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.hasNativeConstructor = hasNativeConstructor;
+  exports.isNativeFunction = isNativeFunction;
+  function isNativeFunction(f) {
+    return typeof f === 'function' && f.toString().indexOf('[native code]') > -1;
+  }
+  function hasNativeConstructor(o, expectedName) {
+    var con = Object.getPrototypeOf(o).constructor;
+    return con.name === expectedName && isNativeFunction(con);
+  }
+},245,[],"../../node_modules/react-native/Libraries/Utilities/FeatureDetection.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  /**
+   * Copyright (c) 2014-present, Facebook, Inc.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+
+  var runtime = function (exports) {
+    "use strict";
+
+    var Op = Object.prototype;
+    var hasOwn = Op.hasOwnProperty;
+    var defineProperty = Object.defineProperty || function (obj, key, desc) {
+      obj[key] = desc.value;
+    };
+    var undefined; // More compressible than void 0.
+    var $Symbol = typeof Symbol === "function" ? Symbol : {};
+    var iteratorSymbol = $Symbol.iterator || "@@iterator";
+    var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
+    var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+    function define(obj, key, value) {
+      Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+      return obj[key];
+    }
+    try {
+      // IE 8 has a broken Object.defineProperty that only works on DOM objects.
+      define({}, "");
+    } catch (err) {
+      define = function define(obj, key, value) {
+        return obj[key] = value;
+      };
+    }
+    function wrap(innerFn, outerFn, self, tryLocsList) {
+      // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
+      var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
+      var generator = Object.create(protoGenerator.prototype);
+      var context = new Context(tryLocsList || []);
+
+      // The ._invoke method unifies the implementations of the .next,
+      // .throw, and .return methods.
+      defineProperty(generator, "_invoke", {
+        value: makeInvokeMethod(innerFn, self, context)
+      });
+      return generator;
+    }
+    exports.wrap = wrap;
+
+    // Try/catch helper to minimize deoptimizations. Returns a completion
+    // record like context.tryEntries[i].completion. This interface could
+    // have been (and was previously) designed to take a closure to be
+    // invoked without arguments, but in all the cases we care about we
+    // already have an existing method we want to call, so there's no need
+    // to create a new function object. We can even get away with assuming
+    // the method takes exactly one argument, since that happens to be true
+    // in every case, so we don't have to touch the arguments object. The
+    // only additional allocation required is the completion record, which
+    // has a stable shape and so hopefully should be cheap to allocate.
+    function tryCatch(fn, obj, arg) {
+      try {
+        return {
+          type: "normal",
+          arg: fn.call(obj, arg)
+        };
+      } catch (err) {
+        return {
+          type: "throw",
+          arg: err
+        };
+      }
+    }
+    var GenStateSuspendedStart = "suspendedStart";
+    var GenStateSuspendedYield = "suspendedYield";
+    var GenStateExecuting = "executing";
+    var GenStateCompleted = "completed";
+
+    // Returning this object from the innerFn has the same effect as
+    // breaking out of the dispatch switch statement.
+    var ContinueSentinel = {};
+
+    // Dummy constructor functions that we use as the .constructor and
+    // .constructor.prototype properties for functions that return Generator
+    // objects. For full spec compliance, you may wish to configure your
+    // minifier not to mangle the names of these two functions.
+    function Generator() {}
+    function GeneratorFunction() {}
+    function GeneratorFunctionPrototype() {}
+
+    // This is a polyfill for %IteratorPrototype% for environments that
+    // don't natively support it.
+    var IteratorPrototype = {};
+    define(IteratorPrototype, iteratorSymbol, function () {
+      return this;
+    });
+    var getProto = Object.getPrototypeOf;
+    var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+    if (NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
+      // This environment has a native %IteratorPrototype%; use it instead
+      // of the polyfill.
+      IteratorPrototype = NativeIteratorPrototype;
+    }
+    var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+    GeneratorFunction.prototype = GeneratorFunctionPrototype;
+    defineProperty(Gp, "constructor", {
+      value: GeneratorFunctionPrototype,
+      configurable: true
+    });
+    defineProperty(GeneratorFunctionPrototype, "constructor", {
+      value: GeneratorFunction,
+      configurable: true
+    });
+    GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction");
+
+    // Helper for defining the .next, .throw, and .return methods of the
+    // Iterator interface in terms of a single ._invoke method.
+    function defineIteratorMethods(prototype) {
+      ["next", "throw", "return"].forEach(function (method) {
+        define(prototype, method, function (arg) {
+          return this._invoke(method, arg);
+        });
+      });
+    }
+    exports.isGeneratorFunction = function (genFun) {
+      var ctor = typeof genFun === "function" && genFun.constructor;
+      return ctor ? ctor === GeneratorFunction ||
+      // For the native GeneratorFunction constructor, the best we can
+      // do is to check its .name property.
+      (ctor.displayName || ctor.name) === "GeneratorFunction" : false;
+    };
+    exports.mark = function (genFun) {
+      if (Object.setPrototypeOf) {
+        Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
+      } else {
+        genFun.__proto__ = GeneratorFunctionPrototype;
+        define(genFun, toStringTagSymbol, "GeneratorFunction");
+      }
+      genFun.prototype = Object.create(Gp);
+      return genFun;
+    };
+
+    // Within the body of any async function, `await x` is transformed to
+    // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
+    // `hasOwn.call(value, "__await")` to determine if the yielded value is
+    // meant to be awaited.
+    exports.awrap = function (arg) {
+      return {
+        __await: arg
+      };
+    };
+    function AsyncIterator(generator, PromiseImpl) {
+      function invoke(method, arg, resolve, reject) {
+        var record = tryCatch(generator[method], generator, arg);
+        if (record.type === "throw") {
+          reject(record.arg);
+        } else {
+          var result = record.arg;
+          var value = result.value;
+          if (value && typeof value === "object" && hasOwn.call(value, "__await")) {
+            return PromiseImpl.resolve(value.__await).then(function (value) {
+              invoke("next", value, resolve, reject);
+            }, function (err) {
+              invoke("throw", err, resolve, reject);
+            });
+          }
+          return PromiseImpl.resolve(value).then(function (unwrapped) {
+            // When a yielded Promise is resolved, its final value becomes
+            // the .value of the Promise<{value,done}> result for the
+            // current iteration.
+            result.value = unwrapped;
+            resolve(result);
+          }, function (error) {
+            // If a rejected Promise was yielded, throw the rejection back
+            // into the async generator function so it can be handled there.
+            return invoke("throw", error, resolve, reject);
+          });
+        }
+      }
+      var previousPromise;
+      function enqueue(method, arg) {
+        function callInvokeWithMethodAndArg() {
+          return new PromiseImpl(function (resolve, reject) {
+            invoke(method, arg, resolve, reject);
+          });
+        }
+        return previousPromise =
+        // If enqueue has been called before, then we want to wait until
+        // all previous Promises have been resolved before calling invoke,
+        // so that results are always delivered in the correct order. If
+        // enqueue has not been called before, then it is important to
+        // call invoke immediately, without waiting on a callback to fire,
+        // so that the async generator function has the opportunity to do
+        // any necessary setup in a predictable way. This predictability
+        // is why the Promise constructor synchronously invokes its
+        // executor callback, and why async functions synchronously
+        // execute code before the first await. Since we implement simple
+        // async functions in terms of async generators, it is especially
+        // important to get this right, even though it requires care.
+        previousPromise ? previousPromise.then(callInvokeWithMethodAndArg,
+        // Avoid propagating failures to Promises returned by later
+        // invocations of the iterator.
+        callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+      }
+
+      // Define the unified helper method that is used to implement .next,
+      // .throw, and .return (see defineIteratorMethods).
+      defineProperty(this, "_invoke", {
+        value: enqueue
+      });
+    }
+    defineIteratorMethods(AsyncIterator.prototype);
+    define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
+      return this;
+    });
+    exports.AsyncIterator = AsyncIterator;
+
+    // Note that simple async functions are implemented on top of
+    // AsyncIterator objects; they just return a Promise for the value of
+    // the final result produced by the iterator.
+    exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+      if (PromiseImpl === void 0) PromiseImpl = Promise;
+      var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
+      return exports.isGeneratorFunction(outerFn) ? iter // If outerFn is a generator, return the full iterator.
+      : iter.next().then(function (result) {
+        return result.done ? result.value : iter.next();
+      });
+    };
+    function makeInvokeMethod(innerFn, self, context) {
+      var state = GenStateSuspendedStart;
+      return function invoke(method, arg) {
+        if (state === GenStateExecuting) {
+          throw new Error("Generator is already running");
+        }
+        if (state === GenStateCompleted) {
+          if (method === "throw") {
+            throw arg;
+          }
+
+          // Be forgiving, per 25.3.3.3.3 of the spec:
+          // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
+          return doneResult();
+        }
+        context.method = method;
+        context.arg = arg;
+        while (true) {
+          var delegate = context.delegate;
+          if (delegate) {
+            var delegateResult = maybeInvokeDelegate(delegate, context);
+            if (delegateResult) {
+              if (delegateResult === ContinueSentinel) continue;
+              return delegateResult;
+            }
+          }
+          if (context.method === "next") {
+            // Setting context._sent for legacy support of Babel's
+            // function.sent implementation.
+            context.sent = context._sent = context.arg;
+          } else if (context.method === "throw") {
+            if (state === GenStateSuspendedStart) {
+              state = GenStateCompleted;
+              throw context.arg;
+            }
+            context.dispatchException(context.arg);
+          } else if (context.method === "return") {
+            context.abrupt("return", context.arg);
+          }
+          state = GenStateExecuting;
+          var record = tryCatch(innerFn, self, context);
+          if (record.type === "normal") {
+            // If an exception is thrown from innerFn, we leave state ===
+            // GenStateExecuting and loop back for another invocation.
+            state = context.done ? GenStateCompleted : GenStateSuspendedYield;
+            if (record.arg === ContinueSentinel) {
+              continue;
+            }
+            return {
+              value: record.arg,
+              done: context.done
+            };
+          } else if (record.type === "throw") {
+            state = GenStateCompleted;
+            // Dispatch the exception by looping back around to the
+            // context.dispatchException(context.arg) call above.
+            context.method = "throw";
+            context.arg = record.arg;
+          }
+        }
+      };
+    }
+
+    // Call delegate.iterator[context.method](context.arg) and handle the
+    // result, either by returning a { value, done } result from the
+    // delegate iterator, or by modifying context.method and context.arg,
+    // setting context.delegate to null, and returning the ContinueSentinel.
+    function maybeInvokeDelegate(delegate, context) {
+      var methodName = context.method;
+      var method = delegate.iterator[methodName];
+      if (method === undefined) {
+        // A .throw or .return when the delegate iterator has no .throw
+        // method, or a missing .next mehtod, always terminate the
+        // yield* loop.
+        context.delegate = null;
+
+        // Note: ["return"] must be used for ES3 parsing compatibility.
+        if (methodName === "throw" && delegate.iterator["return"]) {
+          // If the delegate iterator has a return method, give it a
+          // chance to clean up.
+          context.method = "return";
+          context.arg = undefined;
+          maybeInvokeDelegate(delegate, context);
+          if (context.method === "throw") {
+            // If maybeInvokeDelegate(context) changed context.method from
+            // "return" to "throw", let that override the TypeError below.
+            return ContinueSentinel;
+          }
+        }
+        if (methodName !== "return") {
+          context.method = "throw";
+          context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method");
+        }
+        return ContinueSentinel;
+      }
+      var record = tryCatch(method, delegate.iterator, context.arg);
+      if (record.type === "throw") {
+        context.method = "throw";
+        context.arg = record.arg;
+        context.delegate = null;
+        return ContinueSentinel;
+      }
+      var info = record.arg;
+      if (!info) {
+        context.method = "throw";
+        context.arg = new TypeError("iterator result is not an object");
+        context.delegate = null;
+        return ContinueSentinel;
+      }
+      if (info.done) {
+        // Assign the result of the finished delegate to the temporary
+        // variable specified by delegate.resultName (see delegateYield).
+        context[delegate.resultName] = info.value;
+
+        // Resume execution at the desired location (see delegateYield).
+        context.next = delegate.nextLoc;
+
+        // If context.method was "throw" but the delegate handled the
+        // exception, let the outer generator proceed normally. If
+        // context.method was "next", forget context.arg since it has been
+        // "consumed" by the delegate iterator. If context.method was
+        // "return", allow the original .return call to continue in the
+        // outer generator.
+        if (context.method !== "return") {
+          context.method = "next";
+          context.arg = undefined;
+        }
+      } else {
+        // Re-yield the result returned by the delegate method.
+        return info;
+      }
+
+      // The delegate iterator is finished, so forget it and continue with
+      // the outer generator.
+      context.delegate = null;
+      return ContinueSentinel;
+    }
+
+    // Define Generator.prototype.{next,throw,return} in terms of the
+    // unified ._invoke helper method.
+    defineIteratorMethods(Gp);
+    define(Gp, toStringTagSymbol, "Generator");
+
+    // A Generator should always return itself as the iterator object when the
+    // @@iterator function is called on it. Some browsers' implementations of the
+    // iterator prototype chain incorrectly implement this, causing the Generator
+    // object to not be returned from this call. This ensures that doesn't happen.
+    // See https://github.com/facebook/regenerator/issues/274 for more details.
+    define(Gp, iteratorSymbol, function () {
+      return this;
+    });
+    define(Gp, "toString", function () {
+      return "[object Generator]";
+    });
+    function pushTryEntry(locs) {
+      var entry = {
+        tryLoc: locs[0]
+      };
+      if (1 in locs) {
+        entry.catchLoc = locs[1];
+      }
+      if (2 in locs) {
+        entry.finallyLoc = locs[2];
+        entry.afterLoc = locs[3];
+      }
+      this.tryEntries.push(entry);
+    }
+    function resetTryEntry(entry) {
+      var record = entry.completion || {};
+      record.type = "normal";
+      delete record.arg;
+      entry.completion = record;
+    }
+    function Context(tryLocsList) {
+      // The root entry object (effectively a try statement without a catch
+      // or a finally block) gives us a place to store values thrown from
+      // locations where there is no enclosing try statement.
+      this.tryEntries = [{
+        tryLoc: "root"
+      }];
+      tryLocsList.forEach(pushTryEntry, this);
+      this.reset(true);
+    }
+    exports.keys = function (val) {
+      var object = Object(val);
+      var keys = [];
+      for (var key in object) {
+        keys.push(key);
+      }
+      keys.reverse();
+
+      // Rather than returning an object with a next method, we keep
+      // things simple and return the next function itself.
+      return function next() {
+        while (keys.length) {
+          var key = keys.pop();
+          if (key in object) {
+            next.value = key;
+            next.done = false;
+            return next;
+          }
+        }
+
+        // To avoid creating an additional object, we just hang the .value
+        // and .done properties off the next function object itself. This
+        // also ensures that the minifier will not anonymize the function.
+        next.done = true;
+        return next;
+      };
+    };
+    function values(iterable) {
+      if (iterable) {
+        var iteratorMethod = iterable[iteratorSymbol];
+        if (iteratorMethod) {
+          return iteratorMethod.call(iterable);
+        }
+        if (typeof iterable.next === "function") {
+          return iterable;
+        }
+        if (!isNaN(iterable.length)) {
+          var i = -1,
+            next = function next() {
+              while (++i < iterable.length) {
+                if (hasOwn.call(iterable, i)) {
+                  next.value = iterable[i];
+                  next.done = false;
+                  return next;
+                }
+              }
+              next.value = undefined;
+              next.done = true;
+              return next;
+            };
+          return next.next = next;
+        }
+      }
+
+      // Return an iterator with no values.
+      return {
+        next: doneResult
+      };
+    }
+    exports.values = values;
+    function doneResult() {
+      return {
+        value: undefined,
+        done: true
+      };
+    }
+    Context.prototype = {
+      constructor: Context,
+      reset: function reset(skipTempReset) {
+        this.prev = 0;
+        this.next = 0;
+        // Resetting context._sent for legacy support of Babel's
+        // function.sent implementation.
+        this.sent = this._sent = undefined;
+        this.done = false;
+        this.delegate = null;
+        this.method = "next";
+        this.arg = undefined;
+        this.tryEntries.forEach(resetTryEntry);
+        if (!skipTempReset) {
+          for (var name in this) {
+            // Not sure about the optimal order of these conditions:
+            if (name.charAt(0) === "t" && hasOwn.call(this, name) && !isNaN(+name.slice(1))) {
+              this[name] = undefined;
+            }
+          }
+        }
+      },
+      stop: function stop() {
+        this.done = true;
+        var rootEntry = this.tryEntries[0];
+        var rootRecord = rootEntry.completion;
+        if (rootRecord.type === "throw") {
+          throw rootRecord.arg;
+        }
+        return this.rval;
+      },
+      dispatchException: function dispatchException(exception) {
+        if (this.done) {
+          throw exception;
+        }
+        var context = this;
+        function handle(loc, caught) {
+          record.type = "throw";
+          record.arg = exception;
+          context.next = loc;
+          if (caught) {
+            // If the dispatched exception was caught by a catch block,
+            // then let that catch block handle the exception normally.
+            context.method = "next";
+            context.arg = undefined;
+          }
+          return !!caught;
+        }
+        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+          var entry = this.tryEntries[i];
+          var record = entry.completion;
+          if (entry.tryLoc === "root") {
+            // Exception thrown outside of any try block that could handle
+            // it, so set the completion value of the entire function to
+            // throw the exception.
+            return handle("end");
+          }
+          if (entry.tryLoc <= this.prev) {
+            var hasCatch = hasOwn.call(entry, "catchLoc");
+            var hasFinally = hasOwn.call(entry, "finallyLoc");
+            if (hasCatch && hasFinally) {
+              if (this.prev < entry.catchLoc) {
+                return handle(entry.catchLoc, true);
+              } else if (this.prev < entry.finallyLoc) {
+                return handle(entry.finallyLoc);
+              }
+            } else if (hasCatch) {
+              if (this.prev < entry.catchLoc) {
+                return handle(entry.catchLoc, true);
+              }
+            } else if (hasFinally) {
+              if (this.prev < entry.finallyLoc) {
+                return handle(entry.finallyLoc);
+              }
+            } else {
+              throw new Error("try statement without catch or finally");
+            }
+          }
+        }
+      },
+      abrupt: function abrupt(type, arg) {
+        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+          var entry = this.tryEntries[i];
+          if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+            var finallyEntry = entry;
+            break;
+          }
+        }
+        if (finallyEntry && (type === "break" || type === "continue") && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) {
+          // Ignore the finally entry if control is not jumping to a
+          // location outside the try/catch block.
+          finallyEntry = null;
+        }
+        var record = finallyEntry ? finallyEntry.completion : {};
+        record.type = type;
+        record.arg = arg;
+        if (finallyEntry) {
+          this.method = "next";
+          this.next = finallyEntry.finallyLoc;
+          return ContinueSentinel;
+        }
+        return this.complete(record);
+      },
+      complete: function complete(record, afterLoc) {
+        if (record.type === "throw") {
+          throw record.arg;
+        }
+        if (record.type === "break" || record.type === "continue") {
+          this.next = record.arg;
+        } else if (record.type === "return") {
+          this.rval = this.arg = record.arg;
+          this.method = "return";
+          this.next = "end";
+        } else if (record.type === "normal" && afterLoc) {
+          this.next = afterLoc;
+        }
+        return ContinueSentinel;
+      },
+      finish: function finish(finallyLoc) {
+        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+          var entry = this.tryEntries[i];
+          if (entry.finallyLoc === finallyLoc) {
+            this.complete(entry.completion, entry.afterLoc);
+            resetTryEntry(entry);
+            return ContinueSentinel;
+          }
+        }
+      },
+      "catch": function _catch(tryLoc) {
+        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+          var entry = this.tryEntries[i];
+          if (entry.tryLoc === tryLoc) {
+            var record = entry.completion;
+            if (record.type === "throw") {
+              var thrown = record.arg;
+              resetTryEntry(entry);
+            }
+            return thrown;
+          }
+        }
+
+        // The context.catch method must only be called with a location
+        // argument that corresponds to a known catch block.
+        throw new Error("illegal catch attempt");
+      },
+      delegateYield: function delegateYield(iterable, resultName, nextLoc) {
+        this.delegate = {
+          iterator: values(iterable),
+          resultName: resultName,
+          nextLoc: nextLoc
+        };
+        if (this.method === "next") {
+          // Deliberately forget the last sent value so that we don't
+          // accidentally pass it on to the delegate.
+          this.arg = undefined;
+        }
+        return ContinueSentinel;
+      }
+    };
+
+    // Regardless of whether this script is executing as a CommonJS module
+    // or not, return the runtime object so that we can declare the variable
+    // regeneratorRuntime in the outer scope, which allows this module to be
+    // injected easily by `bin/regenerator --include-runtime script.js`.
+    return exports;
+  }(
+  // If this script is executing as a CommonJS module, use module.exports
+  // as the regeneratorRuntime namespace. Otherwise create a new empty
+  // object. Either way, the resulting object will be used to initialize
+  // the regeneratorRuntime variable at the top of this file.
+  typeof module === "object" ? module.exports : {});
+  try {
+    regeneratorRuntime = runtime;
+  } catch (accidentalStrictMode) {
+    // This module should not be running in strict mode, so the above
+    // assignment should always work unless something is misconfigured. Just
+    // in case runtime.js accidentally runs in strict mode, in modern engines
+    // we can explicitly access globalThis. In older engines we can escape
+    // strict mode using a global Function call. This could conceivably fail
+    // if a Content Security Policy forbids using Function, but in that case
+    // the proper solution is to fix the accidental strict mode problem. If
+    // you've misconfigured your bundler to force strict mode and applied a
+    // CSP to forbid Function, and you're not willing to fix either of those
+    // problems, please detail your unique predicament in a GitHub issue.
+    if (typeof globalThis === "object") {
+      globalThis.regeneratorRuntime = runtime;
+    } else {
+      Function("r", "regeneratorRuntime = r")(runtime);
+    }
+  }
+},246,[],"../../node_modules/regenerator-runtime/runtime.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions").polyfillGlobal('XMLHttpRequest', function () {
+    return _$$_REQUIRE(_dependencyMap[1], "../Network/XMLHttpRequest").default;
+  });
+  _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions").polyfillGlobal('FormData', function () {
+    return _$$_REQUIRE(_dependencyMap[2], "../Network/FormData").default;
+  });
+  _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions").polyfillGlobal('fetch', function () {
+    return _$$_REQUIRE(_dependencyMap[3], "../Network/fetch").fetch;
+  });
+  _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions").polyfillGlobal('Headers', function () {
+    return _$$_REQUIRE(_dependencyMap[3], "../Network/fetch").Headers;
+  });
+  _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions").polyfillGlobal('Request', function () {
+    return _$$_REQUIRE(_dependencyMap[3], "../Network/fetch").Request;
+  });
+  _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions").polyfillGlobal('Response', function () {
+    return _$$_REQUIRE(_dependencyMap[3], "../Network/fetch").Response;
+  });
+  _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions").polyfillGlobal('WebSocket', function () {
+    return _$$_REQUIRE(_dependencyMap[4], "../WebSocket/WebSocket").default;
+  });
+  _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions").polyfillGlobal('Blob', function () {
+    return _$$_REQUIRE(_dependencyMap[5], "../Blob/Blob").default;
+  });
+  _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions").polyfillGlobal('File', function () {
+    return _$$_REQUIRE(_dependencyMap[6], "../Blob/File").default;
+  });
+  _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions").polyfillGlobal('FileReader', function () {
+    return _$$_REQUIRE(_dependencyMap[7], "../Blob/FileReader").default;
+  });
+  _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions").polyfillGlobal('URL', function () {
+    return _$$_REQUIRE(_dependencyMap[8], "../Blob/URL").URL;
+  });
+  _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions").polyfillGlobal('URLSearchParams', function () {
+    return _$$_REQUIRE(_dependencyMap[8], "../Blob/URL").URLSearchParams;
+  });
+  _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions").polyfillGlobal('AbortController', function () {
+    return _$$_REQUIRE(_dependencyMap[9], "abort-controller/dist/abort-controller").AbortController;
+  });
+  _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions").polyfillGlobal('AbortSignal', function () {
+    return _$$_REQUIRE(_dependencyMap[9], "abort-controller/dist/abort-controller").AbortSignal;
+  });
+},247,[114,248,255,169,225,232,258,259,262,264],"../../node_modules/react-native/Libraries/Core/setUpXHR.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _toConsumableArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/toConsumableArray"));
+  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/get"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits"));
+  var _Event = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../../src/private/webapis/dom/events/Event"));
+  var _EventTarget3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "../../src/private/webapis/dom/events/EventTarget"));
+  var _ProgressEvent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "../../src/private/webapis/xhr/events/ProgressEvent"));
+  function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var DEBUG_NETWORK_SEND_DELAY = false;
+  var LABEL_FOR_MISSING_URL_FOR_PROFILING = 'Unknown URL';
+  if (_$$_REQUIRE(_dependencyMap[11], "../Blob/BlobManager").default.isAvailable) {
+    _$$_REQUIRE(_dependencyMap[11], "../Blob/BlobManager").default.addNetworkingHandler();
+  }
+  var UNSENT = 0;
+  var OPENED = 1;
+  var HEADERS_RECEIVED = 2;
+  var LOADING = 3;
+  var DONE = 4;
+  var SUPPORTED_RESPONSE_TYPES = {
+    arraybuffer: typeof global.ArrayBuffer === 'function',
+    blob: typeof global.Blob === 'function',
+    document: false,
+    json: true,
+    text: true,
+    '': true
+  };
+  var XMLHttpRequestEventTarget = /*#__PURE__*/function (_EventTarget) {
+    function XMLHttpRequestEventTarget() {
+      (0, _classCallCheck2.default)(this, XMLHttpRequestEventTarget);
+      return _callSuper(this, XMLHttpRequestEventTarget, arguments);
+    }
+    (0, _inherits2.default)(XMLHttpRequestEventTarget, _EventTarget);
+    return (0, _createClass2.default)(XMLHttpRequestEventTarget, [{
+      key: "onload",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'load');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'load', listener);
+      }
+    }, {
+      key: "onloadstart",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'loadstart');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'loadstart', listener);
+      }
+    }, {
+      key: "onprogress",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'progress');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'progress', listener);
+      }
+    }, {
+      key: "ontimeout",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'timeout');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'timeout', listener);
+      }
+    }, {
+      key: "onerror",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'error');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'error', listener);
+      }
+    }, {
+      key: "onabort",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'abort');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'abort', listener);
+      }
+    }, {
+      key: "onloadend",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'loadend');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'loadend', listener);
+      }
+    }]);
+  }(_EventTarget3.default);
+  var XMLHttpRequest = /*#__PURE__*/function (_EventTarget2) {
+    function XMLHttpRequest() {
+      var _this;
+      (0, _classCallCheck2.default)(this, XMLHttpRequest);
+      _this = _callSuper(this, XMLHttpRequest);
+      _this.UNSENT = UNSENT;
+      _this.OPENED = OPENED;
+      _this.HEADERS_RECEIVED = HEADERS_RECEIVED;
+      _this.LOADING = LOADING;
+      _this.DONE = DONE;
+      _this.readyState = UNSENT;
+      _this.status = 0;
+      _this.timeout = 0;
+      _this.withCredentials = true;
+      _this.upload = new XMLHttpRequestEventTarget();
+      _this._aborted = false;
+      _this._hasError = false;
+      _this._method = null;
+      _this._perfKey = null;
+      _this._response = '';
+      _this._url = null;
+      _this._timedOut = false;
+      _this._trackingName = null;
+      _this._incrementalEvents = false;
+      _this._startTime = null;
+      _this._performanceLogger = _$$_REQUIRE(_dependencyMap[13], "../Utilities/GlobalPerformanceLogger").default;
+      _this._reset();
+      return _this;
+    }
+    (0, _inherits2.default)(XMLHttpRequest, _EventTarget2);
+    return (0, _createClass2.default)(XMLHttpRequest, [{
+      key: "_reset",
+      value: function _reset() {
+        this.readyState = this.UNSENT;
+        this.responseHeaders = undefined;
+        this.status = 0;
+        delete this.responseURL;
+        this._requestId = null;
+        this._cachedResponse = undefined;
+        this._hasError = false;
+        this._headers = {};
+        this._response = '';
+        this._responseType = '';
+        this._sent = false;
+        this._lowerCaseResponseHeaders = {};
+        this._clearSubscriptions();
+        this._timedOut = false;
+      }
+    }, {
+      key: "responseType",
+      get: function get() {
+        return this._responseType;
+      },
+      set: function set(responseType) {
+        if (this._sent) {
+          throw new Error("Failed to set the 'responseType' property on 'XMLHttpRequest': The " + 'response type cannot be set after the request has been sent.');
+        }
+        if (!SUPPORTED_RESPONSE_TYPES.hasOwnProperty(responseType)) {
+          console.warn(`The provided value '${responseType}' is not a valid 'responseType'.`);
+          return;
+        }
+        _$$_REQUIRE(_dependencyMap[14], "invariant")(SUPPORTED_RESPONSE_TYPES[responseType] || responseType === 'document', `The provided value '${responseType}' is unsupported in this environment.`);
+        if (responseType === 'blob') {
+          _$$_REQUIRE(_dependencyMap[14], "invariant")(_$$_REQUIRE(_dependencyMap[11], "../Blob/BlobManager").default.isAvailable, 'Native module BlobModule is required for blob support');
+        }
+        this._responseType = responseType;
+      }
+    }, {
+      key: "responseText",
+      get: function get() {
+        if (this._responseType !== '' && this._responseType !== 'text') {
+          throw new Error("The 'responseText' property is only available if 'responseType' " + `is set to '' or 'text', but it is '${this._responseType}'.`);
+        }
+        if (this.readyState < LOADING) {
+          return '';
+        }
+        return this._response;
+      }
+    }, {
+      key: "response",
+      get: function get() {
+        var responseType = this.responseType;
+        if (responseType === '' || responseType === 'text') {
+          return this.readyState < LOADING || this._hasError ? '' : this._response;
+        }
+        if (this.readyState !== DONE) {
+          return null;
+        }
+        if (this._cachedResponse !== undefined) {
+          return this._cachedResponse;
+        }
+        switch (responseType) {
+          case 'document':
+            this._cachedResponse = null;
+            break;
+          case 'arraybuffer':
+            this._cachedResponse = _$$_REQUIRE(_dependencyMap[15], "base64-js").toByteArray(this._response).buffer;
+            break;
+          case 'blob':
+            if (typeof this._response === 'object' && this._response) {
+              this._cachedResponse = _$$_REQUIRE(_dependencyMap[11], "../Blob/BlobManager").default.createFromOptions(this._response);
+            } else if (this._response === '') {
+              this._cachedResponse = _$$_REQUIRE(_dependencyMap[11], "../Blob/BlobManager").default.createFromParts([]);
+            } else {
+              throw new Error('Invalid response for blob - expecting object, was ' + `${typeof this._response}: ${this._response.trim()}`);
+            }
+            break;
+          case 'json':
+            try {
+              this._cachedResponse = JSON.parse(this._response);
+            } catch (_) {
+              this._cachedResponse = null;
+            }
+            break;
+          default:
+            this._cachedResponse = null;
+        }
+        return this._cachedResponse;
+      }
+    }, {
+      key: "__didCreateRequest",
+      value: function __didCreateRequest(requestId) {
+        this._requestId = requestId;
+        XMLHttpRequest._interceptor && XMLHttpRequest._interceptor.requestSent(requestId, this._url || '', this._method || 'GET', this._headers);
+      }
+    }, {
+      key: "__didUploadProgress",
+      value: function __didUploadProgress(requestId, progress, total) {
+        if (requestId === this._requestId) {
+          (0, _$$_REQUIRE(_dependencyMap[16], "../../src/private/webapis/dom/events/internals/EventTargetInternals").dispatchTrustedEvent)(this.upload, new _ProgressEvent.default('progress', {
+            lengthComputable: true,
+            loaded: progress,
+            total: total
+          }));
+        }
+      }
+    }, {
+      key: "__didReceiveResponse",
+      value: function __didReceiveResponse(requestId, status, responseHeaders, responseURL) {
+        if (requestId === this._requestId) {
+          this._perfKey != null && this._performanceLogger.stopTimespan(this._perfKey);
+          this.status = status;
+          this.setResponseHeaders(responseHeaders);
+          this.setReadyState(this.HEADERS_RECEIVED);
+          if (responseURL || responseURL === '') {
+            this.responseURL = responseURL;
+          } else {
+            delete this.responseURL;
+          }
+          XMLHttpRequest._interceptor && XMLHttpRequest._interceptor.responseReceived(requestId, responseURL || this._url || '', status, responseHeaders || {});
+        }
+      }
+    }, {
+      key: "__didReceiveData",
+      value: function __didReceiveData(requestId, response) {
+        if (requestId !== this._requestId) {
+          return;
+        }
+        this._response = response;
+        this._cachedResponse = undefined;
+        this.setReadyState(this.LOADING);
+        XMLHttpRequest._interceptor && XMLHttpRequest._interceptor.dataReceived(requestId, response);
+      }
+    }, {
+      key: "__didReceiveIncrementalData",
+      value: function __didReceiveIncrementalData(requestId, responseText, progress, total) {
+        if (requestId !== this._requestId) {
+          return;
+        }
+        if (!this._response) {
+          this._response = responseText;
+        } else {
+          this._response += responseText;
+        }
+        if (XMLHttpRequest._profiling) {
+          performance.mark('Track:XMLHttpRequest:Incremental Data: ' + this._getMeasureURL());
+        }
+        XMLHttpRequest._interceptor && XMLHttpRequest._interceptor.dataReceived(requestId, responseText);
+        this.setReadyState(this.LOADING);
+        this.__didReceiveDataProgress(requestId, progress, total);
+      }
+    }, {
+      key: "__didReceiveDataProgress",
+      value: function __didReceiveDataProgress(requestId, loaded, total) {
+        if (requestId !== this._requestId) {
+          return;
+        }
+        (0, _$$_REQUIRE(_dependencyMap[16], "../../src/private/webapis/dom/events/internals/EventTargetInternals").dispatchTrustedEvent)(this, new _ProgressEvent.default('progress', {
+          lengthComputable: total >= 0,
+          loaded: loaded,
+          total: total
+        }));
+      }
+    }, {
+      key: "__didCompleteResponse",
+      value: function __didCompleteResponse(requestId, error, timeOutError) {
+        if (requestId === this._requestId) {
+          if (error) {
+            if (this._responseType === '' || this._responseType === 'text') {
+              this._response = error;
+            }
+            this._hasError = true;
+            if (timeOutError) {
+              this._timedOut = true;
+            }
+          }
+          this._clearSubscriptions();
+          this._requestId = null;
+          this.setReadyState(this.DONE);
+          if (XMLHttpRequest._profiling && this._startTime != null) {
+            var start = this._startTime;
+            performance.measure('Track:XMLHttpRequest:' + this._getMeasureURL(), {
+              start: start,
+              end: performance.now()
+            });
+          }
+          if (error) {
+            XMLHttpRequest._interceptor && XMLHttpRequest._interceptor.loadingFailed(requestId, error);
+          } else {
+            XMLHttpRequest._interceptor && XMLHttpRequest._interceptor.loadingFinished(requestId, this._response.length);
+          }
+        }
+      }
+    }, {
+      key: "_clearSubscriptions",
+      value: function _clearSubscriptions() {
+        (this._subscriptions || []).forEach(function (sub) {
+          if (sub) {
+            sub.remove();
+          }
+        });
+        this._subscriptions = [];
+      }
+    }, {
+      key: "getAllResponseHeaders",
+      value: function getAllResponseHeaders() {
+        if (!this.responseHeaders) {
+          return null;
+        }
+        var responseHeaders = this.responseHeaders;
+        var unsortedHeaders = new Map();
+        for (var rawHeaderName of Object.keys(responseHeaders)) {
+          var headerValue = responseHeaders[rawHeaderName];
+          var lowerHeaderName = rawHeaderName.toLowerCase();
+          var header = unsortedHeaders.get(lowerHeaderName);
+          if (header) {
+            header.headerValue += ', ' + headerValue;
+            unsortedHeaders.set(lowerHeaderName, header);
+          } else {
+            unsortedHeaders.set(lowerHeaderName, {
+              lowerHeaderName: lowerHeaderName,
+              upperHeaderName: rawHeaderName.toUpperCase(),
+              headerValue: headerValue
+            });
+          }
+        }
+        var sortedHeaders = (0, _toConsumableArray2.default)(unsortedHeaders.values()).sort(function (a, b) {
+          if (a.upperHeaderName < b.upperHeaderName) {
+            return -1;
+          }
+          if (a.upperHeaderName > b.upperHeaderName) {
+            return 1;
+          }
+          return 0;
+        });
+        return sortedHeaders.map(function (header) {
+          return header.lowerHeaderName + ': ' + header.headerValue;
+        }).join('\r\n') + '\r\n';
+      }
+    }, {
+      key: "getResponseHeader",
+      value: function getResponseHeader(header) {
+        var value = this._lowerCaseResponseHeaders[header.toLowerCase()];
+        return value !== undefined ? value : null;
+      }
+    }, {
+      key: "setRequestHeader",
+      value: function setRequestHeader(header, value) {
+        if (this.readyState !== this.OPENED) {
+          throw new Error('Request has not been opened');
+        }
+        this._headers[header.toLowerCase()] = String(value);
+      }
+    }, {
+      key: "setTrackingName",
+      value: function setTrackingName(trackingName) {
+        this._trackingName = trackingName;
+        return this;
+      }
+    }, {
+      key: "setPerformanceLogger",
+      value: function setPerformanceLogger(performanceLogger) {
+        this._performanceLogger = performanceLogger;
+        return this;
+      }
+    }, {
+      key: "open",
+      value: function open(method, url, async) {
+        if (this.readyState !== this.UNSENT) {
+          throw new Error('Cannot open, already sending');
+        }
+        if (async !== undefined && !async) {
+          throw new Error('Synchronous http requests are not supported');
+        }
+        if (!url) {
+          throw new Error('Cannot load an empty url');
+        }
+        this._method = method.toUpperCase();
+        this._url = url;
+        this._aborted = false;
+        this.setReadyState(this.OPENED);
+      }
+    }, {
+      key: "send",
+      value: function send(data) {
+        var _this2 = this;
+        if (this.readyState !== this.OPENED) {
+          throw new Error('Request has not been opened');
+        }
+        if (this._sent) {
+          throw new Error('Request has already been sent');
+        }
+        this._sent = true;
+        var incrementalEvents = this._incrementalEvents || !!this.onreadystatechange || !!this.onprogress;
+        this._subscriptions.push(_$$_REQUIRE(_dependencyMap[17], "./RCTNetworking").default.addListener('didSendNetworkData', function (args) {
+          return _this2.__didUploadProgress.apply(_this2, (0, _toConsumableArray2.default)(args));
+        }));
+        this._subscriptions.push(_$$_REQUIRE(_dependencyMap[17], "./RCTNetworking").default.addListener('didReceiveNetworkResponse', function (args) {
+          return _this2.__didReceiveResponse.apply(_this2, (0, _toConsumableArray2.default)(args));
+        }));
+        this._subscriptions.push(_$$_REQUIRE(_dependencyMap[17], "./RCTNetworking").default.addListener('didReceiveNetworkData', function (args) {
+          return _this2.__didReceiveData.apply(_this2, (0, _toConsumableArray2.default)(args));
+        }));
+        this._subscriptions.push(_$$_REQUIRE(_dependencyMap[17], "./RCTNetworking").default.addListener('didReceiveNetworkIncrementalData', function (args) {
+          return _this2.__didReceiveIncrementalData.apply(_this2, (0, _toConsumableArray2.default)(args));
+        }));
+        this._subscriptions.push(_$$_REQUIRE(_dependencyMap[17], "./RCTNetworking").default.addListener('didReceiveNetworkDataProgress', function (args) {
+          return _this2.__didReceiveDataProgress.apply(_this2, (0, _toConsumableArray2.default)(args));
+        }));
+        this._subscriptions.push(_$$_REQUIRE(_dependencyMap[17], "./RCTNetworking").default.addListener('didCompleteNetworkResponse', function (args) {
+          return _this2.__didCompleteResponse.apply(_this2, (0, _toConsumableArray2.default)(args));
+        }));
+        var nativeResponseType = 'text';
+        if (this._responseType === 'arraybuffer') {
+          nativeResponseType = 'base64';
+        }
+        if (this._responseType === 'blob') {
+          nativeResponseType = 'blob';
+        }
+        var doSend = function doSend() {
+          var _this2$_trackingName;
+          var friendlyName = (_this2$_trackingName = _this2._trackingName) != null ? _this2$_trackingName : _this2._url;
+          _this2._perfKey = 'network_XMLHttpRequest_' + String(friendlyName);
+          _this2._performanceLogger.startTimespan(_this2._perfKey);
+          _this2._startTime = performance.now();
+          _$$_REQUIRE(_dependencyMap[14], "invariant")(_this2._method, 'XMLHttpRequest method needs to be defined (%s).', friendlyName);
+          _$$_REQUIRE(_dependencyMap[14], "invariant")(_this2._url, 'XMLHttpRequest URL needs to be defined (%s).', friendlyName);
+          _$$_REQUIRE(_dependencyMap[17], "./RCTNetworking").default.sendRequest(_this2._method, _this2._trackingName, _this2._url, _this2._headers, data, nativeResponseType, incrementalEvents, _this2.timeout, _this2.__didCreateRequest.bind(_this2), _this2.withCredentials);
+        };
+        if (DEBUG_NETWORK_SEND_DELAY) {
+          setTimeout(doSend, DEBUG_NETWORK_SEND_DELAY);
+        } else {
+          doSend();
+        }
+      }
+    }, {
+      key: "abort",
+      value: function abort() {
+        this._aborted = true;
+        if (this._requestId) {
+          _$$_REQUIRE(_dependencyMap[17], "./RCTNetworking").default.abortRequest(this._requestId);
+        }
+        if (!(this.readyState === this.UNSENT || this.readyState === this.OPENED && !this._sent || this.readyState === this.DONE)) {
+          this._reset();
+          this.setReadyState(this.DONE);
+        }
+        this._reset();
+      }
+    }, {
+      key: "setResponseHeaders",
+      value: function setResponseHeaders(responseHeaders) {
+        this.responseHeaders = responseHeaders || null;
+        var headers = responseHeaders || {};
+        this._lowerCaseResponseHeaders = Object.keys(headers).reduce(function (lcaseHeaders, headerName) {
+          lcaseHeaders[headerName.toLowerCase()] = headers[headerName];
+          return lcaseHeaders;
+        }, {});
+      }
+    }, {
+      key: "setReadyState",
+      value: function setReadyState(newState) {
+        this.readyState = newState;
+        (0, _$$_REQUIRE(_dependencyMap[16], "../../src/private/webapis/dom/events/internals/EventTargetInternals").dispatchTrustedEvent)(this, new _Event.default('readystatechange'));
+        if (newState === this.DONE) {
+          if (this._aborted) {
+            (0, _$$_REQUIRE(_dependencyMap[16], "../../src/private/webapis/dom/events/internals/EventTargetInternals").dispatchTrustedEvent)(this, new _Event.default('abort'));
+          } else if (this._hasError) {
+            if (this._timedOut) {
+              (0, _$$_REQUIRE(_dependencyMap[16], "../../src/private/webapis/dom/events/internals/EventTargetInternals").dispatchTrustedEvent)(this, new _Event.default('timeout'));
+            } else {
+              (0, _$$_REQUIRE(_dependencyMap[16], "../../src/private/webapis/dom/events/internals/EventTargetInternals").dispatchTrustedEvent)(this, new _Event.default('error'));
+            }
+          } else {
+            (0, _$$_REQUIRE(_dependencyMap[16], "../../src/private/webapis/dom/events/internals/EventTargetInternals").dispatchTrustedEvent)(this, new _Event.default('load'));
+          }
+          (0, _$$_REQUIRE(_dependencyMap[16], "../../src/private/webapis/dom/events/internals/EventTargetInternals").dispatchTrustedEvent)(this, new _Event.default('loadend'));
+        }
+      }
+    }, {
+      key: "addEventListener",
+      value: function addEventListener(type, listener) {
+        if (type === 'readystatechange' || type === 'progress') {
+          this._incrementalEvents = true;
+        }
+        _superPropGet(XMLHttpRequest, "addEventListener", this, 3)([type, listener]);
+      }
+    }, {
+      key: "_getMeasureURL",
+      value: function _getMeasureURL() {
+        var _ref, _this$_trackingName;
+        return (_ref = (_this$_trackingName = this._trackingName) != null ? _this$_trackingName : this._url) != null ? _ref : LABEL_FOR_MISSING_URL_FOR_PROFILING;
+      }
+    }, {
+      key: "onabort",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'abort');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'abort', listener);
+      }
+    }, {
+      key: "onerror",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'error');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'error', listener);
+      }
+    }, {
+      key: "onload",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'load');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'load', listener);
+      }
+    }, {
+      key: "onloadstart",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'loadstart');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'loadstart', listener);
+      }
+    }, {
+      key: "onprogress",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'progress');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'progress', listener);
+      }
+    }, {
+      key: "ontimeout",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'timeout');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'timeout', listener);
+      }
+    }, {
+      key: "onloadend",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'loadend');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'loadend', listener);
+      }
+    }, {
+      key: "onreadystatechange",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'readystatechange');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[12], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'readystatechange', listener);
+      }
+    }], [{
+      key: "__setInterceptor_DO_NOT_USE",
+      value: function __setInterceptor_DO_NOT_USE(interceptor) {
+        XMLHttpRequest._interceptor = interceptor;
+      }
+    }, {
+      key: "enableProfiling",
+      value: function enableProfiling(_enableProfiling) {
+        XMLHttpRequest._profiling = _enableProfiling;
+      }
+    }]);
+  }(_EventTarget3.default);
+  XMLHttpRequest.UNSENT = UNSENT;
+  XMLHttpRequest.OPENED = OPENED;
+  XMLHttpRequest.HEADERS_RECEIVED = HEADERS_RECEIVED;
+  XMLHttpRequest.LOADING = LOADING;
+  XMLHttpRequest.DONE = DONE;
+  XMLHttpRequest._interceptor = null;
+  XMLHttpRequest._profiling = false;
+  var _default = exports.default = XMLHttpRequest;
+},248,[1,42,21,11,12,18,20,23,226,228,249,233,241,250,32,238,229,253],"../../node_modules/react-native/Libraries/Network/XMLHttpRequest.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var _Event2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../../dom/events/Event"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var ProgressEvent = exports.default = /*#__PURE__*/function (_Event) {
+    function ProgressEvent(type, options) {
+      var _this;
+      (0, _classCallCheck2.default)(this, ProgressEvent);
+      _this = _callSuper(this, ProgressEvent, [type, options]);
+      _this._lengthComputable = Boolean(options == null ? void 0 : options.lengthComputable);
+      _this._loaded = Number(options == null ? void 0 : options.loaded) || 0;
+      _this._total = Number(options == null ? void 0 : options.total) || 0;
+      return _this;
+    }
+    (0, _inherits2.default)(ProgressEvent, _Event);
+    return (0, _createClass2.default)(ProgressEvent, [{
+      key: "lengthComputable",
+      get: function get() {
+        return this._lengthComputable;
+      }
+    }, {
+      key: "loaded",
+      get: function get() {
+        return this._loaded;
+      }
+    }, {
+      key: "total",
+      get: function get() {
+        return this._total;
+      }
+    }]);
+  }(_Event2.default);
+},249,[1,11,12,18,20,23,226],"../../node_modules/react-native/src/private/webapis/xhr/events/ProgressEvent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _createPerformanceLogger = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./createPerformanceLogger"));
+  var GlobalPerformanceLogger = (0, _createPerformanceLogger.default)();
+  var _default = exports.default = GlobalPerformanceLogger;
+},250,[1,251],"../../node_modules/react-native/Libraries/Utilities/GlobalPerformanceLogger.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = createPerformanceLogger;
+  exports.getCurrentTimestamp = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _infoLog = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./infoLog"));
+  var _global$nativeQPLTime;
+  var PRINT_TO_CONSOLE = false;
+  var getCurrentTimestamp = exports.getCurrentTimestamp = (_global$nativeQPLTime = global.nativeQPLTimestamp) != null ? _global$nativeQPLTime : function () {
+    return global.performance.now();
+  };
+  var PerformanceLogger = /*#__PURE__*/function () {
+    function PerformanceLogger() {
+      (0, _classCallCheck2.default)(this, PerformanceLogger);
+      this._timespans = {};
+      this._extras = {};
+      this._points = {};
+      this._pointExtras = {};
+      this._closed = false;
+    }
+    return (0, _createClass2.default)(PerformanceLogger, [{
+      key: "addTimespan",
+      value: function addTimespan(key, startTime, endTime, startExtras, endExtras) {
+        if (this._closed) {
+          if (PRINT_TO_CONSOLE && __DEV__) {
+            (0, _infoLog.default)('PerformanceLogger: addTimespan - has closed ignoring: ', key);
+          }
+          return;
+        }
+        if (this._timespans[key]) {
+          if (PRINT_TO_CONSOLE && __DEV__) {
+            (0, _infoLog.default)('PerformanceLogger: Attempting to add a timespan that already exists ', key);
+          }
+          return;
+        }
+        this._timespans[key] = {
+          startTime: startTime,
+          endTime: endTime,
+          totalTime: endTime - (startTime || 0),
+          startExtras: startExtras,
+          endExtras: endExtras
+        };
+      }
+    }, {
+      key: "append",
+      value: function append(performanceLogger) {
+        this._timespans = Object.assign({}, performanceLogger.getTimespans(), this._timespans);
+        this._extras = Object.assign({}, performanceLogger.getExtras(), this._extras);
+        this._points = Object.assign({}, performanceLogger.getPoints(), this._points);
+        this._pointExtras = Object.assign({}, performanceLogger.getPointExtras(), this._pointExtras);
+      }
+    }, {
+      key: "clear",
+      value: function clear() {
+        this._timespans = {};
+        this._extras = {};
+        this._points = {};
+        if (PRINT_TO_CONSOLE) {
+          (0, _infoLog.default)('PerformanceLogger.js', 'clear');
+        }
+      }
+    }, {
+      key: "clearCompleted",
+      value: function clearCompleted() {
+        for (var _key in this._timespans) {
+          var _this$_timespans$_key;
+          if (((_this$_timespans$_key = this._timespans[_key]) == null ? void 0 : _this$_timespans$_key.totalTime) != null) {
+            delete this._timespans[_key];
+          }
+        }
+        this._extras = {};
+        this._points = {};
+        if (PRINT_TO_CONSOLE) {
+          (0, _infoLog.default)('PerformanceLogger.js', 'clearCompleted');
+        }
+      }
+    }, {
+      key: "close",
+      value: function close() {
+        this._closed = true;
+      }
+    }, {
+      key: "currentTimestamp",
+      value: function currentTimestamp() {
+        return getCurrentTimestamp();
+      }
+    }, {
+      key: "getExtras",
+      value: function getExtras() {
+        return this._extras;
+      }
+    }, {
+      key: "getPoints",
+      value: function getPoints() {
+        return this._points;
+      }
+    }, {
+      key: "getPointExtras",
+      value: function getPointExtras() {
+        return this._pointExtras;
+      }
+    }, {
+      key: "getTimespans",
+      value: function getTimespans() {
+        return this._timespans;
+      }
+    }, {
+      key: "hasTimespan",
+      value: function hasTimespan(key) {
+        return !!this._timespans[key];
+      }
+    }, {
+      key: "isClosed",
+      value: function isClosed() {
+        return this._closed;
+      }
+    }, {
+      key: "logEverything",
+      value: function logEverything() {
+        if (PRINT_TO_CONSOLE) {
+          for (var _key2 in this._timespans) {
+            var _this$_timespans$_key2;
+            if (((_this$_timespans$_key2 = this._timespans[_key2]) == null ? void 0 : _this$_timespans$_key2.totalTime) != null) {
+              (0, _infoLog.default)(_key2 + ': ' + this._timespans[_key2].totalTime + 'ms');
+            }
+          }
+          (0, _infoLog.default)(this._extras);
+          for (var _key3 in this._points) {
+            if (this._points[_key3] != null) {
+              (0, _infoLog.default)(_key3 + ': ' + this._points[_key3] + 'ms');
+            }
+          }
+        }
+      }
+    }, {
+      key: "markPoint",
+      value: function markPoint(key) {
+        var timestamp = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : getCurrentTimestamp();
+        var extras = arguments.length > 2 ? arguments[2] : undefined;
+        if (this._closed) {
+          if (PRINT_TO_CONSOLE && __DEV__) {
+            (0, _infoLog.default)('PerformanceLogger: markPoint - has closed ignoring: ', key);
+          }
+          return;
+        }
+        if (this._points[key] != null) {
+          if (PRINT_TO_CONSOLE && __DEV__) {
+            (0, _infoLog.default)('PerformanceLogger: Attempting to mark a point that has been already logged ', key);
+          }
+          return;
+        }
+        this._points[key] = timestamp;
+        if (extras) {
+          this._pointExtras[key] = extras;
+        }
+      }
+    }, {
+      key: "removeExtra",
+      value: function removeExtra(key) {
+        var value = this._extras[key];
+        delete this._extras[key];
+        return value;
+      }
+    }, {
+      key: "setExtra",
+      value: function setExtra(key, value) {
+        if (this._closed) {
+          if (PRINT_TO_CONSOLE && __DEV__) {
+            (0, _infoLog.default)('PerformanceLogger: setExtra - has closed ignoring: ', key);
+          }
+          return;
+        }
+        if (this._extras.hasOwnProperty(key)) {
+          if (PRINT_TO_CONSOLE && __DEV__) {
+            (0, _infoLog.default)('PerformanceLogger: Attempting to set an extra that already exists ', {
+              key: key,
+              currentValue: this._extras[key],
+              attemptedValue: value
+            });
+          }
+          return;
+        }
+        this._extras[key] = value;
+      }
+    }, {
+      key: "startTimespan",
+      value: function startTimespan(key) {
+        var timestamp = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : getCurrentTimestamp();
+        var extras = arguments.length > 2 ? arguments[2] : undefined;
+        if (this._closed) {
+          if (PRINT_TO_CONSOLE && __DEV__) {
+            (0, _infoLog.default)('PerformanceLogger: startTimespan - has closed ignoring: ', key);
+          }
+          return;
+        }
+        if (this._timespans[key]) {
+          if (PRINT_TO_CONSOLE && __DEV__) {
+            (0, _infoLog.default)('PerformanceLogger: Attempting to start a timespan that already exists ', key);
+          }
+          return;
+        }
+        this._timespans[key] = {
+          startTime: timestamp,
+          startExtras: extras
+        };
+        if (PRINT_TO_CONSOLE) {
+          (0, _infoLog.default)('PerformanceLogger.js', 'start: ' + key);
+        }
+      }
+    }, {
+      key: "stopTimespan",
+      value: function stopTimespan(key) {
+        var timestamp = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : getCurrentTimestamp();
+        var extras = arguments.length > 2 ? arguments[2] : undefined;
+        if (this._closed) {
+          if (PRINT_TO_CONSOLE && __DEV__) {
+            (0, _infoLog.default)('PerformanceLogger: stopTimespan - has closed ignoring: ', key);
+          }
+          return;
+        }
+        var timespan = this._timespans[key];
+        if (!timespan || timespan.startTime == null) {
+          if (PRINT_TO_CONSOLE && __DEV__) {
+            (0, _infoLog.default)('PerformanceLogger: Attempting to end a timespan that has not started ', key);
+          }
+          return;
+        }
+        if (timespan.endTime != null) {
+          if (PRINT_TO_CONSOLE && __DEV__) {
+            (0, _infoLog.default)('PerformanceLogger: Attempting to end a timespan that has already ended ', key);
+          }
+          return;
+        }
+        timespan.endExtras = extras;
+        timespan.endTime = timestamp;
+        timespan.totalTime = timespan.endTime - (timespan.startTime || 0);
+        if (PRINT_TO_CONSOLE) {
+          (0, _infoLog.default)('PerformanceLogger.js', 'end: ' + key);
+        }
+      }
+    }]);
+  }();
+  function createPerformanceLogger() {
+    return new PerformanceLogger();
+  }
+},251,[1,11,12,252],"../../node_modules/react-native/Libraries/Utilities/createPerformanceLogger.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  function infoLog() {
+    var _console;
+    return (_console = console).log.apply(_console, arguments);
+  }
+  var _default = exports.default = infoLog;
+},252,[],"../../node_modules/react-native/Libraries/Utilities/infoLog.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _RCTDeviceEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../EventEmitter/RCTDeviceEventEmitter"));
+  var _convertRequestBody = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./convertRequestBody"));
+  var _NativeNetworkingIOS = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./NativeNetworkingIOS"));
+  var RCTNetworking = {
+    addListener: function addListener(eventType, listener, context) {
+      return _RCTDeviceEventEmitter.default.addListener(eventType, listener, context);
+    },
+    sendRequest: function sendRequest(method, trackingName, url, headers, data, responseType, incrementalUpdates, timeout, callback, withCredentials) {
+      var body = (0, _convertRequestBody.default)(data);
+      _NativeNetworkingIOS.default.sendRequest({
+        method: method,
+        url: url,
+        data: Object.assign({}, body, {
+          trackingName: trackingName
+        }),
+        headers: headers,
+        responseType: responseType,
+        incrementalUpdates: incrementalUpdates,
+        timeout: timeout,
+        withCredentials: withCredentials
+      }, callback);
+    },
+    abortRequest: function abortRequest(requestId) {
+      _NativeNetworkingIOS.default.abortRequest(requestId);
+    },
+    clearCookies: function clearCookies(callback) {
+      _NativeNetworkingIOS.default.clearCookies(callback);
+    }
+  };
+  var _default = exports.default = RCTNetworking;
+},253,[1,17,254,256],"../../node_modules/react-native/Libraries/Network/RCTNetworking.ios.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  function convertRequestBody(body) {
+    if (typeof body === 'string') {
+      return {
+        string: body
+      };
+    }
+    if (body instanceof _$$_REQUIRE(_dependencyMap[0], "../Blob/Blob").default) {
+      return {
+        blob: body.data
+      };
+    }
+    if (body instanceof _$$_REQUIRE(_dependencyMap[1], "./FormData").default) {
+      return {
+        formData: body.getParts()
+      };
+    }
+    if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {
+      return {
+        base64: _$$_REQUIRE(_dependencyMap[2], "../Utilities/binaryToBase64").default(body)
+      };
+    }
+    return body;
+  }
+  var _default = exports.default = convertRequestBody;
+},254,[232,255,237],"../../node_modules/react-native/Libraries/Network/convertRequestBody.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+  function encodeFilename(filename) {
+    return encodeURIComponent(filename.replace(/\//g, '_'));
+  }
+  var FormData = /*#__PURE__*/function () {
+    function FormData() {
+      (0, _classCallCheck2.default)(this, FormData);
+      this._parts = [];
+    }
+    return (0, _createClass2.default)(FormData, [{
+      key: "append",
+      value: function append(key, value) {
+        this._parts.push([key, value]);
+      }
+    }, {
+      key: "getAll",
+      value: function getAll(key) {
+        return this._parts.filter(function (_ref) {
+          var _ref2 = (0, _slicedToArray2.default)(_ref, 1),
+            name = _ref2[0];
+          return name === key;
+        }).map(function (_ref3) {
+          var _ref4 = (0, _slicedToArray2.default)(_ref3, 2),
+            value = _ref4[1];
+          return value;
+        });
+      }
+    }, {
+      key: "getParts",
+      value: function getParts() {
+        return this._parts.map(function (_ref5) {
+          var _ref6 = (0, _slicedToArray2.default)(_ref5, 2),
+            name = _ref6[0],
+            value = _ref6[1];
+          var contentDisposition = 'form-data; name="' + name + '"';
+          var headers = {
+            'content-disposition': contentDisposition
+          };
+          if (typeof value === 'object' && !Array.isArray(value) && value) {
+            if (typeof value.name === 'string') {
+              headers['content-disposition'] += `; filename="${encodeFilename(value.name)}"`;
+            }
+            if (typeof value.type === 'string') {
+              headers['content-type'] = value.type;
+            }
+            return Object.assign({}, value, {
+              headers: headers,
+              fieldName: name
+            });
+          }
+          return {
+            string: String(value),
+            headers: headers,
+            fieldName: name
+          };
+        });
+      }
+    }]);
+  }();
+  var _default = exports.default = FormData;
+},255,[1,34,11,12],"../../node_modules/react-native/Libraries/Network/FormData.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeNetworkingIOS = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativeNetworkingIOS"));
+  Object.keys(_NativeNetworkingIOS).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeNetworkingIOS[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeNetworkingIOS[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeNetworkingIOS.default;
+},256,[257],"../../node_modules/react-native/Libraries/Network/NativeNetworkingIOS.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.getEnforcing('Networking');
+},257,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeNetworkingIOS.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var _Blob2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./Blob"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var File = /*#__PURE__*/function (_Blob) {
+    function File(parts, name, options) {
+      var _this;
+      (0, _classCallCheck2.default)(this, File);
+      _$$_REQUIRE(_dependencyMap[7], "invariant")(parts != null && name != null, 'Failed to construct `File`: Must pass both `parts` and `name` arguments.');
+      _this = _callSuper(this, File, [parts, options]);
+      _this.data.name = name;
+      return _this;
+    }
+    (0, _inherits2.default)(File, _Blob);
+    return (0, _createClass2.default)(File, [{
+      key: "name",
+      get: function get() {
+        _$$_REQUIRE(_dependencyMap[7], "invariant")(this.data.name != null, 'Files must have a name set.');
+        return this.data.name;
+      }
+    }, {
+      key: "lastModified",
+      get: function get() {
+        return this.data.lastModified || 0;
+      }
+    }]);
+  }(_Blob2.default);
+  var _default = exports.default = File;
+},258,[1,11,12,18,20,23,232,32],"../../node_modules/react-native/Libraries/Blob/File.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var _Event = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../../src/private/webapis/dom/events/Event"));
+  var _EventTarget2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../../src/private/webapis/dom/events/EventTarget"));
+  var _NativeFileReaderModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./NativeFileReaderModule"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var EMPTY = 0;
+  var LOADING = 1;
+  var DONE = 2;
+  var FileReader = /*#__PURE__*/function (_EventTarget) {
+    function FileReader() {
+      var _this;
+      (0, _classCallCheck2.default)(this, FileReader);
+      _this = _callSuper(this, FileReader);
+      _this.EMPTY = EMPTY;
+      _this.LOADING = LOADING;
+      _this.DONE = DONE;
+      _this._aborted = false;
+      _this._reset();
+      return _this;
+    }
+    (0, _inherits2.default)(FileReader, _EventTarget);
+    return (0, _createClass2.default)(FileReader, [{
+      key: "_reset",
+      value: function _reset() {
+        this._readyState = EMPTY;
+        this._error = null;
+        this._result = null;
+      }
+    }, {
+      key: "_setReadyState",
+      value: function _setReadyState(newState) {
+        this._readyState = newState;
+        this.dispatchEvent(new _Event.default('readystatechange'));
+        if (newState === DONE) {
+          if (this._aborted) {
+            this.dispatchEvent(new _Event.default('abort'));
+          } else if (this._error) {
+            this.dispatchEvent(new _Event.default('error'));
+          } else {
+            this.dispatchEvent(new _Event.default('load'));
+          }
+          this.dispatchEvent(new _Event.default('loadend'));
+        }
+      }
+    }, {
+      key: "readAsArrayBuffer",
+      value: function readAsArrayBuffer(blob) {
+        var _this2 = this;
+        this._aborted = false;
+        if (blob == null) {
+          throw new TypeError("Failed to execute 'readAsArrayBuffer' on 'FileReader': parameter 1 is not of type 'Blob'");
+        }
+        _NativeFileReaderModule.default.readAsDataURL(blob.data).then(function (text) {
+          if (_this2._aborted) {
+            return;
+          }
+          var base64 = text.split(',')[1];
+          var typedArray = (0, _$$_REQUIRE(_dependencyMap[9], "base64-js").toByteArray)(base64);
+          _this2._result = typedArray.buffer;
+          _this2._setReadyState(DONE);
+        }, function (error) {
+          if (_this2._aborted) {
+            return;
+          }
+          _this2._error = error;
+          _this2._setReadyState(DONE);
+        });
+      }
+    }, {
+      key: "readAsDataURL",
+      value: function readAsDataURL(blob) {
+        var _this3 = this;
+        this._aborted = false;
+        if (blob == null) {
+          throw new TypeError("Failed to execute 'readAsDataURL' on 'FileReader': parameter 1 is not of type 'Blob'");
+        }
+        _NativeFileReaderModule.default.readAsDataURL(blob.data).then(function (text) {
+          if (_this3._aborted) {
+            return;
+          }
+          _this3._result = text;
+          _this3._setReadyState(DONE);
+        }, function (error) {
+          if (_this3._aborted) {
+            return;
+          }
+          _this3._error = error;
+          _this3._setReadyState(DONE);
+        });
+      }
+    }, {
+      key: "readAsText",
+      value: function readAsText(blob) {
+        var _this4 = this;
+        var encoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'UTF-8';
+        this._aborted = false;
+        if (blob == null) {
+          throw new TypeError("Failed to execute 'readAsText' on 'FileReader': parameter 1 is not of type 'Blob'");
+        }
+        _NativeFileReaderModule.default.readAsText(blob.data, encoding).then(function (text) {
+          if (_this4._aborted) {
+            return;
+          }
+          _this4._result = text;
+          _this4._setReadyState(DONE);
+        }, function (error) {
+          if (_this4._aborted) {
+            return;
+          }
+          _this4._error = error;
+          _this4._setReadyState(DONE);
+        });
+      }
+    }, {
+      key: "abort",
+      value: function abort() {
+        this._aborted = true;
+        if (this._readyState !== EMPTY && this._readyState !== DONE) {
+          this._reset();
+          this._setReadyState(DONE);
+        }
+        this._reset();
+      }
+    }, {
+      key: "readyState",
+      get: function get() {
+        return this._readyState;
+      }
+    }, {
+      key: "error",
+      get: function get() {
+        return this._error;
+      }
+    }, {
+      key: "result",
+      get: function get() {
+        return this._result;
+      }
+    }, {
+      key: "onabort",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[10], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'abort');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[10], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'abort', listener);
+      }
+    }, {
+      key: "onerror",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[10], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'error');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[10], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'error', listener);
+      }
+    }, {
+      key: "onload",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[10], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'load');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[10], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'load', listener);
+      }
+    }, {
+      key: "onloadstart",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[10], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'loadstart');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[10], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'loadstart', listener);
+      }
+    }, {
+      key: "onloadend",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[10], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'loadend');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[10], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'loadend', listener);
+      }
+    }, {
+      key: "onprogress",
+      get: function get() {
+        return (0, _$$_REQUIRE(_dependencyMap[10], "../../src/private/webapis/dom/events/EventHandlerAttributes").getEventHandlerAttribute)(this, 'progress');
+      },
+      set: function set(listener) {
+        (0, _$$_REQUIRE(_dependencyMap[10], "../../src/private/webapis/dom/events/EventHandlerAttributes").setEventHandlerAttribute)(this, 'progress', listener);
+      }
+    }]);
+  }(_EventTarget2.default);
+  FileReader.EMPTY = EMPTY;
+  FileReader.LOADING = LOADING;
+  FileReader.DONE = DONE;
+  var _default = exports.default = FileReader;
+},259,[1,11,12,18,20,23,226,228,260,238,241],"../../node_modules/react-native/Libraries/Blob/FileReader.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeFileReaderModule = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativeFileReaderModule"));
+  Object.keys(_NativeFileReaderModule).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeFileReaderModule[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeFileReaderModule[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeFileReaderModule.default;
+},260,[261],"../../node_modules/react-native/Libraries/Blob/NativeFileReaderModule.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.getEnforcing('FileReaderModule');
+},261,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeFileReaderModule.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.URL = void 0;
+  Object.defineProperty(exports, "URLSearchParams", {
+    enumerable: true,
+    get: function get() {
+      return _$$_REQUIRE(_dependencyMap[1], "./URLSearchParams").URLSearchParams;
+    }
+  });
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+  var _NativeBlobModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./NativeBlobModule"));
+  var BLOB_URL_PREFIX = null;
+  if (_NativeBlobModule.default && typeof _NativeBlobModule.default.getConstants().BLOB_URI_SCHEME === 'string') {
+    var constants = _NativeBlobModule.default.getConstants();
+    BLOB_URL_PREFIX = constants.BLOB_URI_SCHEME + ':';
+    if (typeof constants.BLOB_URI_HOST === 'string') {
+      BLOB_URL_PREFIX += `//${constants.BLOB_URI_HOST}/`;
+    }
+  }
+  function validateBaseUrl(url) {
+    return /^(?:(?:(?:https?|ftp):)?\/\/)(?:(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u00a1-\uffff][a-z0-9\u00a1-\uffff_-]{0,62})?[a-z0-9\u00a1-\uffff]\.)*(?:[a-z\u00a1-\uffff]{2,}\.?))(?::\d{2,5})?(?:[/?#]\S*)?$/.test(url);
+  }
+  var URL = exports.URL = /*#__PURE__*/function () {
+    function URL(url, base) {
+      (0, _classCallCheck2.default)(this, URL);
+      this._searchParamsInstance = null;
+      var baseUrl = null;
+      if (!base || validateBaseUrl(url)) {
+        this._url = url;
+        if (this._url.includes('#')) {
+          var split = this._url.split('#');
+          var beforeHash = split[0];
+          var website = beforeHash.split('://')[1];
+          if (!website.includes('/')) {
+            this._url = split.join('/#');
+          }
+        }
+        if (!this._url.endsWith('/') && !(this._url.includes('?') || this._url.includes('#'))) {
+          this._url += '/';
+        }
+      } else {
+        if (typeof base === 'string') {
+          baseUrl = base;
+          if (!validateBaseUrl(baseUrl)) {
+            throw new TypeError(`Invalid base URL: ${baseUrl}`);
+          }
+        } else {
+          baseUrl = base.toString();
+        }
+        if (baseUrl.endsWith('/')) {
+          baseUrl = baseUrl.slice(0, baseUrl.length - 1);
+        }
+        if (!url.startsWith('/')) {
+          url = `/${url}`;
+        }
+        if (baseUrl.endsWith(url)) {
+          url = '';
+        }
+        this._url = `${baseUrl}${url}`;
+      }
+    }
+    return (0, _createClass2.default)(URL, [{
+      key: "hash",
+      get: function get() {
+        var hashMatch = this._url.match(/#([^/]*)/);
+        return hashMatch ? `#${hashMatch[1]}` : '';
+      }
+    }, {
+      key: "host",
+      get: function get() {
+        var hostMatch = this._url.match(/^https?:\/\/(?:[^@]+@)?([^:/?#]+)/);
+        var portMatch = this._url.match(/:(\d+)(?=[/?#]|$)/);
+        return hostMatch ? hostMatch[1] + (portMatch ? `:${portMatch[1]}` : '') : '';
+      }
+    }, {
+      key: "hostname",
+      get: function get() {
+        var hostnameMatch = this._url.match(/^https?:\/\/(?:[^@]+@)?([^:/?#]+)/);
+        return hostnameMatch ? hostnameMatch[1] : '';
+      }
+    }, {
+      key: "href",
+      get: function get() {
+        return this.toString();
+      }
+    }, {
+      key: "origin",
+      get: function get() {
+        var matches = this._url.match(/^(https?:\/\/[^/]+)/);
+        return matches ? matches[1] : '';
+      }
+    }, {
+      key: "password",
+      get: function get() {
+        var passwordMatch = this._url.match(/https?:\/\/.*:(.*)@/);
+        return passwordMatch ? passwordMatch[1] : '';
+      }
+    }, {
+      key: "pathname",
+      get: function get() {
+        var pathMatch = this._url.match(/https?:\/\/[^/]+(\/[^?#]*)?/);
+        return pathMatch ? pathMatch[1] || '/' : '/';
+      }
+    }, {
+      key: "port",
+      get: function get() {
+        var portMatch = this._url.match(/:(\d+)(?=[/?#]|$)/);
+        return portMatch ? portMatch[1] : '';
+      }
+    }, {
+      key: "protocol",
+      get: function get() {
+        var protocolMatch = this._url.match(/^([a-zA-Z][a-zA-Z\d+\-.]*):/);
+        return protocolMatch ? protocolMatch[1] + ':' : '';
+      }
+    }, {
+      key: "search",
+      get: function get() {
+        var searchMatch = this._url.match(/\?([^#]*)/);
+        return searchMatch ? `?${searchMatch[1]}` : '';
+      }
+    }, {
+      key: "searchParams",
+      get: function get() {
+        if (this._searchParamsInstance == null) {
+          this._searchParamsInstance = new URLSearchParams(this.search);
+        }
+        return this._searchParamsInstance;
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON() {
+        return this.toString();
+      }
+    }, {
+      key: "toString",
+      value: function toString() {
+        if (this._searchParamsInstance === null) {
+          return this._url;
+        }
+        var instanceString = this._searchParamsInstance.toString();
+        var separator = this._url.indexOf('?') > -1 ? '&' : '?';
+        return this._url + separator + instanceString;
+      }
+    }, {
+      key: "username",
+      get: function get() {
+        var usernameMatch = this._url.match(/^https?:\/\/([^:@]+)(?::[^@]*)?@/);
+        return usernameMatch ? usernameMatch[1] : '';
+      }
+    }], [{
+      key: "createObjectURL",
+      value: function createObjectURL(blob) {
+        if (BLOB_URL_PREFIX === null) {
+          throw new Error('Cannot create URL for blob!');
+        }
+        return `${BLOB_URL_PREFIX}${blob.data.blobId}?offset=${blob.data.offset}&size=${blob.size}`;
+      }
+    }, {
+      key: "revokeObjectURL",
+      value: function revokeObjectURL(url) {}
+    }]);
+  }();
+},262,[1,263,11,12,234],"../../node_modules/react-native/Libraries/Blob/URL.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.URLSearchParams = void 0;
+  var _toConsumableArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/toConsumableArray"));
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/slicedToArray"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass"));
+  var URLSearchParams = exports.URLSearchParams = /*#__PURE__*/function () {
+    function URLSearchParams(params) {
+      var _this = this;
+      (0, _classCallCheck2.default)(this, URLSearchParams);
+      this._searchParams = new Map();
+      if (params === null) {
+        return;
+      }
+      if (typeof params === 'string') {
+        params.replace(/^\?/, '').split('&').forEach(function (pair) {
+          if (!pair) {
+            return;
+          }
+          var _pair$split$map = pair.split('=').map(function (part) {
+              return decodeURIComponent(part.replace(/\+/g, ' '));
+            }),
+            _pair$split$map2 = (0, _slicedToArray2.default)(_pair$split$map, 2),
+            key = _pair$split$map2[0],
+            value = _pair$split$map2[1];
+          _this.append(key, value);
+        });
+      } else if (Array.isArray(params)) {
+        params.forEach(function (_ref) {
+          var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
+            key = _ref2[0],
+            value = _ref2[1];
+          return _this.append(key, value);
+        });
+      } else if (typeof params === 'object') {
+        Object.entries(params).forEach(function (_ref3) {
+          var _ref4 = (0, _slicedToArray2.default)(_ref3, 2),
+            key = _ref4[0],
+            value = _ref4[1];
+          return _this.append(key, value);
+        });
+      }
+    }
+    return (0, _createClass2.default)(URLSearchParams, [{
+      key: "append",
+      value: function append(key, value) {
+        if (!this._searchParams.has(key)) {
+          this._searchParams.set(key, [value]);
+        } else {
+          var _this$_searchParams$g;
+          (_this$_searchParams$g = this._searchParams.get(key)) == null || _this$_searchParams$g.push(value);
+        }
+      }
+    }, {
+      key: "delete",
+      value: function _delete(name) {
+        this._searchParams.delete(name);
+      }
+    }, {
+      key: "get",
+      value: function get(name) {
+        var values = this._searchParams.get(name);
+        return values ? values[0] : null;
+      }
+    }, {
+      key: "getAll",
+      value: function getAll(name) {
+        var _this$_searchParams$g2;
+        return (_this$_searchParams$g2 = this._searchParams.get(name)) != null ? _this$_searchParams$g2 : [];
+      }
+    }, {
+      key: "has",
+      value: function has(name) {
+        return this._searchParams.has(name);
+      }
+    }, {
+      key: "set",
+      value: function set(name, value) {
+        this._searchParams.set(name, [value]);
+      }
+    }, {
+      key: "keys",
+      value: function keys() {
+        return this._searchParams.keys();
+      }
+    }, {
+      key: "values",
+      value: function values() {
+        function* generateValues(params) {
+          for (var valueArray of params.values()) {
+            for (var _value of valueArray) {
+              yield _value;
+            }
+          }
+        }
+        return generateValues(this._searchParams);
+      }
+    }, {
+      key: "entries",
+      value: function entries() {
+        function* generateEntries(params) {
+          for (var _ref5 of params) {
+            var _ref6 = (0, _slicedToArray2.default)(_ref5, 2);
+            var _key = _ref6[0];
+            var values = _ref6[1];
+            for (var _value2 of values) {
+              yield [_key, _value2];
+            }
+          }
+        }
+        return generateEntries(this._searchParams);
+      }
+    }, {
+      key: "forEach",
+      value: function forEach(callback) {
+        for (var _ref7 of this._searchParams) {
+          var _ref8 = (0, _slicedToArray2.default)(_ref7, 2);
+          var _key2 = _ref8[0];
+          var values = _ref8[1];
+          for (var _value3 of values) {
+            callback(_value3, _key2, this);
+          }
+        }
+      }
+    }, {
+      key: "sort",
+      value: function sort() {
+        this._searchParams = new Map((0, _toConsumableArray2.default)(this._searchParams.entries()).sort(function (_ref9, _ref0) {
+          var _ref1 = (0, _slicedToArray2.default)(_ref9, 1),
+            a = _ref1[0];
+          var _ref10 = (0, _slicedToArray2.default)(_ref0, 1),
+            b = _ref10[0];
+          return a.localeCompare(b);
+        }));
+      }
+    }, {
+      key: Symbol.iterator,
+      value: function value() {
+        var entries = [];
+        for (var _ref11 of this._searchParams) {
+          var _ref12 = (0, _slicedToArray2.default)(_ref11, 2);
+          var _key3 = _ref12[0];
+          var values = _ref12[1];
+          for (var _value4 of values) {
+            entries.push([_key3, _value4]);
+          }
+        }
+        return entries[Symbol.iterator]();
+      }
+    }, {
+      key: "toString",
+      value: function toString() {
+        return Array.from(this._searchParams.entries()).map(function (_ref13) {
+          var _ref14 = (0, _slicedToArray2.default)(_ref13, 2),
+            key = _ref14[0],
+            values = _ref14[1];
+          return values.map(function (value) {
+            return `${encodeURIComponent(key).replace(/%20/g, '+')}=${encodeURIComponent(value).replace(/%20/g, '+')}`;
+          }).join('&');
+        }).join('&');
+      }
+    }]);
+  }();
+},263,[1,42,34,11,12],"../../node_modules/react-native/Libraries/Blob/URLSearchParams.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  /**
+   * @author Toru Nagashima <https://github.com/mysticatea>
+   * See LICENSE file in root directory for full license.
+   */
+  'use strict';
+
+  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+  function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  Object.defineProperty(exports, '__esModule', {
+    value: true
+  });
+  /**
+   * The signal class.
+   * @see https://dom.spec.whatwg.org/#abortsignal
+   */
+  var AbortSignal = /*#__PURE__*/function (_eventTargetShim$Even) {
+    /**
+     * AbortSignal cannot be constructed directly.
+     */
+    function AbortSignal() {
+      var _this;
+      _classCallCheck(this, AbortSignal);
+      _this = _callSuper(this, AbortSignal);
+      throw new TypeError("AbortSignal cannot be constructed directly");
+      return _this;
+    }
+    /**
+     * Returns `true` if this `AbortSignal`'s `AbortController` has signaled to abort, and `false` otherwise.
+     */
+    _inherits(AbortSignal, _eventTargetShim$Even);
+    return _createClass(AbortSignal, [{
+      key: "aborted",
+      get: function get() {
+        var aborted = abortedFlags.get(this);
+        if (typeof aborted !== "boolean") {
+          throw new TypeError(`Expected 'this' to be an 'AbortSignal' object, but got ${this === null ? "null" : typeof this}`);
+        }
+        return aborted;
+      }
+    }]);
+  }(_$$_REQUIRE(_dependencyMap[5], "event-target-shim").EventTarget);
+  _$$_REQUIRE(_dependencyMap[5], "event-target-shim").defineEventAttribute(AbortSignal.prototype, "abort");
+  /**
+   * Create an AbortSignal object.
+   */
+  function createAbortSignal() {
+    var signal = Object.create(AbortSignal.prototype);
+    _$$_REQUIRE(_dependencyMap[5], "event-target-shim").EventTarget.call(signal);
+    abortedFlags.set(signal, false);
+    return signal;
+  }
+  /**
+   * Abort a given signal.
+   */
+  function abortSignal(signal) {
+    if (abortedFlags.get(signal) !== false) {
+      return;
+    }
+    abortedFlags.set(signal, true);
+    signal.dispatchEvent({
+      type: "abort"
+    });
+  }
+  /**
+   * Aborted flag for each instances.
+   */
+  var abortedFlags = new WeakMap();
+  // Properties should be enumerable.
+  Object.defineProperties(AbortSignal.prototype, {
+    aborted: {
+      enumerable: true
+    }
+  });
+  // `toString()` should return `"[object AbortSignal]"`
+  if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {
+    Object.defineProperty(AbortSignal.prototype, Symbol.toStringTag, {
+      configurable: true,
+      value: "AbortSignal"
+    });
+  }
+
+  /**
+   * The AbortController.
+   * @see https://dom.spec.whatwg.org/#abortcontroller
+   */
+  var AbortController = /*#__PURE__*/function () {
+    /**
+     * Initialize this controller.
+     */
+    function AbortController() {
+      _classCallCheck(this, AbortController);
+      signals.set(this, createAbortSignal());
+    }
+    /**
+     * Returns the `AbortSignal` object associated with this object.
+     */
+    return _createClass(AbortController, [{
+      key: "signal",
+      get: function get() {
+        return getSignal(this);
+      }
+      /**
+       * Abort and signal to any observers that the associated activity is to be aborted.
+       */
+    }, {
+      key: "abort",
+      value: function abort() {
+        abortSignal(getSignal(this));
+      }
+    }]);
+  }();
+  /**
+   * Associated signals.
+   */
+  var signals = new WeakMap();
+  /**
+   * Get the associated signal of a given controller.
+   */
+  function getSignal(controller) {
+    var signal = signals.get(controller);
+    if (signal == null) {
+      throw new TypeError(`Expected 'this' to be an 'AbortController' object, but got ${controller === null ? "null" : typeof controller}`);
+    }
+    return signal;
+  }
+  // Properties should be enumerable.
+  Object.defineProperties(AbortController.prototype, {
+    signal: {
+      enumerable: true
+    },
+    abort: {
+      enumerable: true
+    }
+  });
+  if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {
+    Object.defineProperty(AbortController.prototype, Symbol.toStringTag, {
+      configurable: true,
+      value: "AbortController"
+    });
+  }
+  exports.AbortController = AbortController;
+  exports.AbortSignal = AbortSignal;
+  exports.default = AbortController;
+  module.exports = AbortController;
+  module.exports.AbortController = module.exports["default"] = AbortController;
+  module.exports.AbortSignal = AbortSignal;
+},264,[11,12,18,20,23,265],"../../node_modules/abort-controller/dist/abort-controller.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _toConsumableArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/toConsumableArray");
+  var _set = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/set");
+  var _get = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/get");
+  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+  var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+  var _wrapNativeSuper = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/wrapNativeSuper");
+  var _classCallCheck = _$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/classCallCheck");
+  var _createClass = _$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/createClass");
+  function _superPropSet(t, e, o, r, p, f) { return _set(_getPrototypeOf(f ? t.prototype : t), e, o, r, p); }
+  function _superPropGet(t, o, e, r) { var p = _get(_getPrototypeOf(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  Object.defineProperty(exports, '__esModule', {
+    value: true
+  });
+
+  /**
+   * Assert a condition.
+   * @param condition The condition that it should satisfy.
+   * @param message The error message.
+   * @param args The arguments for replacing placeholders in the message.
+   */
+  function assertType(condition, message) {
+    if (!condition) {
+      for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+        args[_key - 2] = arguments[_key];
+      }
+      throw new TypeError(format(message, args));
+    }
+  }
+  /**
+   * Convert a text and arguments to one string.
+   * @param message The formating text
+   * @param args The arguments.
+   */
+  function format(message, args) {
+    var i = 0;
+    return message.replace(/%[os]/g, function () {
+      return anyToString(args[i++]);
+    });
+  }
+  /**
+   * Convert a value to a string representation.
+   * @param x The value to get the string representation.
+   */
+  function anyToString(x) {
+    if (typeof x !== "object" || x === null) {
+      return String(x);
+    }
+    return Object.prototype.toString.call(x);
+  }
+  var currentErrorHandler;
+  /**
+   * Set the error handler.
+   * @param value The error handler to set.
+   */
+  function setErrorHandler(value) {
+    assertType(typeof value === "function" || value === undefined, "The error handler must be a function or undefined, but got %o.", value);
+    currentErrorHandler = value;
+  }
+  /**
+   * Print a error message.
+   * @param maybeError The error object.
+   */
+  function reportError(maybeError) {
+    try {
+      var error = maybeError instanceof Error ? maybeError : new Error(anyToString(maybeError));
+      // Call the user-defined error handler if exists.
+      if (currentErrorHandler) {
+        currentErrorHandler(error);
+        return;
+      }
+      // Dispatch an `error` event if this is on a browser.
+      if (typeof dispatchEvent === "function" && typeof ErrorEvent === "function") {
+        dispatchEvent(new ErrorEvent("error", {
+          error: error,
+          message: error.message
+        }));
+      }
+      // Emit an `uncaughtException` event if this is on Node.js.
+      //istanbul ignore else
+      else if (typeof process !== "undefined" && typeof process.emit === "function") {
+        process.emit("uncaughtException", error);
+        return;
+      }
+      // Otherwise, print the error.
+      console.error(error);
+    } catch (_a) {
+      // ignore.
+    }
+  }
+
+  /**
+   * The global object.
+   */
+  //istanbul ignore next
+  var Global = typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : typeof global !== "undefined" ? global : typeof globalThis !== "undefined" ? globalThis : undefined;
+  var currentWarnHandler;
+  /**
+   * Set the warning handler.
+   * @param value The warning handler to set.
+   */
+  function setWarningHandler(value) {
+    assertType(typeof value === "function" || value === undefined, "The warning handler must be a function or undefined, but got %o.", value);
+    currentWarnHandler = value;
+  }
+  /**
+   * The warning information.
+   */
+  var Warning = /*#__PURE__*/function () {
+    function Warning(code, message) {
+      _classCallCheck(this, Warning);
+      this.code = code;
+      this.message = message;
+    }
+    /**
+     * Report this warning.
+     * @param args The arguments of the warning.
+     */
+    return _createClass(Warning, [{
+      key: "warn",
+      value: function warn() {
+        var _a;
+        try {
+          var _console;
+          for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+            args[_key2] = arguments[_key2];
+          }
+          // Call the user-defined warning handler if exists.
+          if (currentWarnHandler) {
+            currentWarnHandler(Object.assign({}, this, {
+              args: args
+            }));
+            return;
+          }
+          // Otherwise, print the warning.
+          var stack = ((_a = new Error().stack) !== null && _a !== void 0 ? _a : "").replace(/^(?:(?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+?\n){2}/g, "\n");
+          (_console = console).warn.apply(_console, [this.message].concat(args, [stack]));
+        } catch (_b) {
+          // Ignore.
+        }
+      }
+    }]);
+  }();
+  var InitEventWasCalledWhileDispatching = new Warning("W01", "Unable to initialize event under dispatching.");
+  var FalsyWasAssignedToCancelBubble = new Warning("W02", "Assigning any falsy value to 'cancelBubble' property has no effect.");
+  var TruthyWasAssignedToReturnValue = new Warning("W03", "Assigning any truthy value to 'returnValue' property has no effect.");
+  var NonCancelableEventWasCanceled = new Warning("W04", "Unable to preventDefault on non-cancelable events.");
+  var CanceledInPassiveListener = new Warning("W05", "Unable to preventDefault inside passive event listener invocation.");
+  var EventListenerWasDuplicated = new Warning("W06", "An event listener wasn't added because it has been added already: %o, %o");
+  var OptionWasIgnored = new Warning("W07", "The %o option value was abandoned because the event listener wasn't added as duplicated.");
+  var InvalidEventListener = new Warning("W08", "The 'callback' argument must be a function or an object that has 'handleEvent' method: %o");
+  var InvalidAttributeHandler = new Warning("W09", "Event attribute handler must be a function: %o");
+
+  /*eslint-disable class-methods-use-this */
+  /**
+   * An implementation of `Event` interface, that wraps a given event object.
+   * `EventTarget` shim can control the internal state of this `Event` objects.
+   * @see https://dom.spec.whatwg.org/#event
+   */
+  var Event = /*#__PURE__*/function () {
+    /**
+     * Initialize this event instance.
+     * @param type The type of this event.
+     * @param eventInitDict Options to initialize.
+     * @see https://dom.spec.whatwg.org/#dom-event-event
+     */
+    function Event(type, eventInitDict) {
+      _classCallCheck(this, Event);
+      Object.defineProperty(this, "isTrusted", {
+        value: false,
+        enumerable: true
+      });
+      var opts = eventInitDict !== null && eventInitDict !== void 0 ? eventInitDict : {};
+      internalDataMap.set(this, {
+        type: String(type),
+        bubbles: Boolean(opts.bubbles),
+        cancelable: Boolean(opts.cancelable),
+        composed: Boolean(opts.composed),
+        target: null,
+        currentTarget: null,
+        stopPropagationFlag: false,
+        stopImmediatePropagationFlag: false,
+        canceledFlag: false,
+        inPassiveListenerFlag: false,
+        dispatchFlag: false,
+        timeStamp: Date.now()
+      });
+    }
+    /**
+     * The type of this event.
+     * @see https://dom.spec.whatwg.org/#dom-event-type
+     */
+    return _createClass(Event, [{
+      key: "type",
+      get: function get() {
+        return $(this).type;
+      }
+      /**
+       * The event target of the current dispatching.
+       * @see https://dom.spec.whatwg.org/#dom-event-target
+       */
+    }, {
+      key: "target",
+      get: function get() {
+        return $(this).target;
+      }
+      /**
+       * The event target of the current dispatching.
+       * @deprecated Use the `target` property instead.
+       * @see https://dom.spec.whatwg.org/#dom-event-srcelement
+       */
+    }, {
+      key: "srcElement",
+      get: function get() {
+        return $(this).target;
+      }
+      /**
+       * The event target of the current dispatching.
+       * @see https://dom.spec.whatwg.org/#dom-event-currenttarget
+       */
+    }, {
+      key: "currentTarget",
+      get: function get() {
+        return $(this).currentTarget;
+      }
+      /**
+       * The event target of the current dispatching.
+       * This doesn't support node tree.
+       * @see https://dom.spec.whatwg.org/#dom-event-composedpath
+       */
+    }, {
+      key: "composedPath",
+      value: function composedPath() {
+        var currentTarget = $(this).currentTarget;
+        if (currentTarget) {
+          return [currentTarget];
+        }
+        return [];
+      }
+      /**
+       * @see https://dom.spec.whatwg.org/#dom-event-none
+       */
+    }, {
+      key: "NONE",
+      get: function get() {
+        return NONE;
+      }
+      /**
+       * @see https://dom.spec.whatwg.org/#dom-event-capturing_phase
+       */
+    }, {
+      key: "CAPTURING_PHASE",
+      get: function get() {
+        return CAPTURING_PHASE;
+      }
+      /**
+       * @see https://dom.spec.whatwg.org/#dom-event-at_target
+       */
+    }, {
+      key: "AT_TARGET",
+      get: function get() {
+        return AT_TARGET;
+      }
+      /**
+       * @see https://dom.spec.whatwg.org/#dom-event-bubbling_phase
+       */
+    }, {
+      key: "BUBBLING_PHASE",
+      get: function get() {
+        return BUBBLING_PHASE;
+      }
+      /**
+       * The current event phase.
+       * @see https://dom.spec.whatwg.org/#dom-event-eventphase
+       */
+    }, {
+      key: "eventPhase",
+      get: function get() {
+        return $(this).dispatchFlag ? 2 : 0;
+      }
+      /**
+       * Stop event bubbling.
+       * Because this shim doesn't support node tree, this merely changes the `cancelBubble` property value.
+       * @see https://dom.spec.whatwg.org/#dom-event-stoppropagation
+       */
+    }, {
+      key: "stopPropagation",
+      value: function stopPropagation() {
+        $(this).stopPropagationFlag = true;
+      }
+      /**
+       * `true` if event bubbling was stopped.
+       * @deprecated
+       * @see https://dom.spec.whatwg.org/#dom-event-cancelbubble
+       */
+    }, {
+      key: "cancelBubble",
+      get: function get() {
+        return $(this).stopPropagationFlag;
+      }
+      /**
+       * Stop event bubbling if `true` is set.
+       * @deprecated Use the `stopPropagation()` method instead.
+       * @see https://dom.spec.whatwg.org/#dom-event-cancelbubble
+       */,
+      set: function set(value) {
+        if (value) {
+          $(this).stopPropagationFlag = true;
+        } else {
+          FalsyWasAssignedToCancelBubble.warn();
+        }
+      }
+      /**
+       * Stop event bubbling and subsequent event listener callings.
+       * @see https://dom.spec.whatwg.org/#dom-event-stopimmediatepropagation
+       */
+    }, {
+      key: "stopImmediatePropagation",
+      value: function stopImmediatePropagation() {
+        var data = $(this);
+        data.stopPropagationFlag = data.stopImmediatePropagationFlag = true;
+      }
+      /**
+       * `true` if this event will bubble.
+       * @see https://dom.spec.whatwg.org/#dom-event-bubbles
+       */
+    }, {
+      key: "bubbles",
+      get: function get() {
+        return $(this).bubbles;
+      }
+      /**
+       * `true` if this event can be canceled by the `preventDefault()` method.
+       * @see https://dom.spec.whatwg.org/#dom-event-cancelable
+       */
+    }, {
+      key: "cancelable",
+      get: function get() {
+        return $(this).cancelable;
+      }
+      /**
+       * `true` if the default behavior will act.
+       * @deprecated Use the `defaultPrevented` proeprty instead.
+       * @see https://dom.spec.whatwg.org/#dom-event-returnvalue
+       */
+    }, {
+      key: "returnValue",
+      get: function get() {
+        return !$(this).canceledFlag;
+      }
+      /**
+       * Cancel the default behavior if `false` is set.
+       * @deprecated Use the `preventDefault()` method instead.
+       * @see https://dom.spec.whatwg.org/#dom-event-returnvalue
+       */,
+      set: function set(value) {
+        if (!value) {
+          setCancelFlag($(this));
+        } else {
+          TruthyWasAssignedToReturnValue.warn();
+        }
+      }
+      /**
+       * Cancel the default behavior.
+       * @see https://dom.spec.whatwg.org/#dom-event-preventdefault
+       */
+    }, {
+      key: "preventDefault",
+      value: function preventDefault() {
+        setCancelFlag($(this));
+      }
+      /**
+       * `true` if the default behavior was canceled.
+       * @see https://dom.spec.whatwg.org/#dom-event-defaultprevented
+       */
+    }, {
+      key: "defaultPrevented",
+      get: function get() {
+        return $(this).canceledFlag;
+      }
+      /**
+       * @see https://dom.spec.whatwg.org/#dom-event-composed
+       */
+    }, {
+      key: "composed",
+      get: function get() {
+        return $(this).composed;
+      }
+      /**
+       * @see https://dom.spec.whatwg.org/#dom-event-istrusted
+       */
+      //istanbul ignore next
+    }, {
+      key: "isTrusted",
+      get: function get() {
+        return false;
+      }
+      /**
+       * @see https://dom.spec.whatwg.org/#dom-event-timestamp
+       */
+    }, {
+      key: "timeStamp",
+      get: function get() {
+        return $(this).timeStamp;
+      }
+      /**
+       * @deprecated Don't use this method. The constructor did initialization.
+       */
+    }, {
+      key: "initEvent",
+      value: function initEvent(type) {
+        var bubbles = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+        var cancelable = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+        var data = $(this);
+        if (data.dispatchFlag) {
+          InitEventWasCalledWhileDispatching.warn();
+          return;
+        }
+        internalDataMap.set(this, Object.assign({}, data, {
+          type: String(type),
+          bubbles: Boolean(bubbles),
+          cancelable: Boolean(cancelable),
+          target: null,
+          currentTarget: null,
+          stopPropagationFlag: false,
+          stopImmediatePropagationFlag: false,
+          canceledFlag: false
+        }));
+      }
+    }], [{
+      key: "NONE",
+      get:
+      /**
+       * @see https://dom.spec.whatwg.org/#dom-event-none
+       */
+      function get() {
+        return NONE;
+      }
+      /**
+       * @see https://dom.spec.whatwg.org/#dom-event-capturing_phase
+       */
+    }, {
+      key: "CAPTURING_PHASE",
+      get: function get() {
+        return CAPTURING_PHASE;
+      }
+      /**
+       * @see https://dom.spec.whatwg.org/#dom-event-at_target
+       */
+    }, {
+      key: "AT_TARGET",
+      get: function get() {
+        return AT_TARGET;
+      }
+      /**
+       * @see https://dom.spec.whatwg.org/#dom-event-bubbling_phase
+       */
+    }, {
+      key: "BUBBLING_PHASE",
+      get: function get() {
+        return BUBBLING_PHASE;
+      }
+    }]);
+  }(); //------------------------------------------------------------------------------
+  // Helpers
+  //------------------------------------------------------------------------------
+  var NONE = 0;
+  var CAPTURING_PHASE = 1;
+  var AT_TARGET = 2;
+  var BUBBLING_PHASE = 3;
+  /**
+   * Private data for event wrappers.
+   */
+  var internalDataMap = new WeakMap();
+  /**
+   * Get private data.
+   * @param event The event object to get private data.
+   * @param name The variable name to report.
+   * @returns The private data of the event.
+   */
+  function $(event) {
+    var name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "this";
+    var retv = internalDataMap.get(event);
+    assertType(retv != null, "'%s' must be an object that Event constructor created, but got another one: %o", name, event);
+    return retv;
+  }
+  /**
+   * https://dom.spec.whatwg.org/#set-the-canceled-flag
+   * @param data private data.
+   */
+  function setCancelFlag(data) {
+    if (data.inPassiveListenerFlag) {
+      CanceledInPassiveListener.warn();
+      return;
+    }
+    if (!data.cancelable) {
+      NonCancelableEventWasCanceled.warn();
+      return;
+    }
+    data.canceledFlag = true;
+  }
+  // Set enumerable
+  Object.defineProperty(Event, "NONE", {
+    enumerable: true
+  });
+  Object.defineProperty(Event, "CAPTURING_PHASE", {
+    enumerable: true
+  });
+  Object.defineProperty(Event, "AT_TARGET", {
+    enumerable: true
+  });
+  Object.defineProperty(Event, "BUBBLING_PHASE", {
+    enumerable: true
+  });
+  var keys = Object.getOwnPropertyNames(Event.prototype);
+  for (var i = 0; i < keys.length; ++i) {
+    if (keys[i] === "constructor") {
+      continue;
+    }
+    Object.defineProperty(Event.prototype, keys[i], {
+      enumerable: true
+    });
+  }
+  // Ensure `event instanceof window.Event` is `true`.
+  if (typeof Global !== "undefined" && typeof Global.Event !== "undefined") {
+    Object.setPrototypeOf(Event.prototype, Global.Event.prototype);
+  }
+
+  /**
+   * Create a new InvalidStateError instance.
+   * @param message The error message.
+   */
+  function createInvalidStateError(message) {
+    if (Global.DOMException) {
+      return new Global.DOMException(message, "InvalidStateError");
+    }
+    if (DOMException == null) {
+      DOMException = /*#__PURE__*/function (_Error) {
+        function DOMException(msg) {
+          var _this;
+          _classCallCheck(this, DOMException);
+          _this = _callSuper(this, DOMException, [msg]);
+          if (Error.captureStackTrace) {
+            Error.captureStackTrace(_this, DOMException);
+          }
+          return _this;
+        }
+        // eslint-disable-next-line class-methods-use-this
+        _inherits(DOMException, _Error);
+        return _createClass(DOMException, [{
+          key: "code",
+          get: function get() {
+            return 11;
+          }
+          // eslint-disable-next-line class-methods-use-this
+        }, {
+          key: "name",
+          get: function get() {
+            return "InvalidStateError";
+          }
+        }]);
+      }(/*#__PURE__*/_wrapNativeSuper(Error));
+      Object.defineProperties(DOMException.prototype, {
+        code: {
+          enumerable: true
+        },
+        name: {
+          enumerable: true
+        }
+      });
+      defineErrorCodeProperties(DOMException);
+      defineErrorCodeProperties(DOMException.prototype);
+    }
+    return new DOMException(message);
+  }
+  //------------------------------------------------------------------------------
+  // Helpers
+  //------------------------------------------------------------------------------
+  var DOMException;
+  var ErrorCodeMap = {
+    INDEX_SIZE_ERR: 1,
+    DOMSTRING_SIZE_ERR: 2,
+    HIERARCHY_REQUEST_ERR: 3,
+    WRONG_DOCUMENT_ERR: 4,
+    INVALID_CHARACTER_ERR: 5,
+    NO_DATA_ALLOWED_ERR: 6,
+    NO_MODIFICATION_ALLOWED_ERR: 7,
+    NOT_FOUND_ERR: 8,
+    NOT_SUPPORTED_ERR: 9,
+    INUSE_ATTRIBUTE_ERR: 10,
+    INVALID_STATE_ERR: 11,
+    SYNTAX_ERR: 12,
+    INVALID_MODIFICATION_ERR: 13,
+    NAMESPACE_ERR: 14,
+    INVALID_ACCESS_ERR: 15,
+    VALIDATION_ERR: 16,
+    TYPE_MISMATCH_ERR: 17,
+    SECURITY_ERR: 18,
+    NETWORK_ERR: 19,
+    ABORT_ERR: 20,
+    URL_MISMATCH_ERR: 21,
+    QUOTA_EXCEEDED_ERR: 22,
+    TIMEOUT_ERR: 23,
+    INVALID_NODE_TYPE_ERR: 24,
+    DATA_CLONE_ERR: 25
+  };
+  function defineErrorCodeProperties(obj) {
+    var keys = Object.keys(ErrorCodeMap);
+    var _loop = function _loop() {
+      var key = keys[_i];
+      var value = ErrorCodeMap[key];
+      Object.defineProperty(obj, key, {
+        get: function get() {
+          return value;
+        },
+        configurable: true,
+        enumerable: true
+      });
+    };
+    for (var _i = 0; _i < keys.length; ++_i) {
+      _loop();
+    }
+  }
+
+  /**
+   * An implementation of `Event` interface, that wraps a given event object.
+   * This class controls the internal state of `Event`.
+   * @see https://dom.spec.whatwg.org/#interface-event
+   */
+  var EventWrapper = /*#__PURE__*/function (_Event) {
+    function EventWrapper(event) {
+      var _this2;
+      _classCallCheck(this, EventWrapper);
+      _this2 = _callSuper(this, EventWrapper, [event.type, {
+        bubbles: event.bubbles,
+        cancelable: event.cancelable,
+        composed: event.composed
+      }]);
+      if (event.cancelBubble) {
+        _superPropGet((_this2, EventWrapper), "stopPropagation", _this2, 3)([]);
+      }
+      if (event.defaultPrevented) {
+        _superPropGet((_this2, EventWrapper), "preventDefault", _this2, 3)([]);
+      }
+      internalDataMap$1.set(_this2, {
+        original: event
+      });
+      // Define accessors
+      var keys = Object.keys(event);
+      for (var _i2 = 0; _i2 < keys.length; ++_i2) {
+        var key = keys[_i2];
+        if (!(key in _this2)) {
+          Object.defineProperty(_this2, key, defineRedirectDescriptor(event, key));
+        }
+      }
+      return _this2;
+    }
+    _inherits(EventWrapper, _Event);
+    return _createClass(EventWrapper, [{
+      key: "stopPropagation",
+      value: function stopPropagation() {
+        _superPropGet(EventWrapper, "stopPropagation", this, 3)([]);
+        var _$$ = $$1(this),
+          original = _$$.original;
+        if ("stopPropagation" in original) {
+          original.stopPropagation();
+        }
+      }
+    }, {
+      key: "cancelBubble",
+      get: function get() {
+        return _superPropGet(EventWrapper, "cancelBubble", this, 1);
+      },
+      set: function set(value) {
+        _superPropSet(EventWrapper, "cancelBubble", value, this, 1, 1);
+        var _$$2 = $$1(this),
+          original = _$$2.original;
+        if ("cancelBubble" in original) {
+          original.cancelBubble = value;
+        }
+      }
+    }, {
+      key: "stopImmediatePropagation",
+      value: function stopImmediatePropagation() {
+        _superPropGet(EventWrapper, "stopImmediatePropagation", this, 3)([]);
+        var _$$3 = $$1(this),
+          original = _$$3.original;
+        if ("stopImmediatePropagation" in original) {
+          original.stopImmediatePropagation();
+        }
+      }
+    }, {
+      key: "returnValue",
+      get: function get() {
+        return _superPropGet(EventWrapper, "returnValue", this, 1);
+      },
+      set: function set(value) {
+        _superPropSet(EventWrapper, "returnValue", value, this, 1, 1);
+        var _$$4 = $$1(this),
+          original = _$$4.original;
+        if ("returnValue" in original) {
+          original.returnValue = value;
+        }
+      }
+    }, {
+      key: "preventDefault",
+      value: function preventDefault() {
+        _superPropGet(EventWrapper, "preventDefault", this, 3)([]);
+        var _$$5 = $$1(this),
+          original = _$$5.original;
+        if ("preventDefault" in original) {
+          original.preventDefault();
+        }
+      }
+    }, {
+      key: "timeStamp",
+      get: function get() {
+        var _$$6 = $$1(this),
+          original = _$$6.original;
+        if ("timeStamp" in original) {
+          return original.timeStamp;
+        }
+        return _superPropGet(EventWrapper, "timeStamp", this, 1);
+      }
+    }], [{
+      key: "wrap",
+      value:
+      /**
+       * Wrap a given event object to control states.
+       * @param event The event-like object to wrap.
+       */
+      function wrap(event) {
+        return new (getWrapperClassOf(event))(event);
+      }
+    }]);
+  }(Event);
+  /**
+   * Private data for event wrappers.
+   */
+  var internalDataMap$1 = new WeakMap();
+  /**
+   * Get private data.
+   * @param event The event object to get private data.
+   * @returns The private data of the event.
+   */
+  function $$1(event) {
+    var retv = internalDataMap$1.get(event);
+    assertType(retv != null, "'this' is expected an Event object, but got", event);
+    return retv;
+  }
+  /**
+   * Cache for wrapper classes.
+   * @type {WeakMap<Object, Function>}
+   * @private
+   */
+  var wrapperClassCache = new WeakMap();
+  // Make association for wrappers.
+  wrapperClassCache.set(Object.prototype, EventWrapper);
+  if (typeof Global !== "undefined" && typeof Global.Event !== "undefined") {
+    wrapperClassCache.set(Global.Event.prototype, EventWrapper);
+  }
+  /**
+   * Get the wrapper class of a given prototype.
+   * @param originalEvent The event object to wrap.
+   */
+  function getWrapperClassOf(originalEvent) {
+    var prototype = Object.getPrototypeOf(originalEvent);
+    if (prototype == null) {
+      return EventWrapper;
+    }
+    var wrapper = wrapperClassCache.get(prototype);
+    if (wrapper == null) {
+      wrapper = defineWrapper(getWrapperClassOf(prototype), prototype);
+      wrapperClassCache.set(prototype, wrapper);
+    }
+    return wrapper;
+  }
+  /**
+   * Define new wrapper class.
+   * @param BaseEventWrapper The base wrapper class.
+   * @param originalPrototype The prototype of the original event.
+   */
+  function defineWrapper(BaseEventWrapper, originalPrototype) {
+    var CustomEventWrapper = /*#__PURE__*/function (_BaseEventWrapper) {
+      function CustomEventWrapper() {
+        _classCallCheck(this, CustomEventWrapper);
+        return _callSuper(this, CustomEventWrapper, arguments);
+      }
+      _inherits(CustomEventWrapper, _BaseEventWrapper);
+      return _createClass(CustomEventWrapper);
+    }(BaseEventWrapper);
+    var keys = Object.keys(originalPrototype);
+    for (var _i3 = 0; _i3 < keys.length; ++_i3) {
+      Object.defineProperty(CustomEventWrapper.prototype, keys[_i3], defineRedirectDescriptor(originalPrototype, keys[_i3]));
+    }
+    return CustomEventWrapper;
+  }
+  /**
+   * Get the property descriptor to redirect a given property.
+   */
+  function defineRedirectDescriptor(obj, key) {
+    var d = Object.getOwnPropertyDescriptor(obj, key);
+    return {
+      get: function get() {
+        var original = $$1(this).original;
+        var value = original[key];
+        if (typeof value === "function") {
+          return value.bind(original);
+        }
+        return value;
+      },
+      set: function set(value) {
+        var original = $$1(this).original;
+        original[key] = value;
+      },
+      configurable: d.configurable,
+      enumerable: d.enumerable
+    };
+  }
+
+  /**
+   * Create a new listener.
+   * @param callback The callback function.
+   * @param capture The capture flag.
+   * @param passive The passive flag.
+   * @param once The once flag.
+   * @param signal The abort signal.
+   * @param signalListener The abort event listener for the abort signal.
+   */
+  function createListener(callback, capture, passive, once, signal, signalListener) {
+    return {
+      callback: callback,
+      flags: (capture ? 1 /* Capture */ : 0) | (passive ? 2 /* Passive */ : 0) | (once ? 4 /* Once */ : 0),
+      signal: signal,
+      signalListener: signalListener
+    };
+  }
+  /**
+   * Set the `removed` flag to the given listener.
+   * @param listener The listener to check.
+   */
+  function setRemoved(listener) {
+    listener.flags |= 8 /* Removed */;
+  }
+  /**
+   * Check if the given listener has the `capture` flag or not.
+   * @param listener The listener to check.
+   */
+  function isCapture(listener) {
+    return (listener.flags & 1 /* Capture */) === 1 /* Capture */;
+  }
+  /**
+   * Check if the given listener has the `passive` flag or not.
+   * @param listener The listener to check.
+   */
+  function isPassive(listener) {
+    return (listener.flags & 2 /* Passive */) === 2 /* Passive */;
+  }
+  /**
+   * Check if the given listener has the `once` flag or not.
+   * @param listener The listener to check.
+   */
+  function isOnce(listener) {
+    return (listener.flags & 4 /* Once */) === 4 /* Once */;
+  }
+  /**
+   * Check if the given listener has the `removed` flag or not.
+   * @param listener The listener to check.
+   */
+  function isRemoved(listener) {
+    return (listener.flags & 8 /* Removed */) === 8 /* Removed */;
+  }
+  /**
+   * Call an event listener.
+   * @param listener The listener to call.
+   * @param target The event target object for `thisArg`.
+   * @param event The event object for the first argument.
+   * @param attribute `true` if this callback is an event attribute handler.
+   */
+  function invokeCallback(_ref, target, event) {
+    var callback = _ref.callback;
+    try {
+      if (typeof callback === "function") {
+        callback.call(target, event);
+      } else if (typeof callback.handleEvent === "function") {
+        callback.handleEvent(event);
+      }
+    } catch (thrownError) {
+      reportError(thrownError);
+    }
+  }
+
+  /**
+   * Find the index of given listener.
+   * This returns `-1` if not found.
+   * @param list The listener list.
+   * @param callback The callback function to find.
+   * @param capture The capture flag to find.
+   */
+  function findIndexOfListener(_ref2, callback, capture) {
+    var listeners = _ref2.listeners;
+    for (var _i4 = 0; _i4 < listeners.length; ++_i4) {
+      if (listeners[_i4].callback === callback && isCapture(listeners[_i4]) === capture) {
+        return _i4;
+      }
+    }
+    return -1;
+  }
+  /**
+   * Add the given listener.
+   * Does copy-on-write if needed.
+   * @param list The listener list.
+   * @param callback The callback function.
+   * @param capture The capture flag.
+   * @param passive The passive flag.
+   * @param once The once flag.
+   * @param signal The abort signal.
+   */
+  function addListener(list, callback, capture, passive, once, signal) {
+    var signalListener;
+    if (signal) {
+      signalListener = removeListener.bind(null, list, callback, capture);
+      signal.addEventListener("abort", signalListener);
+    }
+    var listener = createListener(callback, capture, passive, once, signal, signalListener);
+    if (list.cow) {
+      list.cow = false;
+      list.listeners = [].concat(_toConsumableArray(list.listeners), [listener]);
+    } else {
+      list.listeners.push(listener);
+    }
+    return listener;
+  }
+  /**
+   * Remove a listener.
+   * @param list The listener list.
+   * @param callback The callback function to find.
+   * @param capture The capture flag to find.
+   * @returns `true` if it mutated the list directly.
+   */
+  function removeListener(list, callback, capture) {
+    var index = findIndexOfListener(list, callback, capture);
+    if (index !== -1) {
+      return removeListenerAt(list, index);
+    }
+    return false;
+  }
+  /**
+   * Remove a listener.
+   * @param list The listener list.
+   * @param index The index of the target listener.
+   * @param disableCow Disable copy-on-write if true.
+   * @returns `true` if it mutated the `listeners` array directly.
+   */
+  function removeListenerAt(list, index) {
+    var disableCow = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    var listener = list.listeners[index];
+    // Set the removed flag.
+    setRemoved(listener);
+    // Dispose the abort signal listener if exists.
+    if (listener.signal) {
+      listener.signal.removeEventListener("abort", listener.signalListener);
+    }
+    // Remove it from the array.
+    if (list.cow && !disableCow) {
+      list.cow = false;
+      list.listeners = list.listeners.filter(function (_, i) {
+        return i !== index;
+      });
+      return false;
+    }
+    list.listeners.splice(index, 1);
+    return true;
+  }
+
+  /**
+   * Create a new `ListenerListMap` object.
+   */
+  function createListenerListMap() {
+    return Object.create(null);
+  }
+  /**
+   * Get the listener list of the given type.
+   * If the listener list has not been initialized, initialize and return it.
+   * @param listenerMap The listener list map.
+   * @param type The event type to get.
+   */
+  function ensureListenerList(listenerMap, type) {
+    var _a;
+    return (_a = listenerMap[type]) !== null && _a !== void 0 ? _a : listenerMap[type] = {
+      attrCallback: undefined,
+      attrListener: undefined,
+      cow: false,
+      listeners: []
+    };
+  }
+
+  /**
+   * An implementation of the `EventTarget` interface.
+   * @see https://dom.spec.whatwg.org/#eventtarget
+   */
+  var EventTarget = /*#__PURE__*/function () {
+    /**
+     * Initialize this instance.
+     */
+    function EventTarget() {
+      _classCallCheck(this, EventTarget);
+      internalDataMap$2.set(this, createListenerListMap());
+    }
+    // Implementation
+    return _createClass(EventTarget, [{
+      key: "addEventListener",
+      value: function addEventListener(type0, callback0, options0) {
+        var listenerMap = $$2(this);
+        var _normalizeAddOptions = normalizeAddOptions(type0, callback0, options0),
+          callback = _normalizeAddOptions.callback,
+          capture = _normalizeAddOptions.capture,
+          once = _normalizeAddOptions.once,
+          passive = _normalizeAddOptions.passive,
+          signal = _normalizeAddOptions.signal,
+          type = _normalizeAddOptions.type;
+        if (callback == null || (signal === null || signal === void 0 ? void 0 : signal.aborted)) {
+          return;
+        }
+        var list = ensureListenerList(listenerMap, type);
+        // Find existing listener.
+        var i = findIndexOfListener(list, callback, capture);
+        if (i !== -1) {
+          warnDuplicate(list.listeners[i], passive, once, signal);
+          return;
+        }
+        // Add the new listener.
+        addListener(list, callback, capture, passive, once, signal);
+      }
+      // Implementation
+    }, {
+      key: "removeEventListener",
+      value: function removeEventListener(type0, callback0, options0) {
+        var listenerMap = $$2(this);
+        var _normalizeOptions = normalizeOptions(type0, callback0, options0),
+          callback = _normalizeOptions.callback,
+          capture = _normalizeOptions.capture,
+          type = _normalizeOptions.type;
+        var list = listenerMap[type];
+        if (callback != null && list) {
+          removeListener(list, callback, capture);
+        }
+      }
+      // Implementation
+    }, {
+      key: "dispatchEvent",
+      value: function dispatchEvent(e) {
+        var list = $$2(this)[String(e.type)];
+        if (list == null) {
+          return true;
+        }
+        var event = e instanceof Event ? e : EventWrapper.wrap(e);
+        var eventData = $(event, "event");
+        if (eventData.dispatchFlag) {
+          throw createInvalidStateError("This event has been in dispatching.");
+        }
+        eventData.dispatchFlag = true;
+        eventData.target = eventData.currentTarget = this;
+        if (!eventData.stopPropagationFlag) {
+          var cow = list.cow,
+            listeners = list.listeners;
+          // Set copy-on-write flag.
+          list.cow = true;
+          // Call listeners.
+          for (var _i5 = 0; _i5 < listeners.length; ++_i5) {
+            var listener = listeners[_i5];
+            // Skip if removed.
+            if (isRemoved(listener)) {
+              continue;
+            }
+            // Remove this listener if has the `once` flag.
+            if (isOnce(listener) && removeListenerAt(list, _i5, !cow)) {
+              // Because this listener was removed, the next index is the
+              // same as the current value.
+              _i5 -= 1;
+            }
+            // Call this listener with the `passive` flag.
+            eventData.inPassiveListenerFlag = isPassive(listener);
+            invokeCallback(listener, this, event);
+            eventData.inPassiveListenerFlag = false;
+            // Stop if the `event.stopImmediatePropagation()` method was called.
+            if (eventData.stopImmediatePropagationFlag) {
+              break;
+            }
+          }
+          // Restore copy-on-write flag.
+          if (!cow) {
+            list.cow = false;
+          }
+        }
+        eventData.target = null;
+        eventData.currentTarget = null;
+        eventData.stopImmediatePropagationFlag = false;
+        eventData.stopPropagationFlag = false;
+        eventData.dispatchFlag = false;
+        return !eventData.canceledFlag;
+      }
+    }]);
+  }();
+  /**
+   * Internal data.
+   */
+  var internalDataMap$2 = new WeakMap();
+  /**
+   * Get private data.
+   * @param target The event target object to get private data.
+   * @param name The variable name to report.
+   * @returns The private data of the event.
+   */
+  function $$2(target) {
+    var name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "this";
+    var retv = internalDataMap$2.get(target);
+    assertType(retv != null, "'%s' must be an object that EventTarget constructor created, but got another one: %o", name, target);
+    return retv;
+  }
+  /**
+   * Normalize options.
+   * @param options The options to normalize.
+   */
+  function normalizeAddOptions(type, callback, options) {
+    var _a;
+    assertCallback(callback);
+    if (typeof options === "object" && options !== null) {
+      return {
+        type: String(type),
+        callback: callback !== null && callback !== void 0 ? callback : undefined,
+        capture: Boolean(options.capture),
+        passive: Boolean(options.passive),
+        once: Boolean(options.once),
+        signal: (_a = options.signal) !== null && _a !== void 0 ? _a : undefined
+      };
+    }
+    return {
+      type: String(type),
+      callback: callback !== null && callback !== void 0 ? callback : undefined,
+      capture: Boolean(options),
+      passive: false,
+      once: false,
+      signal: undefined
+    };
+  }
+  /**
+   * Normalize options.
+   * @param options The options to normalize.
+   */
+  function normalizeOptions(type, callback, options) {
+    assertCallback(callback);
+    if (typeof options === "object" && options !== null) {
+      return {
+        type: String(type),
+        callback: callback !== null && callback !== void 0 ? callback : undefined,
+        capture: Boolean(options.capture)
+      };
+    }
+    return {
+      type: String(type),
+      callback: callback !== null && callback !== void 0 ? callback : undefined,
+      capture: Boolean(options)
+    };
+  }
+  /**
+   * Assert the type of 'callback' argument.
+   * @param callback The callback to check.
+   */
+  function assertCallback(callback) {
+    if (typeof callback === "function" || typeof callback === "object" && callback !== null && typeof callback.handleEvent === "function") {
+      return;
+    }
+    if (callback == null || typeof callback === "object") {
+      InvalidEventListener.warn(callback);
+      return;
+    }
+    throw new TypeError(format(InvalidEventListener.message, [callback]));
+  }
+  /**
+   * Print warning for duplicated.
+   * @param listener The current listener that is duplicated.
+   * @param passive The passive flag of the new duplicated listener.
+   * @param once The once flag of the new duplicated listener.
+   * @param signal The signal object of the new duplicated listener.
+   */
+  function warnDuplicate(listener, passive, once, signal) {
+    EventListenerWasDuplicated.warn(isCapture(listener) ? "capture" : "bubble", listener.callback);
+    if (isPassive(listener) !== passive) {
+      OptionWasIgnored.warn("passive");
+    }
+    if (isOnce(listener) !== once) {
+      OptionWasIgnored.warn("once");
+    }
+    if (listener.signal !== signal) {
+      OptionWasIgnored.warn("signal");
+    }
+  }
+  // Set enumerable
+  var keys$1 = Object.getOwnPropertyNames(EventTarget.prototype);
+  for (var _i6 = 0; _i6 < keys$1.length; ++_i6) {
+    if (keys$1[_i6] === "constructor") {
+      continue;
+    }
+    Object.defineProperty(EventTarget.prototype, keys$1[_i6], {
+      enumerable: true
+    });
+  }
+  // Ensure `eventTarget instanceof window.EventTarget` is `true`.
+  if (typeof Global !== "undefined" && typeof Global.EventTarget !== "undefined") {
+    Object.setPrototypeOf(EventTarget.prototype, Global.EventTarget.prototype);
+  }
+
+  /**
+   * Get the current value of a given event attribute.
+   * @param target The `EventTarget` object to get.
+   * @param type The event type.
+   */
+  function getEventAttributeValue(target, type) {
+    var _a, _b;
+    var listMap = $$2(target, "target");
+    return (_b = (_a = listMap[type]) === null || _a === void 0 ? void 0 : _a.attrCallback) !== null && _b !== void 0 ? _b : null;
+  }
+  /**
+   * Set an event listener to a given event attribute.
+   * @param target The `EventTarget` object to set.
+   * @param type The event type.
+   * @param callback The event listener.
+   */
+  function setEventAttributeValue(target, type, callback) {
+    if (callback != null && typeof callback !== "function") {
+      InvalidAttributeHandler.warn(callback);
+    }
+    if (typeof callback === "function" || typeof callback === "object" && callback !== null) {
+      upsertEventAttributeListener(target, type, callback);
+    } else {
+      removeEventAttributeListener(target, type);
+    }
+  }
+  //------------------------------------------------------------------------------
+  // Helpers
+  //------------------------------------------------------------------------------
+  /**
+   * Update or insert the given event attribute handler.
+   * @param target The `EventTarget` object to set.
+   * @param type The event type.
+   * @param callback The event listener.
+   */
+  function upsertEventAttributeListener(target, type, callback) {
+    var list = ensureListenerList($$2(target, "target"), String(type));
+    list.attrCallback = callback;
+    if (list.attrListener == null) {
+      list.attrListener = addListener(list, defineEventAttributeCallback(list), false, false, false, undefined);
+    }
+  }
+  /**
+   * Remove the given event attribute handler.
+   * @param target The `EventTarget` object to remove.
+   * @param type The event type.
+   * @param callback The event listener.
+   */
+  function removeEventAttributeListener(target, type) {
+    var listMap = $$2(target, "target");
+    var list = listMap[String(type)];
+    if (list && list.attrListener) {
+      removeListener(list, list.attrListener.callback, false);
+      list.attrCallback = list.attrListener = undefined;
+    }
+  }
+  /**
+   * Define the callback function for the given listener list object.
+   * It calls `attrCallback` property if the property value is a function.
+   * @param list The `ListenerList` object.
+   */
+  function defineEventAttributeCallback(list) {
+    return function (event) {
+      var callback = list.attrCallback;
+      if (typeof callback === "function") {
+        callback.call(this, event);
+      }
+    };
+  }
+
+  /**
+   * Define an `EventTarget` class that has event attibutes.
+   * @param types The types to define event attributes.
+   * @deprecated Use `getEventAttributeValue`/`setEventAttributeValue` pair on your derived class instead because of static analysis friendly.
+   */
+  function defineCustomEventTarget() {
+    var CustomEventTarget = /*#__PURE__*/function (_EventTarget) {
+      function CustomEventTarget() {
+        _classCallCheck(this, CustomEventTarget);
+        return _callSuper(this, CustomEventTarget, arguments);
+      }
+      _inherits(CustomEventTarget, _EventTarget);
+      return _createClass(CustomEventTarget);
+    }(EventTarget);
+    for (var _i7 = 0; _i7 < arguments.length; ++_i7) {
+      defineEventAttribute(CustomEventTarget.prototype, _i7 < 0 || arguments.length <= _i7 ? undefined : arguments[_i7]);
+    }
+    return CustomEventTarget;
+  }
+  /**
+   * Define an event attribute.
+   * @param target The `EventTarget` object to define an event attribute.
+   * @param type The event type to define.
+   * @param _eventClass Unused, but to infer `Event` class type.
+   * @deprecated Use `getEventAttributeValue`/`setEventAttributeValue` pair on your derived class instead because of static analysis friendly.
+   */
+  function defineEventAttribute(target, type, _eventClass) {
+    Object.defineProperty(target, `on${type}`, {
+      get: function get() {
+        return getEventAttributeValue(this, type);
+      },
+      set: function set(value) {
+        setEventAttributeValue(this, type, value);
+      },
+      configurable: true,
+      enumerable: true
+    });
+  }
+  exports.Event = Event;
+  exports.EventTarget = EventTarget;
+  exports.default = EventTarget;
+  exports.defineCustomEventTarget = defineCustomEventTarget;
+  exports.defineEventAttribute = defineEventAttribute;
+  exports.getEventAttributeValue = getEventAttributeValue;
+  exports.setErrorHandler = setErrorHandler;
+  exports.setEventAttributeValue = setEventAttributeValue;
+  exports.setWarningHandler = setWarningHandler;
+},265,[42,266,21,18,20,23,175,11,12],"../../node_modules/event-target-shim/index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  function set(e, r, t, o) {
+    return set = "undefined" != typeof Reflect && Reflect.set ? Reflect.set : function (e, r, t, o) {
+      var f,
+        i = _$$_REQUIRE(_dependencyMap[0], "./superPropBase.js")(e, r);
+      if (i) {
+        if ((f = Object.getOwnPropertyDescriptor(i, r)).set) return f.set.call(o, t), !0;
+        if (!f.writable) return !1;
+      }
+      if (f = Object.getOwnPropertyDescriptor(o, r)) {
+        if (!f.writable) return !1;
+        f.value = t, Object.defineProperty(o, r, f);
+      } else _$$_REQUIRE(_dependencyMap[1], "./defineProperty.js")(o, r, t);
+      return !0;
+    }, set(e, r, t, o);
+  }
+  function _set(e, r, t, o, f) {
+    if (!set(e, r, t, o || e) && f) throw new TypeError("failed to set property");
+    return t;
+  }
+  module.exports = _set, module.exports.__esModule = true, module.exports["default"] = module.exports;
+},266,[22,65],"../../node_modules/@babel/runtime/helpers/set.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  if (!global.alert) {
+    global.alert = function (text) {
+      _$$_REQUIRE(_dependencyMap[0], "../Alert/Alert").default.alert('Alert', '' + text);
+    };
+  }
+},267,[268],"../../node_modules/react-native/Libraries/Core/setUpAlert.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../Utilities/Platform"));
+  var _RCTAlertManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./RCTAlertManager"));
+  var Alert = /*#__PURE__*/function () {
+    function Alert() {
+      (0, _classCallCheck2.default)(this, Alert);
+    }
+    return (0, _createClass2.default)(Alert, null, [{
+      key: "alert",
+      value: function alert(title, message, buttons, options) {
+        if (_Platform.default.OS === 'ios') {
+          Alert.prompt(title, message, buttons, 'default', undefined, undefined, options);
+        } else if (_Platform.default.OS === 'android') {
+          var NativeDialogManagerAndroid = _$$_REQUIRE(_dependencyMap[5], "../NativeModules/specs/NativeDialogManagerAndroid").default;
+          if (!NativeDialogManagerAndroid) {
+            return;
+          }
+          var constants = NativeDialogManagerAndroid.getConstants();
+          var config = {
+            title: title || '',
+            message: message || '',
+            cancelable: false
+          };
+          if (options && options.cancelable) {
+            config.cancelable = options.cancelable;
+          }
+          var defaultPositiveText = 'OK';
+          var validButtons = buttons ? buttons.slice(0, 3) : [{
+            text: defaultPositiveText
+          }];
+          var buttonPositive = validButtons.pop();
+          var buttonNegative = validButtons.pop();
+          var buttonNeutral = validButtons.pop();
+          if (buttonNeutral) {
+            config.buttonNeutral = buttonNeutral.text || '';
+          }
+          if (buttonNegative) {
+            config.buttonNegative = buttonNegative.text || '';
+          }
+          if (buttonPositive) {
+            config.buttonPositive = buttonPositive.text || defaultPositiveText;
+          }
+          var onAction = function onAction(action, buttonKey) {
+            if (action === constants.buttonClicked) {
+              if (buttonKey === constants.buttonNeutral) {
+                buttonNeutral.onPress && buttonNeutral.onPress();
+              } else if (buttonKey === constants.buttonNegative) {
+                buttonNegative.onPress && buttonNegative.onPress();
+              } else if (buttonKey === constants.buttonPositive) {
+                buttonPositive.onPress && buttonPositive.onPress();
+              }
+            } else if (action === constants.dismissed) {
+              options && options.onDismiss && options.onDismiss();
+            }
+          };
+          var onError = function onError(errorMessage) {
+            return console.warn(errorMessage);
+          };
+          NativeDialogManagerAndroid.showAlert(config, onError, onAction);
+        }
+      }
+    }, {
+      key: "prompt",
+      value: function prompt(title, message, callbackOrButtons) {
+        var type = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'plain-text';
+        var defaultValue = arguments.length > 4 ? arguments[4] : undefined;
+        var keyboardType = arguments.length > 5 ? arguments[5] : undefined;
+        var options = arguments.length > 6 ? arguments[6] : undefined;
+        if (_Platform.default.OS === 'ios') {
+          var callbacks = [];
+          var buttons = [];
+          var cancelButtonKey;
+          var destructiveButtonKey;
+          var preferredButtonKey;
+          if (typeof callbackOrButtons === 'function') {
+            callbacks = [callbackOrButtons];
+          } else if (Array.isArray(callbackOrButtons)) {
+            callbackOrButtons.forEach(function (btn, index) {
+              callbacks[index] = btn.onPress;
+              if (btn.style === 'cancel') {
+                cancelButtonKey = String(index);
+              } else if (btn.style === 'destructive') {
+                destructiveButtonKey = String(index);
+              }
+              if (btn.isPreferred) {
+                preferredButtonKey = String(index);
+              }
+              if (btn.text || index < (callbackOrButtons || []).length - 1) {
+                var btnDef = {};
+                btnDef[index] = btn.text || '';
+                buttons.push(btnDef);
+              }
+            });
+          }
+          _RCTAlertManager.default.alertWithArgs({
+            title: title || '',
+            message: message || undefined,
+            buttons: buttons,
+            type: type || undefined,
+            defaultValue: defaultValue,
+            cancelButtonKey: cancelButtonKey,
+            destructiveButtonKey: destructiveButtonKey,
+            preferredButtonKey: preferredButtonKey,
+            keyboardType: keyboardType,
+            userInterfaceStyle: (options == null ? void 0 : options.userInterfaceStyle) || undefined
+          }, function (id, value) {
+            var cb = callbacks[id];
+            cb && cb(value);
+          });
+        }
+      }
+    }]);
+  }();
+  var _default = exports.default = Alert;
+},268,[1,11,12,68,269,272],"../../node_modules/react-native/Libraries/Alert/Alert.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _NativeAlertManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativeAlertManager"));
+  var _default = exports.default = {
+    alertWithArgs: function alertWithArgs(args, callback) {
+      if (_NativeAlertManager.default == null) {
+        return;
+      }
+      _NativeAlertManager.default.alertWithArgs(args, callback);
+    }
+  };
+},269,[1,270],"../../node_modules/react-native/Libraries/Alert/RCTAlertManager.ios.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeAlertManager = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativeAlertManager"));
+  Object.keys(_NativeAlertManager).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeAlertManager[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeAlertManager[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeAlertManager.default;
+},270,[271],"../../node_modules/react-native/Libraries/Alert/NativeAlertManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.get('AlertManager');
+},271,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeAlertManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeDialogManagerAndroid = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../src/private/specs_DEPRECATED/modules/NativeDialogManagerAndroid"));
+  Object.keys(_NativeDialogManagerAndroid).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeDialogManagerAndroid[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeDialogManagerAndroid[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeDialogManagerAndroid.default;
+},272,[273],"../../node_modules/react-native/Libraries/NativeModules/specs/NativeDialogManagerAndroid.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.get('DialogManagerAndroid');
+},273,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeDialogManagerAndroid.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var navigator = global.navigator;
+  if (navigator === undefined) {
+    global.navigator = {
+      product: 'ReactNative'
+    };
+  } else {
+    _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions").polyfillObjectProperty(navigator, 'product', function () {
+      return 'ReactNative';
+    });
+  }
+},274,[114],"../../node_modules/react-native/Libraries/Core/setUpNavigator.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  var _registerCallableModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./registerCallableModule"));
+  (0, _registerCallableModule.default)('Systrace', function () {
+    return _$$_REQUIRE(_dependencyMap[2], "../Performance/Systrace");
+  });
+  if (!(global.RN$Bridgeless === true)) {
+    (0, _registerCallableModule.default)('JSTimers', function () {
+      return _$$_REQUIRE(_dependencyMap[3], "./Timers/JSTimers").default;
+    });
+  }
+  (0, _registerCallableModule.default)('RCTLog', function () {
+    return _$$_REQUIRE(_dependencyMap[4], "../Utilities/RCTLog").default;
+  });
+  (0, _registerCallableModule.default)('RCTDeviceEventEmitter', function () {
+    return _$$_REQUIRE(_dependencyMap[5], "../EventEmitter/RCTDeviceEventEmitter").default;
+  });
+  (0, _registerCallableModule.default)('RCTNativeAppEventEmitter', function () {
+    return _$$_REQUIRE(_dependencyMap[6], "../EventEmitter/RCTNativeAppEventEmitter").default;
+  });
+  (0, _registerCallableModule.default)('GlobalPerformanceLogger', function () {
+    return _$$_REQUIRE(_dependencyMap[7], "../Utilities/GlobalPerformanceLogger").default;
+  });
+  if (__DEV__) {
+    (0, _registerCallableModule.default)('HMRClient', function () {
+      return _$$_REQUIRE(_dependencyMap[8], "../Utilities/HMRClient").default;
+    });
+  } else {
+    (0, _registerCallableModule.default)('HMRClient', function () {
+      return _$$_REQUIRE(_dependencyMap[9], "../Utilities/HMRClientProdShim").default;
+    });
+  }
+},275,[1,276,28,198,154,17,242,250,277,289],"../../node_modules/react-native/Libraries/Core/setUpBatchedBridge.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var registerCallableModule = function () {
+    if (global.RN$Bridgeless === true) {
+      return function (name, moduleOrFactory) {
+        if (typeof moduleOrFactory === 'function') {
+          global.RN$registerCallableModule(name, moduleOrFactory);
+          return;
+        }
+        global.RN$registerCallableModule(name, function () {
+          return moduleOrFactory;
+        });
+      };
+    }
+    var BatchedBridge = _$$_REQUIRE(_dependencyMap[0], "../BatchedBridge/BatchedBridge").default;
+    return function (name, moduleOrFactory) {
+      if (typeof moduleOrFactory === 'function') {
+        BatchedBridge.registerLazyCallableModule(name, moduleOrFactory);
+        return;
+      }
+      BatchedBridge.registerCallableModule(name, moduleOrFactory);
+    };
+  }();
+  var _default = exports.default = registerCallableModule;
+},276,[40],"../../node_modules/react-native/Libraries/Core/registerCallableModule.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _getDevServer2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../Core/Devtools/getDevServer"));
+  var _LogBox = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../LogBox/LogBox"));
+  var _NativeRedBox = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../NativeModules/specs/NativeRedBox"));
+  var pendingEntryPoints = [];
+  var hmrClient = null;
+  var hmrUnavailableReason = null;
+  var currentCompileErrorMessage = null;
+  var didConnect = false;
+  var pendingLogs = [];
+  var HMRClient = {
+    enable: function enable() {
+      if (hmrUnavailableReason !== null) {
+        throw new Error(hmrUnavailableReason);
+      }
+      _$$_REQUIRE(_dependencyMap[5], "invariant")(hmrClient, 'Expected HMRClient.setup() call at startup.');
+      var DevLoadingView = _$$_REQUIRE(_dependencyMap[6], "./DevLoadingView").default;
+      hmrClient.send(JSON.stringify({
+        type: 'log-opt-in'
+      }));
+      var hasUpdates = hmrClient.hasPendingUpdates();
+      if (hasUpdates) {
+        DevLoadingView.showMessage('Refreshing...', 'refresh');
+      }
+      try {
+        hmrClient.enable();
+      } finally {
+        if (hasUpdates) {
+          DevLoadingView.hide();
+        }
+      }
+      showCompileError();
+    },
+    disable: function disable() {
+      _$$_REQUIRE(_dependencyMap[5], "invariant")(hmrClient, 'Expected HMRClient.setup() call at startup.');
+      hmrClient.disable();
+    },
+    registerBundle: function registerBundle(requestUrl) {
+      _$$_REQUIRE(_dependencyMap[5], "invariant")(hmrClient, 'Expected HMRClient.setup() call at startup.');
+      pendingEntryPoints.push(requestUrl);
+      registerBundleEntryPoints(hmrClient);
+    },
+    log: function log(level, data) {
+      if (!hmrClient) {
+        pendingLogs.push([level, data]);
+        if (pendingLogs.length > 100) {
+          pendingLogs.shift();
+        }
+        return;
+      }
+      try {
+        hmrClient.send(JSON.stringify({
+          type: 'log',
+          level: level,
+          mode: global.RN$Bridgeless === true ? 'NOBRIDGE' : 'BRIDGE',
+          data: data.map(function (item) {
+            return typeof item === 'string' ? item : _$$_REQUIRE(_dependencyMap[7], "pretty-format").format(item, {
+              escapeString: true,
+              highlight: true,
+              maxDepth: 3,
+              min: true,
+              plugins: [_$$_REQUIRE(_dependencyMap[7], "pretty-format").plugins.ReactElement]
+            });
+          })
+        }));
+      } catch (error) {}
+    },
+    setup: function setup(platform, bundleEntry, host, port, isEnabled) {
+      var scheme = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 'http';
+      _$$_REQUIRE(_dependencyMap[5], "invariant")(platform, 'Missing required parameter `platform`');
+      _$$_REQUIRE(_dependencyMap[5], "invariant")(bundleEntry, 'Missing required parameter `bundleEntry`');
+      _$$_REQUIRE(_dependencyMap[5], "invariant")(host, 'Missing required parameter `host`');
+      _$$_REQUIRE(_dependencyMap[5], "invariant")(!hmrClient, 'Cannot initialize hmrClient twice');
+      var DevLoadingView = _$$_REQUIRE(_dependencyMap[6], "./DevLoadingView").default;
+      var serverHost = port !== null && port !== '' ? `${host}:${port}` : host;
+      var serverScheme = scheme;
+      var client = new (_$$_REQUIRE(_dependencyMap[8], "metro-runtime/src/modules/HMRClient"))(`${serverScheme}://${serverHost}/hot`);
+      hmrClient = client;
+      var _getDevServer = (0, _getDevServer2.default)(),
+        fullBundleUrl = _getDevServer.fullBundleUrl;
+      pendingEntryPoints.push(fullBundleUrl != null ? fullBundleUrl : `${serverScheme}://${serverHost}/hot?bundleEntry=${bundleEntry}&platform=${platform}`);
+      client.on('connection-error', function (e) {
+        var error = `Cannot connect to Metro.
+
+Try the following to fix the issue:
+- Ensure that Metro is running and available on the same network`;
+        if ("ios" === 'ios') {
+          error += `
+- Ensure that the Metro URL is correctly set in AppDelegate`;
+        } else {
+          error += `
+- Ensure that your device/emulator is connected to your machine and has USB debugging enabled - run 'adb devices' to see a list of connected devices
+- If you're on a physical device connected to the same machine, run 'adb reverse tcp:8081 tcp:8081' to forward requests from your device
+- If your device is on the same Wi-Fi network, set 'Debug server host & port for device' in 'Dev settings' to your machine's IP address and the port of the local dev server - e.g. 10.0.1.1:8081`;
+        }
+        error += `
+
+URL: ${host}:${port}
+
+Error: ${e.message}`;
+        setHMRUnavailableReason(error);
+      });
+      client.on('update-start', function (_ref) {
+        var isInitialUpdate = _ref.isInitialUpdate;
+        currentCompileErrorMessage = null;
+        didConnect = true;
+        if (client.isEnabled() && !isInitialUpdate) {
+          DevLoadingView.showMessage('Refreshing...', 'refresh');
+        }
+      });
+      client.on('update', function (_ref2) {
+        var isInitialUpdate = _ref2.isInitialUpdate;
+        if (client.isEnabled() && !isInitialUpdate) {
+          dismissRedbox();
+          _LogBox.default.clearAllLogs();
+        }
+      });
+      client.on('update-done', function () {
+        DevLoadingView.hide();
+      });
+      client.on('error', function (data) {
+        DevLoadingView.hide();
+        if (data.type === 'GraphNotFoundError') {
+          client.close();
+          setHMRUnavailableReason('Metro has restarted since the last edit. Reload to reconnect.');
+        } else if (data.type === 'RevisionNotFoundError') {
+          client.close();
+          setHMRUnavailableReason('Metro and the client are out of sync. Reload to reconnect.');
+        } else {
+          currentCompileErrorMessage = `${data.type} ${data.message}`;
+          if (client.isEnabled()) {
+            showCompileError();
+          }
+        }
+      });
+      client.on('close', function (closeEvent) {
+        DevLoadingView.hide();
+        var isNormalOrUnsetCloseReason = closeEvent == null || closeEvent.code === 1000 || closeEvent.code === 1005 || closeEvent.code == null;
+        setHMRUnavailableReason(`${isNormalOrUnsetCloseReason ? 'Disconnected from Metro.' : `Disconnected from Metro (${closeEvent.code}: "${closeEvent.reason}").`}
+
+To reconnect:
+- Ensure that Metro is running and available on the same network
+- Reload this app (will trigger further help if Metro cannot be connected to)
+      `);
+      });
+      if (isEnabled) {
+        HMRClient.enable();
+      } else {
+        HMRClient.disable();
+      }
+      registerBundleEntryPoints(hmrClient);
+      flushEarlyLogs(hmrClient);
+    }
+  };
+  function setHMRUnavailableReason(reason) {
+    _$$_REQUIRE(_dependencyMap[5], "invariant")(hmrClient, 'Expected HMRClient.setup() call at startup.');
+    if (hmrUnavailableReason !== null) {
+      return;
+    }
+    hmrUnavailableReason = reason;
+    if (hmrClient.isEnabled() && didConnect) {
+      console.warn(reason);
+    }
+  }
+  function registerBundleEntryPoints(client) {
+    if (hmrUnavailableReason != null) {
+      _$$_REQUIRE(_dependencyMap[9], "./DevSettings").default.reload('Bundle Splitting – Metro disconnected');
+      return;
+    }
+    if (pendingEntryPoints.length > 0) {
+      client.send(JSON.stringify({
+        type: 'register-entrypoints',
+        entryPoints: pendingEntryPoints
+      }));
+      pendingEntryPoints.length = 0;
+    }
+  }
+  function flushEarlyLogs(client) {
+    try {
+      pendingLogs.forEach(function (_ref3) {
+        var _ref4 = (0, _slicedToArray2.default)(_ref3, 2),
+          level = _ref4[0],
+          data = _ref4[1];
+        HMRClient.log(level, data);
+      });
+    } finally {
+      pendingLogs.length = 0;
+    }
+  }
+  function dismissRedbox() {
+    if ("ios" === 'ios' && _NativeRedBox.default != null && _NativeRedBox.default.dismiss != null) {
+      _NativeRedBox.default.dismiss();
+    } else {
+      var NativeExceptionsManager = _$$_REQUIRE(_dependencyMap[10], "../Core/NativeExceptionsManager").default;
+      NativeExceptionsManager && NativeExceptionsManager.dismissRedbox && NativeExceptionsManager.dismissRedbox();
+    }
+  }
+  function showCompileError() {
+    if (currentCompileErrorMessage === null) {
+      return;
+    }
+    dismissRedbox();
+    var message = currentCompileErrorMessage;
+    currentCompileErrorMessage = null;
+    var error = new Error(message);
+    error.preventSymbolication = true;
+    throw error;
+  }
+  var _default = exports.default = HMRClient;
+},277,[1,34,168,153,278,32,280,184,286,288,179],"../../node_modules/react-native/Libraries/Utilities/HMRClient.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeRedBox = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../src/private/specs_DEPRECATED/modules/NativeRedBox"));
+  Object.keys(_NativeRedBox).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeRedBox[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeRedBox[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeRedBox.default;
+},278,[279],"../../node_modules/react-native/Libraries/NativeModules/specs/NativeRedBox.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.get('RedBox');
+},279,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeRedBox.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _processColor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../StyleSheet/processColor"));
+  var _NativeDevLoadingView = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./NativeDevLoadingView"));
+  var COLOR_SCHEME = {
+    dark: {
+      refresh: {
+        backgroundColor: '#2584e8',
+        textColor: '#ffffff'
+      },
+      load: {
+        backgroundColor: '#fafafa',
+        textColor: '#242526'
+      }
+    },
+    default: {
+      refresh: {
+        backgroundColor: '#2584e8',
+        textColor: '#ffffff'
+      },
+      load: {
+        backgroundColor: '#404040',
+        textColor: '#ffffff'
+      }
+    }
+  };
+  var _default = exports.default = {
+    showMessage: function showMessage(message, type) {
+      if (_NativeDevLoadingView.default) {
+        var colorScheme = (0, _$$_REQUIRE(_dependencyMap[3], "./Appearance").getColorScheme)() === 'dark' ? COLOR_SCHEME.dark : COLOR_SCHEME.default;
+        var colorSet = colorScheme[type];
+        var backgroundColor;
+        var textColor;
+        if (colorSet) {
+          backgroundColor = (0, _processColor.default)(colorSet.backgroundColor);
+          textColor = (0, _processColor.default)(colorSet.textColor);
+        }
+        _NativeDevLoadingView.default.showMessage(message, typeof textColor === 'number' ? textColor : null, typeof backgroundColor === 'number' ? backgroundColor : null);
+      }
+    },
+    hide: function hide() {
+      _NativeDevLoadingView.default && _NativeDevLoadingView.default.hide();
+    }
+  };
+},280,[1,57,281,283],"../../node_modules/react-native/Libraries/Utilities/DevLoadingView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeDevLoadingView = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativeDevLoadingView"));
+  Object.keys(_NativeDevLoadingView).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeDevLoadingView[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeDevLoadingView[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeDevLoadingView.default;
+},281,[282],"../../node_modules/react-native/Libraries/Utilities/NativeDevLoadingView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.get('DevLoadingView');
+},282,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeDevLoadingView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.addChangeListener = addChangeListener;
+  exports.getColorScheme = getColorScheme;
+  exports.setColorScheme = setColorScheme;
+  var _NativeEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../EventEmitter/NativeEventEmitter"));
+  var _EventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../vendor/emitter/EventEmitter"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "invariant"));
+  var lazyState;
+  function getState() {
+    if (lazyState != null) {
+      return lazyState;
+    }
+    var eventEmitter = new _EventEmitter.default();
+    var NativeAppearance = _$$_REQUIRE(_dependencyMap[4], "./NativeAppearance").default;
+    if (NativeAppearance == null) {
+      lazyState = {
+        NativeAppearance: null,
+        appearance: null,
+        eventEmitter: eventEmitter
+      };
+    } else {
+      var state = {
+        NativeAppearance: NativeAppearance,
+        appearance: null,
+        eventEmitter: eventEmitter
+      };
+      new _NativeEventEmitter.default(NativeAppearance).addListener('appearanceChanged', function (newAppearance) {
+        state.appearance = {
+          colorScheme: toColorScheme(newAppearance.colorScheme)
+        };
+        eventEmitter.emit('change', state.appearance);
+      });
+      lazyState = state;
+    }
+    return lazyState;
+  }
+  function getColorScheme() {
+    var colorScheme = null;
+    var state = getState();
+    var NativeAppearance = state.NativeAppearance;
+    if (NativeAppearance != null) {
+      if (state.appearance == null) {
+        state.appearance = {
+          colorScheme: toColorScheme(NativeAppearance.getColorScheme())
+        };
+      }
+      colorScheme = state.appearance.colorScheme;
+    }
+    return colorScheme;
+  }
+  function setColorScheme(colorScheme) {
+    var state = getState();
+    var NativeAppearance = state.NativeAppearance;
+    if (NativeAppearance != null) {
+      NativeAppearance.setColorScheme(colorScheme != null ? colorScheme : 'unspecified');
+      state.appearance = {
+        colorScheme: toColorScheme(NativeAppearance.getColorScheme())
+      };
+    }
+  }
+  function addChangeListener(listener) {
+    var _getState = getState(),
+      eventEmitter = _getState.eventEmitter;
+    return eventEmitter.addListener('change', listener);
+  }
+  function toColorScheme(colorScheme) {
+    (0, _invariant.default)(colorScheme === 'dark' || colorScheme === 'light' || colorScheme == null, "Unrecognized color scheme. Did you mean 'dark', 'light' or null?");
+    return colorScheme;
+  }
+},283,[1,221,25,32,284],"../../node_modules/react-native/Libraries/Utilities/Appearance.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _NativeAppearance = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../src/private/specs_DEPRECATED/modules/NativeAppearance"));
+  var _default = exports.default = _NativeAppearance.default;
+},284,[1,285],"../../node_modules/react-native/Libraries/Utilities/NativeAppearance.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.get('Appearance');
+},285,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeAppearance.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  "use strict";
+
+  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+  var _slicedToArray = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/slicedToArray");
+  function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var inject = function inject(_ref) {
+    var _ref$module = _slicedToArray(_ref.module, 2),
+      id = _ref$module[0],
+      code = _ref$module[1],
+      sourceURL = _ref.sourceURL;
+    if (global.globalEvalWithSourceUrl) {
+      global.globalEvalWithSourceUrl(code, sourceURL);
+    } else {
+      eval(code);
+    }
+  };
+  var injectUpdate = function injectUpdate(update) {
+    update.added.forEach(inject);
+    update.modified.forEach(inject);
+  };
+  var HMRClient = /*#__PURE__*/function (_EventEmitter) {
+    function HMRClient(url) {
+      var _this;
+      _classCallCheck(this, HMRClient);
+      _this = _callSuper(this, HMRClient);
+      _this._isEnabled = false;
+      _this._pendingUpdate = null;
+      _this._queue = [];
+      _this._state = "opening";
+      _this._ws = new global.WebSocket(url);
+      _this._ws.onopen = function () {
+        _this._state = "open";
+        _this.emit("open");
+        _this._flushQueue();
+      };
+      _this._ws.onerror = function (error) {
+        _this.emit("connection-error", error);
+      };
+      _this._ws.onclose = function (closeEvent) {
+        _this._state = "closed";
+        _this.emit("close", closeEvent);
+      };
+      _this._ws.onmessage = function (message) {
+        var data = JSON.parse(String(message.data));
+        switch (data.type) {
+          case "bundle-registered":
+            _this.emit("bundle-registered");
+            break;
+          case "update-start":
+            _this.emit("update-start", data.body);
+            break;
+          case "update":
+            _this.emit("update", data.body);
+            break;
+          case "update-done":
+            _this.emit("update-done");
+            break;
+          case "error":
+            _this.emit("error", data.body);
+            break;
+          default:
+            _this.emit("error", {
+              type: "unknown-message",
+              message: data
+            });
+        }
+      };
+      _this.on("update", function (update) {
+        if (_this._isEnabled) {
+          injectUpdate(update);
+        } else if (_this._pendingUpdate == null) {
+          _this._pendingUpdate = update;
+        } else {
+          _this._pendingUpdate = mergeUpdates(_this._pendingUpdate, update);
+        }
+      });
+      return _this;
+    }
+    _inherits(HMRClient, _EventEmitter);
+    return _createClass(HMRClient, [{
+      key: "close",
+      value: function close() {
+        this._ws.close();
+      }
+    }, {
+      key: "send",
+      value: function send(message) {
+        switch (this._state) {
+          case "opening":
+            this._queue.push(message);
+            break;
+          case "open":
+            this._ws.send(message);
+            break;
+          case "closed":
+            break;
+          default:
+            throw new Error("[WebSocketHMRClient] Unknown state: " + this._state);
+        }
+      }
+    }, {
+      key: "_flushQueue",
+      value: function _flushQueue() {
+        var _this2 = this;
+        this._queue.forEach(function (message) {
+          return _this2.send(message);
+        });
+        this._queue.length = 0;
+      }
+    }, {
+      key: "enable",
+      value: function enable() {
+        this._isEnabled = true;
+        var update = this._pendingUpdate;
+        this._pendingUpdate = null;
+        if (update != null) {
+          injectUpdate(update);
+        }
+      }
+    }, {
+      key: "disable",
+      value: function disable() {
+        this._isEnabled = false;
+      }
+    }, {
+      key: "isEnabled",
+      value: function isEnabled() {
+        return this._isEnabled;
+      }
+    }, {
+      key: "hasPendingUpdates",
+      value: function hasPendingUpdates() {
+        return this._pendingUpdate != null;
+      }
+    }]);
+  }(_$$_REQUIRE(_dependencyMap[6], "./vendor/eventemitter3"));
+  function mergeUpdates(base, next) {
+    var addedIDs = new Set();
+    var deletedIDs = new Set();
+    var moduleMap = new Map();
+    applyUpdateLocally(base);
+    applyUpdateLocally(next);
+    function applyUpdateLocally(update) {
+      update.deleted.forEach(function (id) {
+        if (addedIDs.has(id)) {
+          addedIDs.delete(id);
+        } else {
+          deletedIDs.add(id);
+        }
+        moduleMap.delete(id);
+      });
+      update.added.forEach(function (item) {
+        var id = item.module[0];
+        if (deletedIDs.has(id)) {
+          deletedIDs.delete(id);
+        } else {
+          addedIDs.add(id);
+        }
+        moduleMap.set(id, item);
+      });
+      update.modified.forEach(function (item) {
+        var id = item.module[0];
+        moduleMap.set(id, item);
+      });
+    }
+    var result = {
+      isInitialUpdate: next.isInitialUpdate,
+      revisionId: next.revisionId,
+      added: [],
+      modified: [],
+      deleted: []
+    };
+    deletedIDs.forEach(function (id) {
+      result.deleted.push(id);
+    });
+    moduleMap.forEach(function (item, id) {
+      if (deletedIDs.has(id)) {
+        return;
+      }
+      if (addedIDs.has(id)) {
+        result.added.push(item);
+      } else {
+        result.modified.push(item);
+      }
+    });
+    return result;
+  }
+  module.exports = HMRClient;
+},286,[11,12,18,20,23,34,287],"../../node_modules/metro-runtime/src/modules/HMRClient.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  "use strict";
+
+  var has = Object.prototype.hasOwnProperty,
+    prefix = "~";
+  function Events() {}
+  if (Object.create) {
+    Events.prototype = Object.create(null);
+    if (!new Events().__proto__) prefix = false;
+  }
+  function EE(fn, context, once) {
+    this.fn = fn;
+    this.context = context;
+    this.once = once || false;
+  }
+  function addListener(emitter, event, fn, context, once) {
+    if (typeof fn !== "function") {
+      throw new TypeError("The listener must be a function");
+    }
+    var listener = new EE(fn, context || emitter, once),
+      evt = prefix ? prefix + event : event;
+    if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);else emitter._events[evt] = [emitter._events[evt], listener];
+    return emitter;
+  }
+  function clearEvent(emitter, evt) {
+    if (--emitter._eventsCount === 0) emitter._events = new Events();else delete emitter._events[evt];
+  }
+  function EventEmitter() {
+    this._events = new Events();
+    this._eventsCount = 0;
+  }
+  EventEmitter.prototype.eventNames = function eventNames() {
+    var names = [],
+      events,
+      name;
+    if (this._eventsCount === 0) return names;
+    for (name in events = this._events) {
+      if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+    }
+    if (Object.getOwnPropertySymbols) {
+      return names.concat(Object.getOwnPropertySymbols(events));
+    }
+    return names;
+  };
+  EventEmitter.prototype.listeners = function listeners(event) {
+    var evt = prefix ? prefix + event : event,
+      handlers = this._events[evt];
+    if (!handlers) return [];
+    if (handlers.fn) return [handlers.fn];
+    for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+      ee[i] = handlers[i].fn;
+    }
+    return ee;
+  };
+  EventEmitter.prototype.listenerCount = function listenerCount(event) {
+    var evt = prefix ? prefix + event : event,
+      listeners = this._events[evt];
+    if (!listeners) return 0;
+    if (listeners.fn) return 1;
+    return listeners.length;
+  };
+  EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+    var evt = prefix ? prefix + event : event;
+    if (!this._events[evt]) return false;
+    var listeners = this._events[evt],
+      len = arguments.length,
+      args,
+      i;
+    if (listeners.fn) {
+      if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
+      switch (len) {
+        case 1:
+          return listeners.fn.call(listeners.context), true;
+        case 2:
+          return listeners.fn.call(listeners.context, a1), true;
+        case 3:
+          return listeners.fn.call(listeners.context, a1, a2), true;
+        case 4:
+          return listeners.fn.call(listeners.context, a1, a2, a3), true;
+        case 5:
+          return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+        case 6:
+          return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+      }
+      for (i = 1, args = new Array(len - 1); i < len; i++) {
+        args[i - 1] = arguments[i];
+      }
+      listeners.fn.apply(listeners.context, args);
+    } else {
+      var length = listeners.length,
+        j;
+      for (i = 0; i < length; i++) {
+        if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
+        switch (len) {
+          case 1:
+            listeners[i].fn.call(listeners[i].context);
+            break;
+          case 2:
+            listeners[i].fn.call(listeners[i].context, a1);
+            break;
+          case 3:
+            listeners[i].fn.call(listeners[i].context, a1, a2);
+            break;
+          case 4:
+            listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+            break;
+          default:
+            if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
+              args[j - 1] = arguments[j];
+            }
+            listeners[i].fn.apply(listeners[i].context, args);
+        }
+      }
+    }
+    return true;
+  };
+  EventEmitter.prototype.on = function on(event, fn, context) {
+    return addListener(this, event, fn, context, false);
+  };
+  EventEmitter.prototype.once = function once(event, fn, context) {
+    return addListener(this, event, fn, context, true);
+  };
+  EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+    var evt = prefix ? prefix + event : event;
+    if (!this._events[evt]) return this;
+    if (!fn) {
+      clearEvent(this, evt);
+      return this;
+    }
+    var listeners = this._events[evt];
+    if (listeners.fn) {
+      if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+        clearEvent(this, evt);
+      }
+    } else {
+      for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+        if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+          events.push(listeners[i]);
+        }
+      }
+      if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;else clearEvent(this, evt);
+    }
+    return this;
+  };
+  EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+    var evt;
+    if (event) {
+      evt = prefix ? prefix + event : event;
+      if (this._events[evt]) clearEvent(this, evt);
+    } else {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
+    return this;
+  };
+  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+  EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+  EventEmitter.prefixed = prefix;
+  EventEmitter.EventEmitter = EventEmitter;
+  if ("undefined" !== typeof module) {
+    module.exports = EventEmitter;
+  }
+},287,[],"../../node_modules/metro-runtime/src/modules/vendor/eventemitter3.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _NativeEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../EventEmitter/NativeEventEmitter"));
+  var _NativeDevSettings = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../NativeModules/specs/NativeDevSettings"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../Utilities/Platform"));
+  var DevSettings = {
+    addMenuItem: function addMenuItem(title, handler) {},
+    reload: function reload(reason) {},
+    onFastRefresh: function onFastRefresh() {}
+  };
+  if (__DEV__) {
+    var emitter = new _NativeEventEmitter.default(_Platform.default.OS !== 'ios' ? null : _NativeDevSettings.default);
+    var subscriptions = new Map();
+    DevSettings = {
+      addMenuItem: function addMenuItem(title, handler) {
+        var subscription = subscriptions.get(title);
+        if (subscription != null) {
+          subscription.remove();
+        } else {
+          _NativeDevSettings.default.addMenuItem(title);
+        }
+        subscription = emitter.addListener('didPressMenuItem', function (event) {
+          if (event.title === title) {
+            handler();
+          }
+        });
+        subscriptions.set(title, subscription);
+      },
+      reload: function reload(reason) {
+        if (_NativeDevSettings.default.reloadWithReason != null) {
+          _NativeDevSettings.default.reloadWithReason(reason != null ? reason : 'Uncategorized from JS');
+        } else {
+          _NativeDevSettings.default.reload();
+        }
+      },
+      onFastRefresh: function onFastRefresh() {
+        _NativeDevSettings.default.onFastRefresh == null || _NativeDevSettings.default.onFastRefresh();
+      }
+    };
+  }
+  var _default = exports.default = DevSettings;
+},288,[1,221,160,68],"../../node_modules/react-native/Libraries/Utilities/DevSettings.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var HMRClientProdShim = {
+    setup: function setup() {},
+    enable: function enable() {
+      console.error('Fast Refresh is disabled in JavaScript bundles built in production mode. ' + 'Did you forget to run Metro?');
+    },
+    disable: function disable() {},
+    registerBundle: function registerBundle() {},
+    log: function log() {}
+  };
+  var _default = exports.default = HMRClientProdShim;
+},289,[],"../../node_modules/react-native/Libraries/Utilities/HMRClientProdShim.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  function __fetchSegment(segmentId, options, callback) {
+    var SegmentFetcher = _$$_REQUIRE(_dependencyMap[0], "./SegmentFetcher/NativeSegmentFetcher").default;
+    SegmentFetcher.fetchSegment(segmentId, options, function (errorObject) {
+      if (errorObject) {
+        var error = new Error(errorObject.message);
+        error.code = errorObject.code;
+        callback(error);
+        return;
+      }
+      callback(null);
+    });
+  }
+  global.__fetchSegment = __fetchSegment;
+},290,[291],"../../node_modules/react-native/Libraries/Core/setUpSegmentFetcher.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeSegmentFetcher = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../src/private/specs_DEPRECATED/modules/NativeSegmentFetcher"));
+  Object.keys(_NativeSegmentFetcher).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeSegmentFetcher[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeSegmentFetcher[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeSegmentFetcher.default;
+},291,[292],"../../node_modules/react-native/Libraries/Core/SegmentFetcher/NativeSegmentFetcher.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.getEnforcing('SegmentFetcher');
+},292,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeSegmentFetcher.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  _$$_REQUIRE(_dependencyMap[0], "./ReactNativeVersionCheck").checkVersions();
+},293,[294],"../../node_modules/react-native/Libraries/Core/checkNativeVersion.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.checkVersions = checkVersions;
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../Utilities/Platform"));
+  function checkVersions() {
+    var nativeVersion = _Platform.default.constants.reactNativeVersion;
+    if (_$$_REQUIRE(_dependencyMap[2], "./ReactNativeVersion").version.major !== nativeVersion.major || _$$_REQUIRE(_dependencyMap[2], "./ReactNativeVersion").version.minor !== nativeVersion.minor) {
+      console.error(`React Native version mismatch.\n\nJavaScript version: ${_formatVersion(_$$_REQUIRE(_dependencyMap[2], "./ReactNativeVersion").version)}\n` + `Native version: ${_formatVersion(nativeVersion)}\n\n` + 'Make sure that you have rebuilt the native code. If the problem ' + 'persists try clearing the Watchman and packager caches with ' + '`watchman watch-del-all && npx react-native start --reset-cache`.');
+    }
+  }
+  function _formatVersion(version) {
+    return `${version.major}.${version.minor}.${version.patch}` + (version.prerelease != undefined ? `-${version.prerelease}` : '');
+  }
+},294,[1,68,295],"../../node_modules/react-native/Libraries/Core/ReactNativeVersionCheck.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.version = void 0;
+  var version = exports.version = {
+    major: 0,
+    minor: 80,
+    patch: 1,
+    prerelease: null
+  };
+},295,[],"../../node_modules/react-native/Libraries/Core/ReactNativeVersion.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../Utilities/Platform"));
+  if (__DEV__) {
+    var _global$__METRO_GLOBA;
+    if (!_Platform.default.isTesting) {
+      var HMRClient = _$$_REQUIRE(_dependencyMap[2], "../Utilities/HMRClient").default;
+      if (console._isPolyfilled) {
+        ['trace', 'info', 'warn', 'error', 'log', 'group', 'groupCollapsed', 'groupEnd', 'debug'].forEach(function (level) {
+          var originalFunction = console[level];
+          console[level] = function () {
+            for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+              args[_key] = arguments[_key];
+            }
+            HMRClient.log(level, args);
+            originalFunction.apply(console, args);
+          };
+        });
+      }
+    }
+    _$$_REQUIRE(_dependencyMap[3], "./setUpReactRefresh");
+    global[`${(_global$__METRO_GLOBA = global.__METRO_GLOBAL_PREFIX__) != null ? _global$__METRO_GLOBA : ''}__loadBundleAsync`] = _$$_REQUIRE(_dependencyMap[4], "./Devtools/loadBundleFromServer").default;
+  }
+},296,[1,68,277,297,301],"../../node_modules/react-native/Libraries/Core/setUpDeveloperTools.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  if (__DEV__) {
+    var DevSettings = _$$_REQUIRE(_dependencyMap[0], "../Utilities/DevSettings").default;
+    if (typeof DevSettings.reload !== 'function') {
+      throw new Error('Could not find the reload() implementation.');
+    }
+    var ReactRefreshRuntime = _$$_REQUIRE(_dependencyMap[1], "react-refresh/runtime");
+    ReactRefreshRuntime.injectIntoGlobalHook(global);
+    var Refresh = {
+      performFullRefresh: function performFullRefresh(reason) {
+        DevSettings.reload(reason);
+      },
+      createSignatureFunctionForTransform: ReactRefreshRuntime.createSignatureFunctionForTransform,
+      isLikelyComponentType: ReactRefreshRuntime.isLikelyComponentType,
+      getFamilyByType: ReactRefreshRuntime.getFamilyByType,
+      register: ReactRefreshRuntime.register,
+      performReactRefresh: function performReactRefresh() {
+        ReactRefreshRuntime.performReactRefresh();
+        DevSettings.onFastRefresh();
+      }
+    };
+    global[(global.__METRO_GLOBAL_PREFIX__ || '') + '__ReactRefresh'] = Refresh;
+  }
+},297,[288,298],"../../node_modules/react-native/Libraries/Core/setUpReactRefresh.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  if (process.env.NODE_ENV === 'production') {
+    module.exports = _$$_REQUIRE(_dependencyMap[0], "./cjs/react-refresh-runtime.production.min.js");
+  } else {
+    module.exports = _$$_REQUIRE(_dependencyMap[1], "./cjs/react-refresh-runtime.development.js");
+  }
+},298,[299,300],"../../node_modules/react-refresh/runtime.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  /**
+   * @license React
+   * react-refresh-runtime.production.min.js
+   *
+   * Copyright (c) Facebook, Inc. and its 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';
+
+  throw Error("React Refresh runtime should not be included in the production bundle.");
+},299,[],"../../node_modules/react-refresh/cjs/react-refresh-runtime.production.min.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  /**
+   * @license React
+   * react-refresh-runtime.development.js
+   *
+   * Copyright (c) Facebook, Inc. and its 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';
+
+  if (process.env.NODE_ENV !== "production") {
+    (function () {
+      'use strict';
+
+      // ATTENTION
+      var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+      var REACT_MEMO_TYPE = Symbol.for('react.memo');
+      var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map; // We never remove these associations.
+      // It's OK to reference families, but use WeakMap/Set for types.
+
+      var allFamiliesByID = new Map();
+      var allFamiliesByType = new PossiblyWeakMap();
+      var allSignaturesByType = new PossiblyWeakMap(); // This WeakMap is read by React, so we only put families
+      // that have actually been edited here. This keeps checks fast.
+      // $FlowIssue
+
+      var updatedFamiliesByType = new PossiblyWeakMap(); // This is cleared on every performReactRefresh() call.
+      // It is an array of [Family, NextType] tuples.
+
+      var pendingUpdates = []; // This is injected by the renderer via DevTools global hook.
+
+      var helpersByRendererID = new Map();
+      var helpersByRoot = new Map(); // We keep track of mounted roots so we can schedule updates.
+
+      var mountedRoots = new Set(); // If a root captures an error, we remember it so we can retry on edit.
+
+      var failedRoots = new Set(); // In environments that support WeakMap, we also remember the last element for every root.
+      // It needs to be weak because we do this even for roots that failed to mount.
+      // If there is no WeakMap, we won't attempt to do retrying.
+      // $FlowIssue
+
+      var rootElements =
+      // $FlowIssue
+      typeof WeakMap === 'function' ? new WeakMap() : null;
+      var isPerformingRefresh = false;
+      function computeFullKey(signature) {
+        if (signature.fullKey !== null) {
+          return signature.fullKey;
+        }
+        var fullKey = signature.ownKey;
+        var hooks;
+        try {
+          hooks = signature.getCustomHooks();
+        } catch (err) {
+          // This can happen in an edge case, e.g. if expression like Foo.useSomething
+          // depends on Foo which is lazily initialized during rendering.
+          // In that case just assume we'll have to remount.
+          signature.forceReset = true;
+          signature.fullKey = fullKey;
+          return fullKey;
+        }
+        for (var i = 0; i < hooks.length; i++) {
+          var hook = hooks[i];
+          if (typeof hook !== 'function') {
+            // Something's wrong. Assume we need to remount.
+            signature.forceReset = true;
+            signature.fullKey = fullKey;
+            return fullKey;
+          }
+          var nestedHookSignature = allSignaturesByType.get(hook);
+          if (nestedHookSignature === undefined) {
+            // No signature means Hook wasn't in the source code, e.g. in a library.
+            // We'll skip it because we can assume it won't change during this session.
+            continue;
+          }
+          var nestedHookKey = computeFullKey(nestedHookSignature);
+          if (nestedHookSignature.forceReset) {
+            signature.forceReset = true;
+          }
+          fullKey += '\n---\n' + nestedHookKey;
+        }
+        signature.fullKey = fullKey;
+        return fullKey;
+      }
+      function haveEqualSignatures(prevType, nextType) {
+        var prevSignature = allSignaturesByType.get(prevType);
+        var nextSignature = allSignaturesByType.get(nextType);
+        if (prevSignature === undefined && nextSignature === undefined) {
+          return true;
+        }
+        if (prevSignature === undefined || nextSignature === undefined) {
+          return false;
+        }
+        if (computeFullKey(prevSignature) !== computeFullKey(nextSignature)) {
+          return false;
+        }
+        if (nextSignature.forceReset) {
+          return false;
+        }
+        return true;
+      }
+      function isReactClass(type) {
+        return type.prototype && type.prototype.isReactComponent;
+      }
+      function canPreserveStateBetween(prevType, nextType) {
+        if (isReactClass(prevType) || isReactClass(nextType)) {
+          return false;
+        }
+        if (haveEqualSignatures(prevType, nextType)) {
+          return true;
+        }
+        return false;
+      }
+      function resolveFamily(type) {
+        // Only check updated types to keep lookups fast.
+        return updatedFamiliesByType.get(type);
+      } // If we didn't care about IE11, we could use new Map/Set(iterable).
+
+      function cloneMap(map) {
+        var clone = new Map();
+        map.forEach(function (value, key) {
+          clone.set(key, value);
+        });
+        return clone;
+      }
+      function cloneSet(set) {
+        var clone = new Set();
+        set.forEach(function (value) {
+          clone.add(value);
+        });
+        return clone;
+      } // This is a safety mechanism to protect against rogue getters and Proxies.
+
+      function getProperty(object, property) {
+        try {
+          return object[property];
+        } catch (err) {
+          // Intentionally ignore.
+          return undefined;
+        }
+      }
+      function performReactRefresh() {
+        if (pendingUpdates.length === 0) {
+          return null;
+        }
+        if (isPerformingRefresh) {
+          return null;
+        }
+        isPerformingRefresh = true;
+        try {
+          var staleFamilies = new Set();
+          var updatedFamilies = new Set();
+          var updates = pendingUpdates;
+          pendingUpdates = [];
+          updates.forEach(function (_ref) {
+            var family = _ref[0],
+              nextType = _ref[1];
+            // Now that we got a real edit, we can create associations
+            // that will be read by the React reconciler.
+            var prevType = family.current;
+            updatedFamiliesByType.set(prevType, family);
+            updatedFamiliesByType.set(nextType, family);
+            family.current = nextType; // Determine whether this should be a re-render or a re-mount.
+
+            if (canPreserveStateBetween(prevType, nextType)) {
+              updatedFamilies.add(family);
+            } else {
+              staleFamilies.add(family);
+            }
+          }); // TODO: rename these fields to something more meaningful.
+
+          var update = {
+            updatedFamilies: updatedFamilies,
+            // Families that will re-render preserving state
+            staleFamilies: staleFamilies // Families that will be remounted
+          };
+          helpersByRendererID.forEach(function (helpers) {
+            // Even if there are no roots, set the handler on first update.
+            // This ensures that if *new* roots are mounted, they'll use the resolve handler.
+            helpers.setRefreshHandler(resolveFamily);
+          });
+          var didError = false;
+          var firstError = null; // We snapshot maps and sets that are mutated during commits.
+          // If we don't do this, there is a risk they will be mutated while
+          // we iterate over them. For example, trying to recover a failed root
+          // may cause another root to be added to the failed list -- an infinite loop.
+
+          var failedRootsSnapshot = cloneSet(failedRoots);
+          var mountedRootsSnapshot = cloneSet(mountedRoots);
+          var helpersByRootSnapshot = cloneMap(helpersByRoot);
+          failedRootsSnapshot.forEach(function (root) {
+            var helpers = helpersByRootSnapshot.get(root);
+            if (helpers === undefined) {
+              throw new Error('Could not find helpers for a root. This is a bug in React Refresh.');
+            }
+            if (!failedRoots.has(root)) {// No longer failed.
+            }
+            if (rootElements === null) {
+              return;
+            }
+            if (!rootElements.has(root)) {
+              return;
+            }
+            var element = rootElements.get(root);
+            try {
+              helpers.scheduleRoot(root, element);
+            } catch (err) {
+              if (!didError) {
+                didError = true;
+                firstError = err;
+              } // Keep trying other roots.
+            }
+          });
+          mountedRootsSnapshot.forEach(function (root) {
+            var helpers = helpersByRootSnapshot.get(root);
+            if (helpers === undefined) {
+              throw new Error('Could not find helpers for a root. This is a bug in React Refresh.');
+            }
+            if (!mountedRoots.has(root)) {// No longer mounted.
+            }
+            try {
+              helpers.scheduleRefresh(root, update);
+            } catch (err) {
+              if (!didError) {
+                didError = true;
+                firstError = err;
+              } // Keep trying other roots.
+            }
+          });
+          if (didError) {
+            throw firstError;
+          }
+          return update;
+        } finally {
+          isPerformingRefresh = false;
+        }
+      }
+      function register(type, id) {
+        {
+          if (type === null) {
+            return;
+          }
+          if (typeof type !== 'function' && typeof type !== 'object') {
+            return;
+          } // This can happen in an edge case, e.g. if we register
+          // return value of a HOC but it returns a cached component.
+          // Ignore anything but the first registration for each type.
+
+          if (allFamiliesByType.has(type)) {
+            return;
+          } // Create family or remember to update it.
+          // None of this bookkeeping affects reconciliation
+          // until the first performReactRefresh() call above.
+
+          var family = allFamiliesByID.get(id);
+          if (family === undefined) {
+            family = {
+              current: type
+            };
+            allFamiliesByID.set(id, family);
+          } else {
+            pendingUpdates.push([family, type]);
+          }
+          allFamiliesByType.set(type, family); // Visit inner types because we might not have registered them.
+
+          if (typeof type === 'object' && type !== null) {
+            switch (getProperty(type, '$$typeof')) {
+              case REACT_FORWARD_REF_TYPE:
+                register(type.render, id + '$render');
+                break;
+              case REACT_MEMO_TYPE:
+                register(type.type, id + '$type');
+                break;
+            }
+          }
+        }
+      }
+      function setSignature(type, key) {
+        var forceReset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+        var getCustomHooks = arguments.length > 3 ? arguments[3] : undefined;
+        {
+          if (!allSignaturesByType.has(type)) {
+            allSignaturesByType.set(type, {
+              forceReset: forceReset,
+              ownKey: key,
+              fullKey: null,
+              getCustomHooks: getCustomHooks || function () {
+                return [];
+              }
+            });
+          } // Visit inner types because we might not have signed them.
+
+          if (typeof type === 'object' && type !== null) {
+            switch (getProperty(type, '$$typeof')) {
+              case REACT_FORWARD_REF_TYPE:
+                setSignature(type.render, key, forceReset, getCustomHooks);
+                break;
+              case REACT_MEMO_TYPE:
+                setSignature(type.type, key, forceReset, getCustomHooks);
+                break;
+            }
+          }
+        }
+      } // This is lazily called during first render for a type.
+      // It captures Hook list at that time so inline requires don't break comparisons.
+
+      function collectCustomHooksForSignature(type) {
+        {
+          var signature = allSignaturesByType.get(type);
+          if (signature !== undefined) {
+            computeFullKey(signature);
+          }
+        }
+      }
+      function getFamilyByID(id) {
+        {
+          return allFamiliesByID.get(id);
+        }
+      }
+      function getFamilyByType(type) {
+        {
+          return allFamiliesByType.get(type);
+        }
+      }
+      function findAffectedHostInstances(families) {
+        {
+          var affectedInstances = new Set();
+          mountedRoots.forEach(function (root) {
+            var helpers = helpersByRoot.get(root);
+            if (helpers === undefined) {
+              throw new Error('Could not find helpers for a root. This is a bug in React Refresh.');
+            }
+            var instancesForRoot = helpers.findHostInstancesForRefresh(root, families);
+            instancesForRoot.forEach(function (inst) {
+              affectedInstances.add(inst);
+            });
+          });
+          return affectedInstances;
+        }
+      }
+      function injectIntoGlobalHook(globalObject) {
+        {
+          // For React Native, the global hook will be set up by require('react-devtools-core').
+          // That code will run before us. So we need to monkeypatch functions on existing hook.
+          // For React Web, the global hook will be set up by the extension.
+          // This will also run before us.
+          var hook = globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+          if (hook === undefined) {
+            // However, if there is no DevTools extension, we'll need to set up the global hook ourselves.
+            // Note that in this case it's important that renderer code runs *after* this method call.
+            // Otherwise, the renderer will think that there is no global hook, and won't do the injection.
+            var nextID = 0;
+            globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook = {
+              renderers: new Map(),
+              supportsFiber: true,
+              inject: function inject(injected) {
+                return nextID++;
+              },
+              onScheduleFiberRoot: function onScheduleFiberRoot(id, root, children) {},
+              onCommitFiberRoot: function onCommitFiberRoot(id, root, maybePriorityLevel, didError) {},
+              onCommitFiberUnmount: function onCommitFiberUnmount() {}
+            };
+          }
+          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.
+            // Using console['warn'] to evade Babel and ESLint
+            console['warn']('Something has shimmed the React DevTools global hook (__REACT_DEVTOOLS_GLOBAL_HOOK__). ' + 'Fast Refresh is not compatible with this shim and will be disabled.');
+            return;
+          } // Here, we just want to get a reference to scheduleRefresh.
+
+          var oldInject = hook.inject;
+          hook.inject = function (injected) {
+            var id = oldInject.apply(this, arguments);
+            if (typeof injected.scheduleRefresh === 'function' && typeof injected.setRefreshHandler === 'function') {
+              // This version supports React Refresh.
+              helpersByRendererID.set(id, injected);
+            }
+            return id;
+          }; // Do the same for any already injected roots.
+          // This is useful if ReactDOM has already been initialized.
+          // https://github.com/facebook/react/issues/17626
+
+          hook.renderers.forEach(function (injected, id) {
+            if (typeof injected.scheduleRefresh === 'function' && typeof injected.setRefreshHandler === 'function') {
+              // This version supports React Refresh.
+              helpersByRendererID.set(id, injected);
+            }
+          }); // We also want to track currently mounted roots.
+
+          var oldOnCommitFiberRoot = hook.onCommitFiberRoot;
+          var oldOnScheduleFiberRoot = hook.onScheduleFiberRoot || function () {};
+          hook.onScheduleFiberRoot = function (id, root, children) {
+            if (!isPerformingRefresh) {
+              // If it was intentionally scheduled, don't attempt to restore.
+              // This includes intentionally scheduled unmounts.
+              failedRoots.delete(root);
+              if (rootElements !== null) {
+                rootElements.set(root, children);
+              }
+            }
+            return oldOnScheduleFiberRoot.apply(this, arguments);
+          };
+          hook.onCommitFiberRoot = function (id, root, maybePriorityLevel, didError) {
+            var helpers = helpersByRendererID.get(id);
+            if (helpers !== undefined) {
+              helpersByRoot.set(root, helpers);
+              var current = root.current;
+              var alternate = current.alternate; // We need to determine whether this root has just (un)mounted.
+              // This logic is copy-pasted from similar logic in the DevTools backend.
+              // If this breaks with some refactoring, you'll want to update DevTools too.
+
+              if (alternate !== null) {
+                var wasMounted = alternate.memoizedState != null && alternate.memoizedState.element != null && mountedRoots.has(root);
+                var isMounted = current.memoizedState != null && current.memoizedState.element != null;
+                if (!wasMounted && isMounted) {
+                  // Mount a new root.
+                  mountedRoots.add(root);
+                  failedRoots.delete(root);
+                } else if (wasMounted && isMounted) ;else if (wasMounted && !isMounted) {
+                  // Unmount an existing root.
+                  mountedRoots.delete(root);
+                  if (didError) {
+                    // We'll remount it on future edits.
+                    failedRoots.add(root);
+                  } else {
+                    helpersByRoot.delete(root);
+                  }
+                } else if (!wasMounted && !isMounted) {
+                  if (didError) {
+                    // We'll remount it on future edits.
+                    failedRoots.add(root);
+                  }
+                }
+              } else {
+                // Mount a new root.
+                mountedRoots.add(root);
+              }
+            } // Always call the decorated DevTools hook.
+
+            return oldOnCommitFiberRoot.apply(this, arguments);
+          };
+        }
+      }
+      function hasUnrecoverableErrors() {
+        // TODO: delete this after removing dependency in RN.
+        return false;
+      } // Exposed for testing.
+
+      function _getMountedRootCount() {
+        {
+          return mountedRoots.size;
+        }
+      } // This is a wrapper over more primitive functions for setting signature.
+      // Signatures let us decide whether the Hook order has changed on refresh.
+      //
+      // This function is intended to be used as a transform target, e.g.:
+      // var _s = createSignatureFunctionForTransform()
+      //
+      // function Hello() {
+      //   const [foo, setFoo] = useState(0);
+      //   const value = useCustomHook();
+      //   _s(); /* Call without arguments triggers collecting the custom Hook list.
+      //          * This doesn't happen during the module evaluation because we
+      //          * don't want to change the module order with inline requires.
+      //          * Next calls are noops. */
+      //   return <h1>Hi</h1>;
+      // }
+      //
+      // /* Call with arguments attaches the signature to the type: */
+      // _s(
+      //   Hello,
+      //   'useState{[foo, setFoo]}(0)',
+      //   () => [useCustomHook], /* Lazy to avoid triggering inline requires */
+      // );
+
+      function createSignatureFunctionForTransform() {
+        {
+          var savedType;
+          var hasCustomHooks;
+          var didCollectHooks = false;
+          return function (type, key, forceReset, getCustomHooks) {
+            if (typeof key === 'string') {
+              // We're in the initial phase that associates signatures
+              // with the functions. Note this may be called multiple times
+              // in HOC chains like _s(hoc1(_s(hoc2(_s(actualFunction))))).
+              if (!savedType) {
+                // We're in the innermost call, so this is the actual type.
+                savedType = type;
+                hasCustomHooks = typeof getCustomHooks === 'function';
+              } // Set the signature for all types (even wrappers!) in case
+              // they have no signatures of their own. This is to prevent
+              // problems like https://github.com/facebook/react/issues/20417.
+
+              if (type != null && (typeof type === 'function' || typeof type === 'object')) {
+                setSignature(type, key, forceReset, getCustomHooks);
+              }
+              return type;
+            } else {
+              // We're in the _s() call without arguments, which means
+              // this is the time to collect custom Hook signatures.
+              // Only do this once. This path is hot and runs *inside* every render!
+              if (!didCollectHooks && hasCustomHooks) {
+                didCollectHooks = true;
+                collectCustomHooksForSignature(savedType);
+              }
+            }
+          };
+        }
+      }
+      function isLikelyComponentType(type) {
+        {
+          switch (typeof type) {
+            case 'function':
+              {
+                // First, deal with classes.
+                if (type.prototype != null) {
+                  if (type.prototype.isReactComponent) {
+                    // React class.
+                    return true;
+                  }
+                  var ownNames = Object.getOwnPropertyNames(type.prototype);
+                  if (ownNames.length > 1 || ownNames[0] !== 'constructor') {
+                    // This looks like a class.
+                    return false;
+                  } // eslint-disable-next-line no-proto
+
+                  if (type.prototype.__proto__ !== Object.prototype) {
+                    // It has a superclass.
+                    return false;
+                  } // Pass through.
+                  // This looks like a regular function with empty prototype.
+                } // For plain functions and arrows, use name as a heuristic.
+
+                var name = type.name || type.displayName;
+                return typeof name === 'string' && /^[A-Z]/.test(name);
+              }
+            case 'object':
+              {
+                if (type != null) {
+                  switch (getProperty(type, '$$typeof')) {
+                    case REACT_FORWARD_REF_TYPE:
+                    case REACT_MEMO_TYPE:
+                      // Definitely React components.
+                      return true;
+                    default:
+                      return false;
+                  }
+                }
+                return false;
+              }
+            default:
+              {
+                return false;
+              }
+          }
+        }
+      }
+      exports._getMountedRootCount = _getMountedRootCount;
+      exports.collectCustomHooksForSignature = collectCustomHooksForSignature;
+      exports.createSignatureFunctionForTransform = createSignatureFunctionForTransform;
+      exports.findAffectedHostInstances = findAffectedHostInstances;
+      exports.getFamilyByID = getFamilyByID;
+      exports.getFamilyByType = getFamilyByType;
+      exports.hasUnrecoverableErrors = hasUnrecoverableErrors;
+      exports.injectIntoGlobalHook = injectIntoGlobalHook;
+      exports.isLikelyComponentType = isLikelyComponentType;
+      exports.performReactRefresh = performReactRefresh;
+      exports.register = register;
+      exports.setSignature = setSignature;
+    })();
+  }
+},300,[],"../../node_modules/react-refresh/cjs/react-refresh-runtime.development.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = loadBundleFromServer;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _RCTNetworking = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../Network/RCTNetworking"));
+  var _DevLoadingView = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../Utilities/DevLoadingView"));
+  var _HMRClient = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../../Utilities/HMRClient"));
+  var _getDevServer2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./getDevServer"));
+  var pendingRequests = 0;
+  var cachedPromisesByUrl = new Map();
+  function asyncRequest(url) {
+    var id = null;
+    var responseText = null;
+    var headers = null;
+    var dataListener;
+    var completeListener;
+    var responseListener;
+    var incrementalDataListener;
+    return new Promise(function (resolve, reject) {
+      dataListener = _RCTNetworking.default.addListener('didReceiveNetworkData', function (_ref) {
+        var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
+          requestId = _ref2[0],
+          response = _ref2[1];
+        if (requestId === id) {
+          responseText = response;
+        }
+      });
+      incrementalDataListener = _RCTNetworking.default.addListener('didReceiveNetworkIncrementalData', function (_ref3) {
+        var _ref4 = (0, _slicedToArray2.default)(_ref3, 2),
+          requestId = _ref4[0],
+          data = _ref4[1];
+        if (requestId === id) {
+          if (responseText != null) {
+            responseText += data;
+          } else {
+            responseText = data;
+          }
+        }
+      });
+      responseListener = _RCTNetworking.default.addListener('didReceiveNetworkResponse', function (_ref5) {
+        var _ref6 = (0, _slicedToArray2.default)(_ref5, 3),
+          requestId = _ref6[0],
+          status = _ref6[1],
+          responseHeaders = _ref6[2];
+        if (requestId === id) {
+          headers = responseHeaders;
+        }
+      });
+      completeListener = _RCTNetworking.default.addListener('didCompleteNetworkResponse', function (_ref7) {
+        var _ref8 = (0, _slicedToArray2.default)(_ref7, 2),
+          requestId = _ref8[0],
+          error = _ref8[1];
+        if (requestId === id) {
+          if (error) {
+            reject(error);
+          } else {
+            resolve({
+              body: responseText,
+              headers: headers
+            });
+          }
+        }
+      });
+      _RCTNetworking.default.sendRequest('GET', 'asyncRequest', url, {}, '', 'text', true, 0, function (requestId) {
+        id = requestId;
+      }, true);
+    }).finally(function () {
+      var _dataListener, _completeListener, _responseListener, _incrementalDataListe;
+      (_dataListener = dataListener) == null || _dataListener.remove();
+      (_completeListener = completeListener) == null || _completeListener.remove();
+      (_responseListener = responseListener) == null || _responseListener.remove();
+      (_incrementalDataListe = incrementalDataListener) == null || _incrementalDataListe.remove();
+    });
+  }
+  function buildUrlForBundle(bundlePathAndQuery) {
+    var _getDevServer = (0, _getDevServer2.default)(),
+      serverUrl = _getDevServer.url;
+    return serverUrl.replace(/\/+$/, '') + '/' + bundlePathAndQuery.replace(/^\/+/, '');
+  }
+  function loadBundleFromServer(bundlePathAndQuery) {
+    var requestUrl = buildUrlForBundle(bundlePathAndQuery);
+    var loadPromise = cachedPromisesByUrl.get(requestUrl);
+    if (loadPromise) {
+      return loadPromise;
+    }
+    _DevLoadingView.default.showMessage('Downloading...', 'load');
+    ++pendingRequests;
+    loadPromise = asyncRequest(requestUrl).then(function (_ref9) {
+      var body = _ref9.body,
+        headers = _ref9.headers;
+      if (headers['Content-Type'] != null && headers['Content-Type'].indexOf('application/json') >= 0) {
+        throw new Error(JSON.parse(body).message || `Unknown error fetching '${bundlePathAndQuery}'`);
+      }
+      _HMRClient.default.registerBundle(requestUrl);
+      if (global.globalEvalWithSourceUrl) {
+        global.globalEvalWithSourceUrl(body, requestUrl);
+      } else {
+        eval(body);
+      }
+    }).catch(function (e) {
+      cachedPromisesByUrl.delete(requestUrl);
+      throw e;
+    }).finally(function () {
+      if (! --pendingRequests) {
+        _DevLoadingView.default.hide();
+      }
+    });
+    cachedPromisesByUrl.set(requestUrl, loadPromise);
+    return loadPromise;
+  }
+},301,[1,34,253,280,277,168],"../../node_modules/react-native/Libraries/Core/Devtools/loadBundleFromServer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.AppRegistry = void 0;
+  var _registerCallableModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../Core/registerCallableModule"));
+  var AppRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[2], "./AppRegistryImpl"));
+  exports.AppRegistry = AppRegistry;
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  AppRegistry.registerComponent('LogBox', function () {
+    if (__DEV__ && typeof jest === 'undefined') {
+      return _$$_REQUIRE(_dependencyMap[3], "../LogBox/LogBoxInspectorContainer").default;
+    } else {
+      return function NoOp() {
+        return null;
+      };
+    }
+  });
+  global.RN$AppRegistry = AppRegistry;
+  global.RN$SurfaceRegistry = {
+    renderSurface: AppRegistry.runApplication,
+    setSurfaceProps: AppRegistry.setSurfaceProps
+  };
+  (0, _registerCallableModule.default)('AppRegistry', AppRegistry);
+},302,[1,276,303,495],"../../node_modules/react-native/Libraries/ReactNative/AppRegistry.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.cancelHeadlessTask = cancelHeadlessTask;
+  exports.getAppKeys = getAppKeys;
+  exports.getRegistry = getRegistry;
+  exports.getRunnable = getRunnable;
+  exports.getSectionKeys = getSectionKeys;
+  exports.getSections = getSections;
+  exports.registerCancellableHeadlessTask = registerCancellableHeadlessTask;
+  exports.registerComponent = registerComponent;
+  exports.registerConfig = registerConfig;
+  exports.registerHeadlessTask = registerHeadlessTask;
+  exports.registerRunnable = registerRunnable;
+  exports.registerSection = registerSection;
+  exports.runApplication = runApplication;
+  exports.setComponentProviderInstrumentationHook = setComponentProviderInstrumentationHook;
+  exports.setRootViewStyleProvider = setRootViewStyleProvider;
+  exports.setSurfaceProps = setSurfaceProps;
+  exports.setWrapperComponentProvider = setWrapperComponentProvider;
+  exports.startHeadlessTask = startHeadlessTask;
+  exports.unmountApplicationComponentAtRootTag = unmountApplicationComponentAtRootTag;
+  var _BugReporting = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../BugReporting/BugReporting"));
+  var _createPerformanceLogger = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../Utilities/createPerformanceLogger"));
+  var _infoLog = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../Utilities/infoLog"));
+  var _SceneTracker = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../Utilities/SceneTracker"));
+  var _HeadlessJsTaskError = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./HeadlessJsTaskError"));
+  var _NativeHeadlessJsTaskSupport = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./NativeHeadlessJsTaskSupport"));
+  var _renderApplication = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./renderApplication"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "invariant"));
+  var runnables = {};
+  var runCount = 1;
+  var sections = {};
+  var taskProviders = new Map();
+  var taskCancelProviders = new Map();
+  var componentProviderInstrumentationHook = function componentProviderInstrumentationHook(component) {
+    return component();
+  };
+  var wrapperComponentProvider;
+  var rootViewStyleProvider;
+  function setWrapperComponentProvider(provider) {
+    wrapperComponentProvider = provider;
+  }
+  function setRootViewStyleProvider(provider) {
+    rootViewStyleProvider = provider;
+  }
+  function registerConfig(config) {
+    config.forEach(function (appConfig) {
+      if (appConfig.run) {
+        registerRunnable(appConfig.appKey, appConfig.run);
+      } else {
+        (0, _invariant.default)(appConfig.component != null, 'AppRegistry.registerConfig(...): Every config is expected to set ' + 'either `run` or `component`, but `%s` has neither.', appConfig.appKey);
+        registerComponent(appConfig.appKey, appConfig.component, appConfig.section);
+      }
+    });
+  }
+  function registerComponent(appKey, componentProvider, section) {
+    var scopedPerformanceLogger = (0, _createPerformanceLogger.default)();
+    runnables[appKey] = function (appParameters, displayMode) {
+      (0, _renderApplication.default)(componentProviderInstrumentationHook(componentProvider, scopedPerformanceLogger), appParameters.initialProps, appParameters.rootTag, wrapperComponentProvider && wrapperComponentProvider(appParameters), rootViewStyleProvider && rootViewStyleProvider(appParameters), appParameters.fabric, scopedPerformanceLogger, appKey === 'LogBox', appKey, displayMode);
+    };
+    if (section) {
+      sections[appKey] = runnables[appKey];
+    }
+    return appKey;
+  }
+  function registerRunnable(appKey, run) {
+    runnables[appKey] = run;
+    return appKey;
+  }
+  function registerSection(appKey, component) {
+    registerComponent(appKey, component, true);
+  }
+  function getAppKeys() {
+    return Object.keys(runnables);
+  }
+  function getSectionKeys() {
+    return Object.keys(sections);
+  }
+  function getSections() {
+    return Object.assign({}, sections);
+  }
+  function getRunnable(appKey) {
+    return runnables[appKey];
+  }
+  function getRegistry() {
+    return {
+      sections: getSectionKeys(),
+      runnables: Object.assign({}, runnables)
+    };
+  }
+  function setComponentProviderInstrumentationHook(hook) {
+    componentProviderInstrumentationHook = hook;
+  }
+  function runApplication(appKey, appParameters, displayMode) {
+    if (appKey !== 'LogBox') {
+      var logParams = __DEV__ ? ` with ${JSON.stringify(appParameters)}` : '';
+      var msg = `Running "${appKey}"${logParams}`;
+      (0, _infoLog.default)(msg);
+      _BugReporting.default.addSource('AppRegistry.runApplication' + runCount++, function () {
+        return msg;
+      });
+    }
+    (0, _invariant.default)(runnables[appKey], `"${appKey}" has not been registered. This can happen if:\n` + '* Metro (the local dev server) is run from the wrong folder. ' + 'Check if Metro is running, stop it and restart it in the current project.\n' + "* A module failed to load due to an error and `AppRegistry.registerComponent` wasn't called.");
+    _SceneTracker.default.setActiveScene({
+      name: appKey
+    });
+    runnables[appKey](appParameters, (0, _$$_REQUIRE(_dependencyMap[9], "./DisplayMode").coerceDisplayMode)(displayMode));
+  }
+  function setSurfaceProps(appKey, appParameters, displayMode) {
+    if (appKey !== 'LogBox') {
+      var msg = 'Updating props for Surface "' + appKey + '" with ' + JSON.stringify(appParameters);
+      (0, _infoLog.default)(msg);
+      _BugReporting.default.addSource('AppRegistry.setSurfaceProps' + runCount++, function () {
+        return msg;
+      });
+    }
+    (0, _invariant.default)(runnables[appKey], `"${appKey}" has not been registered. This can happen if:\n` + '* Metro (the local dev server) is run from the wrong folder. ' + 'Check if Metro is running, stop it and restart it in the current project.\n' + "* A module failed to load due to an error and `AppRegistry.registerComponent` wasn't called.");
+    runnables[appKey](appParameters, (0, _$$_REQUIRE(_dependencyMap[9], "./DisplayMode").coerceDisplayMode)(displayMode));
+  }
+  function unmountApplicationComponentAtRootTag(rootTag) {
+    (0, _$$_REQUIRE(_dependencyMap[10], "./RendererProxy").unmountComponentAtNodeAndRemoveContainer)(rootTag);
+  }
+  function registerHeadlessTask(taskKey, taskProvider) {
+    registerCancellableHeadlessTask(taskKey, taskProvider, function () {
+      return function () {};
+    });
+  }
+  function registerCancellableHeadlessTask(taskKey, taskProvider, taskCancelProvider) {
+    if (taskProviders.has(taskKey)) {
+      console.warn(`registerHeadlessTask or registerCancellableHeadlessTask called multiple times for same key '${taskKey}'`);
+    }
+    taskProviders.set(taskKey, taskProvider);
+    taskCancelProviders.set(taskKey, taskCancelProvider);
+  }
+  function startHeadlessTask(taskId, taskKey, data) {
+    var taskProvider = taskProviders.get(taskKey);
+    if (!taskProvider) {
+      console.warn(`No task registered for key ${taskKey}`);
+      if (_NativeHeadlessJsTaskSupport.default) {
+        _NativeHeadlessJsTaskSupport.default.notifyTaskFinished(taskId);
+      }
+      return;
+    }
+    taskProvider()(data).then(function () {
+      if (_NativeHeadlessJsTaskSupport.default) {
+        _NativeHeadlessJsTaskSupport.default.notifyTaskFinished(taskId);
+      }
+    }).catch(function (reason) {
+      console.error(reason);
+      if (_NativeHeadlessJsTaskSupport.default && reason instanceof _HeadlessJsTaskError.default) {
+        _NativeHeadlessJsTaskSupport.default.notifyTaskRetry(taskId).then(function (retryPosted) {
+          if (!retryPosted) {
+            _NativeHeadlessJsTaskSupport.default.notifyTaskFinished(taskId);
+          }
+        });
+      }
+    });
+  }
+  function cancelHeadlessTask(taskId, taskKey) {
+    var taskCancelProvider = taskCancelProviders.get(taskKey);
+    if (!taskCancelProvider) {
+      throw new Error(`No task canceller registered for key '${taskKey}'`);
+    }
+    taskCancelProvider()();
+  }
+},303,[1,304,251,252,308,309,310,312,32,492,106],"../../node_modules/react-native/Libraries/ReactNative/AppRegistryImpl.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+  var _RCTDeviceEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../EventEmitter/RCTDeviceEventEmitter"));
+  var _NativeRedBox = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../NativeModules/specs/NativeRedBox"));
+  var _NativeBugReporting = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./NativeBugReporting"));
+  function defaultExtras() {
+    BugReporting.addFileSource('react_hierarchy.txt', function () {
+      return _$$_REQUIRE(_dependencyMap[7], "./dumpReactTree").default();
+    });
+  }
+  var BugReporting = /*#__PURE__*/function () {
+    function BugReporting() {
+      (0, _classCallCheck2.default)(this, BugReporting);
+    }
+    return (0, _createClass2.default)(BugReporting, null, [{
+      key: "_maybeInit",
+      value: function _maybeInit() {
+        if (!BugReporting._subscription) {
+          BugReporting._subscription = _RCTDeviceEventEmitter.default.addListener('collectBugExtraData', BugReporting.collectExtraData, null);
+          defaultExtras();
+        }
+        if (!BugReporting._redboxSubscription) {
+          BugReporting._redboxSubscription = _RCTDeviceEventEmitter.default.addListener('collectRedBoxExtraData', BugReporting.collectExtraData, null);
+        }
+      }
+    }, {
+      key: "addSource",
+      value: function addSource(key, callback) {
+        return this._addSource(key, callback, BugReporting._extraSources);
+      }
+    }, {
+      key: "addFileSource",
+      value: function addFileSource(key, callback) {
+        return this._addSource(key, callback, BugReporting._fileSources);
+      }
+    }, {
+      key: "_addSource",
+      value: function _addSource(key, callback, source) {
+        BugReporting._maybeInit();
+        if (source.has(key)) {
+          console.warn(`BugReporting.add* called multiple times for same key '${key}'`);
+        }
+        source.set(key, callback);
+        return {
+          remove: function remove() {
+            source.delete(key);
+          }
+        };
+      }
+    }, {
+      key: "collectExtraData",
+      value: function collectExtraData() {
+        var extraData = {};
+        for (var _ref of BugReporting._extraSources) {
+          var _ref2 = (0, _slicedToArray2.default)(_ref, 2);
+          var _key = _ref2[0];
+          var callback = _ref2[1];
+          extraData[_key] = callback();
+        }
+        var fileData = {};
+        for (var _ref3 of BugReporting._fileSources) {
+          var _ref4 = (0, _slicedToArray2.default)(_ref3, 2);
+          var _key2 = _ref4[0];
+          var _callback = _ref4[1];
+          fileData[_key2] = _callback();
+        }
+        if (_NativeBugReporting.default != null && _NativeBugReporting.default.setExtraData != null) {
+          _NativeBugReporting.default.setExtraData(extraData, fileData);
+        }
+        if (_NativeRedBox.default != null && _NativeRedBox.default.setExtraData != null) {
+          _NativeRedBox.default.setExtraData(extraData, 'From BugReporting.js');
+        }
+        return {
+          extras: extraData,
+          files: fileData
+        };
+      }
+    }]);
+  }();
+  BugReporting._extraSources = new Map();
+  BugReporting._fileSources = new Map();
+  BugReporting._subscription = null;
+  BugReporting._redboxSubscription = null;
+  var _default = exports.default = BugReporting;
+},304,[1,34,11,12,17,278,305,307],"../../node_modules/react-native/Libraries/BugReporting/BugReporting.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeBugReporting = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativeBugReporting"));
+  Object.keys(_NativeBugReporting).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeBugReporting[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeBugReporting[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeBugReporting.default;
+},305,[306],"../../node_modules/react-native/Libraries/BugReporting/NativeBugReporting.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.get('BugReporting');
+},306,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeBugReporting.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  function dumpReactTree() {
+    try {
+      return getReactTree();
+    } catch (e) {
+      return 'Failed to dump react tree: ' + e;
+    }
+  }
+  function getReactTree() {
+    return 'React tree dumps have been temporarily disabled while React is ' + 'upgraded to Fiber.';
+  }
+  var _default = exports.default = dumpReactTree;
+},307,[],"../../node_modules/react-native/Libraries/BugReporting/dumpReactTree.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _listeners = [];
+  var _activeScene = {
+    name: 'default'
+  };
+  var SceneTracker = {
+    setActiveScene: function setActiveScene(scene) {
+      _activeScene = scene;
+      _listeners.forEach(function (listener) {
+        return listener(_activeScene);
+      });
+    },
+    getActiveScene: function getActiveScene() {
+      return _activeScene;
+    },
+    addActiveSceneChangedListener: function addActiveSceneChangedListener(callback) {
+      _listeners.push(callback);
+      return {
+        remove: function remove() {
+          _listeners = _listeners.filter(function (listener) {
+            return callback !== listener;
+          });
+        }
+      };
+    }
+  };
+  var _default = exports.default = SceneTracker;
+},308,[],"../../node_modules/react-native/Libraries/Utilities/SceneTracker.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var _wrapNativeSuper2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/wrapNativeSuper"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var HeadlessJsTaskError = exports.default = /*#__PURE__*/function (_Error) {
+    function HeadlessJsTaskError() {
+      (0, _classCallCheck2.default)(this, HeadlessJsTaskError);
+      return _callSuper(this, HeadlessJsTaskError, arguments);
+    }
+    (0, _inherits2.default)(HeadlessJsTaskError, _Error);
+    return (0, _createClass2.default)(HeadlessJsTaskError);
+  }(/*#__PURE__*/(0, _wrapNativeSuper2.default)(Error));
+},309,[1,12,11,18,20,23,175],"../../node_modules/react-native/Libraries/ReactNative/HeadlessJsTaskError.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeHeadlessJsTaskSupport = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativeHeadlessJsTaskSupport"));
+  Object.keys(_NativeHeadlessJsTaskSupport).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeHeadlessJsTaskSupport[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeHeadlessJsTaskSupport[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeHeadlessJsTaskSupport.default;
+},310,[311],"../../node_modules/react-native/Libraries/ReactNative/NativeHeadlessJsTaskSupport.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.get('HeadlessJsTaskSupport');
+},311,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeHeadlessJsTaskSupport.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = renderApplication;
+  var _GlobalPerformanceLogger = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../Utilities/GlobalPerformanceLogger"));
+  var _PerformanceLoggerContext = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../Utilities/PerformanceLoggerContext"));
+  var _warnOnce = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../Utilities/warnOnce"));
+  var _AppContainer = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./AppContainer"));
+  var _DisplayMode = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./DisplayMode"));
+  var _getCachedComponentWithDebugName = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./getCachedComponentWithDebugName"));
+  var Renderer = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "./RendererProxy"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "invariant"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[9], "react"));
+  _$$_REQUIRE(_dependencyMap[10], "../Utilities/BackHandler");
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[11], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/ReactNative/renderApplication.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function renderApplication(RootComponent, initialProps, rootTag, WrapperComponent, rootViewStyle, fabric, scopedPerformanceLogger, isLogBox, debugName, displayMode, useOffscreen) {
+    (0, _invariant.default)(rootTag, 'Expect to have a valid rootTag, instead got ', rootTag);
+    var performanceLogger = scopedPerformanceLogger != null ? scopedPerformanceLogger : _GlobalPerformanceLogger.default;
+    var renderable = /*#__PURE__*/(0, _jsxRuntime.jsx)(_PerformanceLoggerContext.default.Provider, {
+      value: performanceLogger,
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_AppContainer.default, {
+        rootTag: rootTag,
+        fabric: fabric,
+        WrapperComponent: WrapperComponent,
+        rootViewStyle: rootViewStyle,
+        initialProps: initialProps != null ? initialProps : Object.freeze({}),
+        internal_excludeLogBox: isLogBox,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(RootComponent, Object.assign({}, initialProps, {
+          rootTag: rootTag
+        }))
+      })
+    });
+    if (__DEV__ && debugName) {
+      var RootComponentWithMeaningfulName = (0, _getCachedComponentWithDebugName.default)(`${debugName}(RootComponent)`);
+      renderable = /*#__PURE__*/(0, _jsxRuntime.jsx)(RootComponentWithMeaningfulName, {
+        children: renderable
+      });
+    }
+    if (useOffscreen && displayMode != null) {
+      var Activity = React.unstable_Activity;
+      renderable = /*#__PURE__*/(0, _jsxRuntime.jsx)(Activity, {
+        mode: displayMode === _DisplayMode.default.VISIBLE ? 'visible' : 'hidden',
+        children: renderable
+      });
+    }
+    var useConcurrentRoot = Boolean(fabric);
+    performanceLogger.startTimespan('renderApplication_React_render');
+    performanceLogger.setExtra('usedReactConcurrentRoot', useConcurrentRoot ? '1' : '0');
+    performanceLogger.setExtra('usedReactFabric', fabric ? '1' : '0');
+    performanceLogger.setExtra('usedReactProfiler', Renderer.isProfilingRenderer());
+    Renderer.renderElement({
+      element: renderable,
+      rootTag: rootTag,
+      useFabric: Boolean(fabric),
+      useConcurrentRoot: useConcurrentRoot
+    });
+    var newArchitecture = !!fabric;
+    if (!newArchitecture) {
+      (0, _warnOnce.default)('[OSS][OldArchDeprecatedWarning]', 'The app is running using the Legacy Architecture. The Legacy Architecture is deprecated and will be removed in a future version of React Native. Please consider migrating to the New Architecture. For more information, please see https://reactnative.dev/blog/2024/10/23/the-new-architecture-is-here');
+    }
+    performanceLogger.stopTimespan('renderApplication_React_render');
+  }
+},312,[1,250,313,46,314,492,493,106,32,73,494,171],"../../node_modules/react-native/Libraries/ReactNative/renderApplication.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  exports.usePerformanceLogger = usePerformanceLogger;
+  var _GlobalPerformanceLogger = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./GlobalPerformanceLogger"));
+  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[2], "react"));
+  var React = _react;
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var PerformanceLoggerContext = React.createContext(_GlobalPerformanceLogger.default);
+  if (__DEV__) {
+    PerformanceLoggerContext.displayName = 'PerformanceLoggerContext';
+  }
+  function usePerformanceLogger() {
+    return (0, _react.useContext)(PerformanceLoggerContext);
+  }
+  var _default = exports.default = PerformanceLoggerContext;
+},313,[1,250,73],"../../node_modules/react-native/Libraries/Utilities/PerformanceLoggerContext.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var AppContainer = __DEV__ ? _$$_REQUIRE(_dependencyMap[1], "./AppContainer-dev").default : _$$_REQUIRE(_dependencyMap[2], "./AppContainer-prod").default;
+  var _default = exports.default = AppContainer;
+},314,[73,315,491],"../../node_modules/react-native/Libraries/ReactNative/AppContainer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _ReactNativeStyleAttributes = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../Components/View/ReactNativeStyleAttributes"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../Components/View/View"));
+  var _DebuggingOverlay = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../Debugging/DebuggingOverlay"));
+  var _useSubscribeToDebuggingOverlayRegistry = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../Debugging/useSubscribeToDebuggingOverlayRegistry"));
+  var _RCTDeviceEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../EventEmitter/RCTDeviceEventEmitter"));
+  var _LogBoxNotificationContainer = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../LogBox/LogBoxNotificationContainer"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../StyleSheet/StyleSheet"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[9], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[10], "react/jsx-runtime");
+  var _this = this,
+    _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/ReactNative/AppContainer-dev.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var useEffect = React.useEffect,
+    useState = React.useState,
+    useCallback = React.useCallback;
+  var reactDevToolsHook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+  if (reactDevToolsHook) {
+    reactDevToolsHook.resolveRNStyle = _$$_REQUIRE(_dependencyMap[11], "../StyleSheet/flattenStyle").default;
+    reactDevToolsHook.nativeStyleEditorValidAttributes = Object.keys(_ReactNativeStyleAttributes.default);
+  }
+  var InspectorDeferred = function InspectorDeferred(_ref) {
+    var inspectedViewRef = _ref.inspectedViewRef,
+      onInspectedViewRerenderRequest = _ref.onInspectedViewRerenderRequest,
+      reactDevToolsAgent = _ref.reactDevToolsAgent;
+    var Inspector = _$$_REQUIRE(_dependencyMap[12], "../../src/private/devsupport/devmenu/elementinspector/Inspector").default;
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(Inspector, {
+      inspectedViewRef: inspectedViewRef,
+      onRequestRerenderApp: onInspectedViewRerenderRequest,
+      reactDevToolsAgent: reactDevToolsAgent
+    });
+  };
+  var ReactDevToolsOverlayDeferred = function ReactDevToolsOverlayDeferred(_ref2) {
+    var inspectedViewRef = _ref2.inspectedViewRef,
+      reactDevToolsAgent = _ref2.reactDevToolsAgent;
+    var ReactDevToolsOverlay = _$$_REQUIRE(_dependencyMap[13], "../../src/private/devsupport/devmenu/elementinspector/ReactDevToolsOverlay").default;
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(ReactDevToolsOverlay, {
+      inspectedViewRef: inspectedViewRef,
+      reactDevToolsAgent: reactDevToolsAgent
+    });
+  };
+  var AppContainer = function AppContainer(_ref3) {
+    var children = _ref3.children,
+      fabric = _ref3.fabric,
+      initialProps = _ref3.initialProps,
+      _ref3$internal_exclud = _ref3.internal_excludeInspector,
+      internal_excludeInspector = _ref3$internal_exclud === void 0 ? false : _ref3$internal_exclud,
+      _ref3$internal_exclud2 = _ref3.internal_excludeLogBox,
+      internal_excludeLogBox = _ref3$internal_exclud2 === void 0 ? false : _ref3$internal_exclud2,
+      rootTag = _ref3.rootTag,
+      WrapperComponent = _ref3.WrapperComponent,
+      rootViewStyle = _ref3.rootViewStyle;
+    var appContainerRootViewRef = React.useRef(null);
+    var innerViewRef = React.useRef(null);
+    var debuggingOverlayRef = React.useRef(null);
+    (0, _useSubscribeToDebuggingOverlayRegistry.default)(appContainerRootViewRef, debuggingOverlayRef);
+    var _useState = useState(0),
+      _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+      key = _useState2[0],
+      setKey = _useState2[1];
+    var _useState3 = useState(false),
+      _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
+      shouldRenderInspector = _useState4[0],
+      setShouldRenderInspector = _useState4[1];
+    var _useState5 = useState(reactDevToolsHook == null ? void 0 : reactDevToolsHook.reactDevtoolsAgent),
+      _useState6 = (0, _slicedToArray2.default)(_useState5, 2),
+      reactDevToolsAgent = _useState6[0],
+      setReactDevToolsAgent = _useState6[1];
+    useEffect(function () {
+      var inspectorSubscription = null;
+      if (!internal_excludeInspector) {
+        inspectorSubscription = _RCTDeviceEventEmitter.default.addListener('toggleElementInspector', function () {
+          return setShouldRenderInspector(function (value) {
+            return !value;
+          });
+        });
+      }
+      var reactDevToolsAgentListener = null;
+      if (reactDevToolsHook != null && reactDevToolsAgent == null) {
+        reactDevToolsAgentListener = setReactDevToolsAgent;
+        reactDevToolsHook.on == null || reactDevToolsHook.on('react-devtools', reactDevToolsAgentListener);
+      }
+      return function () {
+        var _inspectorSubscriptio;
+        (_inspectorSubscriptio = inspectorSubscription) == null || _inspectorSubscriptio.remove();
+        if ((reactDevToolsHook == null ? void 0 : reactDevToolsHook.off) != null && reactDevToolsAgentListener != null) {
+          reactDevToolsHook.off('react-devtools', reactDevToolsAgentListener);
+        }
+      };
+    }, []);
+    var innerView = /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+      collapsable: reactDevToolsAgent == null && !shouldRenderInspector,
+      pointerEvents: "box-none",
+      style: rootViewStyle || styles.container,
+      ref: innerViewRef,
+      children: children
+    }, key);
+    if (WrapperComponent != null) {
+      innerView = /*#__PURE__*/(0, _jsxRuntime.jsx)(WrapperComponent, {
+        initialProps: initialProps,
+        fabric: fabric === true,
+        children: innerView
+      });
+    }
+    var onInspectedViewRerenderRequest = useCallback(function () {
+      return setKey(function (k) {
+        return k + 1;
+      });
+    }, []);
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[14], "./RootTag").RootTagContext.Provider, {
+      value: (0, _$$_REQUIRE(_dependencyMap[14], "./RootTag").createRootTag)(rootTag),
+      children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_View.default, {
+        ref: appContainerRootViewRef,
+        style: rootViewStyle || styles.container,
+        pointerEvents: "box-none",
+        children: [innerView, /*#__PURE__*/(0, _jsxRuntime.jsx)(_DebuggingOverlay.default, {
+          ref: debuggingOverlayRef
+        }), reactDevToolsAgent != null && /*#__PURE__*/(0, _jsxRuntime.jsx)(ReactDevToolsOverlayDeferred, {
+          inspectedViewRef: innerViewRef,
+          reactDevToolsAgent: reactDevToolsAgent
+        }), shouldRenderInspector && /*#__PURE__*/(0, _jsxRuntime.jsx)(InspectorDeferred, {
+          inspectedViewRef: innerViewRef,
+          onInspectedViewRerenderRequest: onInspectedViewRerenderRequest,
+          reactDevToolsAgent: reactDevToolsAgent
+        }), !internal_excludeLogBox && /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxNotificationContainer.default, {})]
+      })
+    });
+  };
+  var styles = _StyleSheet.default.create({
+    container: {
+      flex: 1
+    }
+  });
+  var _default = exports.default = AppContainer;
+},315,[1,34,51,71,316,332,17,334,6,73,171,9,375,490,360],"../../node_modules/react-native/Libraries/ReactNative/AppContainer-dev.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../Components/View/View"));
+  var _UIManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../ReactNative/UIManager"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../StyleSheet/StyleSheet"));
+  var _DebuggingOverlayNativeComponent = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[4], "./DebuggingOverlayNativeComponent"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[5], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[6], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Debugging/DebuggingOverlay.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var useRef = React.useRef,
+    useImperativeHandle = React.useImperativeHandle;
+  var isNativeComponentReady = _UIManager.default.hasViewManagerConfig('DebuggingOverlay');
+  function DebuggingOverlay(_props, ref) {
+    useImperativeHandle(ref, function () {
+      return {
+        highlightTraceUpdates: function highlightTraceUpdates(updates) {
+          if (!isNativeComponentReady) {
+            return;
+          }
+          var nonEmptyRectangles = updates.filter(function (_ref) {
+            var rectangle = _ref.rectangle,
+              color = _ref.color;
+            return rectangle.width >= 0 && rectangle.height >= 0;
+          });
+          if (nativeComponentRef.current != null) {
+            _DebuggingOverlayNativeComponent.Commands.highlightTraceUpdates(nativeComponentRef.current, nonEmptyRectangles);
+          }
+        },
+        highlightElements: function highlightElements(elements) {
+          if (!isNativeComponentReady) {
+            return;
+          }
+          if (nativeComponentRef.current != null) {
+            _DebuggingOverlayNativeComponent.Commands.highlightElements(nativeComponentRef.current, elements);
+          }
+        },
+        clearElementsHighlight: function clearElementsHighlight() {
+          if (!isNativeComponentReady) {
+            return;
+          }
+          if (nativeComponentRef.current != null) {
+            _DebuggingOverlayNativeComponent.Commands.clearElementsHighlights(nativeComponentRef.current);
+          }
+        }
+      };
+    }, []);
+    var nativeComponentRef = useRef(null);
+    return isNativeComponentReady && /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+      pointerEvents: "none",
+      style: styles.overlay,
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_DebuggingOverlayNativeComponent.default, {
+        ref: nativeComponentRef,
+        style: styles.overlay
+      })
+    });
+  }
+  var styles = _StyleSheet.default.create({
+    overlay: {
+      position: 'absolute',
+      top: 0,
+      bottom: 0,
+      left: 0,
+      right: 0
+    }
+  });
+  var DebuggingOverlayWithForwardedRef = React.forwardRef(DebuggingOverlay);
+  var _default = exports.default = DebuggingOverlayWithForwardedRef;
+},316,[1,71,79,6,317,73,171],"../../node_modules/react-native/Libraries/Debugging/DebuggingOverlay.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _DebuggingOverlayNativeComponent = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/components/DebuggingOverlayNativeComponent"));
+  Object.keys(_DebuggingOverlayNativeComponent).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _DebuggingOverlayNativeComponent[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _DebuggingOverlayNativeComponent[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _DebuggingOverlayNativeComponent.default;
+},317,[318],"../../node_modules/react-native/Libraries/Debugging/DebuggingOverlayNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = exports.__INTERNAL_VIEW_CONFIG = exports.Commands = void 0;
+  var _codegenNativeCommands = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../../../Libraries/Utilities/codegenNativeCommands"));
+  var _codegenNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../../../Libraries/Utilities/codegenNativeComponent"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[3], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var nativeComponentName = 'DebuggingOverlay';
+  var __INTERNAL_VIEW_CONFIG = exports.__INTERNAL_VIEW_CONFIG = {
+    uiViewClassName: "DebuggingOverlay",
+    validAttributes: {}
+  };
+  var _default = exports.default = _$$_REQUIRE(_dependencyMap[4], "react-native/Libraries/NativeComponent/NativeComponentRegistry").get(nativeComponentName, function () {
+    return __INTERNAL_VIEW_CONFIG;
+  });
+  var Commands = exports.Commands = {
+    highlightTraceUpdates: function highlightTraceUpdates(ref, updates) {
+      _$$_REQUIRE(_dependencyMap[5], "react-native/Libraries/ReactNative/RendererProxy").dispatchCommand(ref, "highlightTraceUpdates", [updates]);
+    },
+    highlightElements: function highlightElements(ref, elements) {
+      _$$_REQUIRE(_dependencyMap[5], "react-native/Libraries/ReactNative/RendererProxy").dispatchCommand(ref, "highlightElements", [elements]);
+    },
+    clearElementsHighlights: function clearElementsHighlights(ref) {
+      _$$_REQUIRE(_dependencyMap[5], "react-native/Libraries/ReactNative/RendererProxy").dispatchCommand(ref, "clearElementsHighlights", []);
+    }
+  };
+},318,[1,105,319,73,77,106],"../../node_modules/react-native/src/private/specs_DEPRECATED/components/DebuggingOverlayNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _requireNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Libraries/ReactNative/requireNativeComponent"));
+  var _UIManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../ReactNative/UIManager"));
+  function codegenNativeComponent(componentName, options) {
+    if (global.RN$Bridgeless === true && __DEV__) {
+      console.warn(`Codegen didn't run for ${componentName}. This will be an error in the future. Make sure you are using @react-native/babel-preset when building your JavaScript code.`);
+    }
+    var componentNameInUse = options && options.paperComponentName != null ? options.paperComponentName : componentName;
+    if (options != null && options.paperComponentNameDeprecated != null) {
+      if (_UIManager.default.hasViewManagerConfig(componentName)) {
+        componentNameInUse = componentName;
+      } else if (options.paperComponentNameDeprecated != null && _UIManager.default.hasViewManagerConfig(options.paperComponentNameDeprecated)) {
+        componentNameInUse = options.paperComponentNameDeprecated;
+      } else {
+        var _options$paperCompone;
+        throw new Error(`Failed to find native component for either ${componentName} or ${(_options$paperCompone = options.paperComponentNameDeprecated) != null ? _options$paperCompone : '(unknown)'}`);
+      }
+    }
+    return (0, _requireNativeComponent.default)(componentNameInUse);
+  }
+  var _default = exports.default = codegenNativeComponent;
+},319,[1,320,79],"../../node_modules/react-native/Libraries/Utilities/codegenNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var requireNativeComponent = function requireNativeComponent(uiViewClassName) {
+    return _$$_REQUIRE(_dependencyMap[0], "../Renderer/shims/createReactNativeComponentClass").default(uiViewClassName, function () {
+      return _$$_REQUIRE(_dependencyMap[1], "./getNativeComponentAttributes").default(uiViewClassName);
+    });
+  };
+  var _default = exports.default = requireNativeComponent;
+},320,[321,78],"../../node_modules/react-native/Libraries/ReactNative/requireNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var register = _$$_REQUIRE(_dependencyMap[0], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").ReactNativeViewConfigRegistry.register;
+  var createReactNativeComponentClass = function createReactNativeComponentClass(name, callback) {
+    return register(name, callback);
+  };
+  var _default = exports.default = createReactNativeComponentClass;
+},321,[322],"../../node_modules/react-native/Libraries/Renderer/shims/createReactNativeComponentClass.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  module.exports = {
+    get BatchedBridge() {
+      return _$$_REQUIRE(_dependencyMap[0], "../BatchedBridge/BatchedBridge").default;
+    },
+    get ExceptionsManager() {
+      return _$$_REQUIRE(_dependencyMap[1], "../Core/ExceptionsManager").default;
+    },
+    get Platform() {
+      return _$$_REQUIRE(_dependencyMap[2], "../Utilities/Platform").default;
+    },
+    get RCTEventEmitter() {
+      return _$$_REQUIRE(_dependencyMap[3], "../EventEmitter/RCTEventEmitter").default;
+    },
+    get ReactNativeViewConfigRegistry() {
+      return _$$_REQUIRE(_dependencyMap[4], "../Renderer/shims/ReactNativeViewConfigRegistry");
+    },
+    get TextInputState() {
+      return _$$_REQUIRE(_dependencyMap[5], "../Components/TextInput/TextInputState").default;
+    },
+    get UIManager() {
+      return _$$_REQUIRE(_dependencyMap[6], "../ReactNative/UIManager").default;
+    },
+    get deepDiffer() {
+      return _$$_REQUIRE(_dependencyMap[7], "../Utilities/differ/deepDiffer").default;
+    },
+    get deepFreezeAndThrowOnMutationInDev() {
+      return _$$_REQUIRE(_dependencyMap[8], "../Utilities/deepFreezeAndThrowOnMutationInDev").default;
+    },
+    get flattenStyle() {
+      return _$$_REQUIRE(_dependencyMap[9], "../StyleSheet/flattenStyle").default;
+    },
+    get ReactFiberErrorDialog() {
+      return _$$_REQUIRE(_dependencyMap[10], "../Core/ReactFiberErrorDialog").default;
+    },
+    get legacySendAccessibilityEvent() {
+      return _$$_REQUIRE(_dependencyMap[11], "../Components/AccessibilityInfo/legacySendAccessibilityEvent").default;
+    },
+    get RawEventEmitter() {
+      return _$$_REQUIRE(_dependencyMap[12], "../Core/RawEventEmitter").default;
+    },
+    get CustomEvent() {
+      return _$$_REQUIRE(_dependencyMap[13], "../../src/private/webapis/dom/events/CustomEvent").default;
+    },
+    get createAttributePayload() {
+      return _$$_REQUIRE(_dependencyMap[14], "../ReactNative/ReactFabricPublicInstance/ReactNativeAttributePayload").create;
+    },
+    get diffAttributePayloads() {
+      return _$$_REQUIRE(_dependencyMap[14], "../ReactNative/ReactFabricPublicInstance/ReactNativeAttributePayload").diff;
+    },
+    get createPublicRootInstance() {
+      return _$$_REQUIRE(_dependencyMap[15], "../ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstance").createPublicRootInstance;
+    },
+    get createPublicInstance() {
+      return _$$_REQUIRE(_dependencyMap[15], "../ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstance").createPublicInstance;
+    },
+    get createPublicTextInstance() {
+      return _$$_REQUIRE(_dependencyMap[15], "../ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstance").createPublicTextInstance;
+    },
+    get getNativeTagFromPublicInstance() {
+      return _$$_REQUIRE(_dependencyMap[15], "../ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstance").getNativeTagFromPublicInstance;
+    },
+    get getNodeFromPublicInstance() {
+      return _$$_REQUIRE(_dependencyMap[15], "../ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstance").getNodeFromPublicInstance;
+    },
+    get getInternalInstanceHandleFromPublicInstance() {
+      return _$$_REQUIRE(_dependencyMap[15], "../ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstance").getInternalInstanceHandleFromPublicInstance;
+    }
+  };
+},322,[40,174,68,323,99,130,79,136,48,9,324,325,328,329,135,330],"../../node_modules/react-native/Libraries/ReactPrivate/ReactNativePrivateInterface.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _registerCallableModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../Core/registerCallableModule"));
+  var RCTEventEmitter = {
+    register: function register(eventEmitter) {
+      (0, _registerCallableModule.default)('RCTEventEmitter', eventEmitter);
+    }
+  };
+  var _default = exports.default = RCTEventEmitter;
+},323,[1,276],"../../node_modules/react-native/Libraries/EventEmitter/RCTEventEmitter.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _ExceptionsManager = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "./ExceptionsManager"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var ReactFiberErrorDialog = {
+    showErrorDialog: function showErrorDialog(_ref) {
+      var componentStack = _ref.componentStack,
+        errorValue = _ref.error;
+      var error;
+      if (errorValue instanceof Error) {
+        error = errorValue;
+      } else if (typeof errorValue === 'string') {
+        error = new _ExceptionsManager.SyntheticError(errorValue);
+      } else {
+        error = new _ExceptionsManager.SyntheticError('Unspecified error');
+      }
+      try {
+        error.componentStack = componentStack;
+        error.isComponentError = true;
+      } catch (_unused) {}
+      _ExceptionsManager.default.handleException(error, false);
+      return false;
+    }
+  };
+  var _default = exports.default = ReactFiberErrorDialog;
+},324,[174],"../../node_modules/react-native/Libraries/Core/ReactFiberErrorDialog.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _NativeAccessibilityManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativeAccessibilityManager"));
+  function legacySendAccessibilityEvent(reactTag, eventType) {
+    if (eventType === 'focus' && _NativeAccessibilityManager.default) {
+      _NativeAccessibilityManager.default.setAccessibilityFocus(reactTag);
+    }
+  }
+  var _default = exports.default = legacySendAccessibilityEvent;
+},325,[1,326],"../../node_modules/react-native/Libraries/Components/AccessibilityInfo/legacySendAccessibilityEvent.ios.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeAccessibilityManager = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../src/private/specs_DEPRECATED/modules/NativeAccessibilityManager"));
+  Object.keys(_NativeAccessibilityManager).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeAccessibilityManager[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeAccessibilityManager[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeAccessibilityManager.default;
+},326,[327],"../../node_modules/react-native/Libraries/Components/AccessibilityInfo/NativeAccessibilityManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.get('AccessibilityManager');
+},327,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeAccessibilityManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _EventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../vendor/emitter/EventEmitter"));
+  var RawEventEmitter = new _EventEmitter.default();
+  var _default = exports.default = RawEventEmitter;
+},328,[1,25],"../../node_modules/react-native/Libraries/Core/RawEventEmitter.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var _Event2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./Event"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var CustomEvent = exports.default = /*#__PURE__*/function (_Event) {
+    function CustomEvent(type, options) {
+      var _this;
+      (0, _classCallCheck2.default)(this, CustomEvent);
+      _this = _callSuper(this, CustomEvent, [type, options]);
+      _this._detail = options == null ? void 0 : options.detail;
+      return _this;
+    }
+    (0, _inherits2.default)(CustomEvent, _Event);
+    return (0, _createClass2.default)(CustomEvent, [{
+      key: "detail",
+      get: function get() {
+        return this._detail;
+      }
+    }]);
+  }(_Event2.default);
+},329,[1,11,12,18,20,23,226],"../../node_modules/react-native/src/private/webapis/dom/events/CustomEvent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.createPublicInstance = createPublicInstance;
+  exports.createPublicRootInstance = createPublicRootInstance;
+  exports.createPublicTextInstance = createPublicTextInstance;
+  exports.getInternalInstanceHandleFromPublicInstance = getInternalInstanceHandleFromPublicInstance;
+  exports.getNativeTagFromPublicInstance = getNativeTagFromPublicInstance;
+  exports.getNodeFromPublicInstance = getNodeFromPublicInstance;
+  var ReactNativeFeatureFlags = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../src/private/featureflags/ReactNativeFeatureFlags"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var ReactNativeDocumentModuleObject;
+  var ReactFabricHostComponentClass;
+  var ReactNativeElementClass;
+  var ReadOnlyTextClass;
+  var RendererProxy;
+  function getReactNativeDocumentModule() {
+    if (ReactNativeDocumentModuleObject == null) {
+      ReactNativeDocumentModuleObject = _$$_REQUIRE(_dependencyMap[1], "../../../src/private/webapis/dom/nodes/ReactNativeDocument");
+    }
+    return ReactNativeDocumentModuleObject;
+  }
+  function getReactNativeElementClass() {
+    if (ReactNativeElementClass == null) {
+      ReactNativeElementClass = _$$_REQUIRE(_dependencyMap[2], "../../../src/private/webapis/dom/nodes/ReactNativeElement").default;
+    }
+    return ReactNativeElementClass;
+  }
+  function getReactFabricHostComponentClass() {
+    if (ReactFabricHostComponentClass == null) {
+      ReactFabricHostComponentClass = _$$_REQUIRE(_dependencyMap[3], "./ReactFabricHostComponent").default;
+    }
+    return ReactFabricHostComponentClass;
+  }
+  function getReadOnlyTextClass() {
+    if (ReadOnlyTextClass == null) {
+      ReadOnlyTextClass = _$$_REQUIRE(_dependencyMap[4], "../../../src/private/webapis/dom/nodes/ReadOnlyText").default;
+    }
+    return ReadOnlyTextClass;
+  }
+  function createPublicRootInstance(rootTag) {
+    if (ReactNativeFeatureFlags.enableAccessToHostTreeInFabric()) {
+      var ReactNativeDocumentModule = getReactNativeDocumentModule();
+      return ReactNativeDocumentModule.createReactNativeDocument(rootTag);
+    }
+    return null;
+  }
+  function createPublicInstance(tag, viewConfig, internalInstanceHandle, ownerDocument) {
+    if (ReactNativeFeatureFlags.enableAccessToHostTreeInFabric()) {
+      var ReactNativeElement = getReactNativeElementClass();
+      return new ReactNativeElement(tag, viewConfig, internalInstanceHandle, ownerDocument);
+    } else {
+      var ReactFabricHostComponent = getReactFabricHostComponentClass();
+      return new ReactFabricHostComponent(tag, viewConfig, internalInstanceHandle);
+    }
+  }
+  function createPublicTextInstance(internalInstanceHandle, ownerDocument) {
+    var ReadOnlyText = getReadOnlyTextClass();
+    return new ReadOnlyText(internalInstanceHandle, ownerDocument);
+  }
+  function getNativeTagFromPublicInstance(publicInstance) {
+    return publicInstance.__nativeTag;
+  }
+  function getNodeFromPublicInstance(publicInstance) {
+    if (publicInstance.__internalInstanceHandle == null) {
+      return null;
+    }
+    if (RendererProxy == null) {
+      RendererProxy = _$$_REQUIRE(_dependencyMap[5], "../../ReactNative/RendererProxy");
+    }
+    return RendererProxy.getNodeFromInternalInstanceHandle(publicInstance.__internalInstanceHandle);
+  }
+  function getInternalInstanceHandleFromPublicInstance(publicInstance) {
+    if (publicInstance._internalInstanceHandle != null) {
+      return publicInstance._internalInstanceHandle;
+    }
+    return publicInstance.__internalInstanceHandle;
+  }
+},330,[52,128,129,331,138,106],"../../node_modules/react-native/Libraries/ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstance.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _TextInputState = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../Components/TextInput/TextInputState"));
+  var _warnForStyleProps = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./warnForStyleProps"));
+  var _nullthrows2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "nullthrows"));
+  var _nullthrows = (0, _nullthrows2.default)((0, _$$_REQUIRE(_dependencyMap[6], "../FabricUIManager").getFabricUIManager)()),
+    fabricMeasure = _nullthrows.measure,
+    fabricMeasureInWindow = _nullthrows.measureInWindow,
+    fabricMeasureLayout = _nullthrows.measureLayout,
+    fabricGetBoundingClientRect = _nullthrows.getBoundingClientRect,
+    _setNativeProps = _nullthrows.setNativeProps;
+  var noop = function noop() {};
+  var ReactFabricHostComponent = exports.default = /*#__PURE__*/function () {
+    function ReactFabricHostComponent(tag, viewConfig, internalInstanceHandle) {
+      (0, _classCallCheck2.default)(this, ReactFabricHostComponent);
+      this.__nativeTag = tag;
+      this._viewConfig = viewConfig;
+      this.__internalInstanceHandle = internalInstanceHandle;
+    }
+    return (0, _createClass2.default)(ReactFabricHostComponent, [{
+      key: "blur",
+      value: function blur() {
+        _TextInputState.default.blurTextInput(this);
+      }
+    }, {
+      key: "focus",
+      value: function focus() {
+        _TextInputState.default.focusTextInput(this);
+      }
+    }, {
+      key: "measure",
+      value: function measure(callback) {
+        var node = (0, _$$_REQUIRE(_dependencyMap[7], "../../ReactNative/RendererProxy").getNodeFromInternalInstanceHandle)(this.__internalInstanceHandle);
+        if (node != null) {
+          fabricMeasure(node, callback);
+        }
+      }
+    }, {
+      key: "measureInWindow",
+      value: function measureInWindow(callback) {
+        var node = (0, _$$_REQUIRE(_dependencyMap[7], "../../ReactNative/RendererProxy").getNodeFromInternalInstanceHandle)(this.__internalInstanceHandle);
+        if (node != null) {
+          fabricMeasureInWindow(node, callback);
+        }
+      }
+    }, {
+      key: "measureLayout",
+      value: function measureLayout(relativeToNativeNode, onSuccess, onFail) {
+        if (typeof relativeToNativeNode === 'number' || !(relativeToNativeNode instanceof ReactFabricHostComponent)) {
+          if (__DEV__) {
+            console.error('Warning: ref.measureLayout must be called with a ref to a native component.');
+          }
+          return;
+        }
+        var toStateNode = (0, _$$_REQUIRE(_dependencyMap[7], "../../ReactNative/RendererProxy").getNodeFromInternalInstanceHandle)(this.__internalInstanceHandle);
+        var fromStateNode = (0, _$$_REQUIRE(_dependencyMap[7], "../../ReactNative/RendererProxy").getNodeFromInternalInstanceHandle)(relativeToNativeNode.__internalInstanceHandle);
+        if (toStateNode != null && fromStateNode != null) {
+          fabricMeasureLayout(toStateNode, fromStateNode, onFail != null ? onFail : noop, onSuccess != null ? onSuccess : noop);
+        }
+      }
+    }, {
+      key: "unstable_getBoundingClientRect",
+      value: function unstable_getBoundingClientRect() {
+        var node = (0, _$$_REQUIRE(_dependencyMap[7], "../../ReactNative/RendererProxy").getNodeFromInternalInstanceHandle)(this.__internalInstanceHandle);
+        if (node != null) {
+          var rect = fabricGetBoundingClientRect(node, true);
+          if (rect) {
+            return new DOMRect(rect[0], rect[1], rect[2], rect[3]);
+          }
+        }
+        return new DOMRect(0, 0, 0, 0);
+      }
+    }, {
+      key: "setNativeProps",
+      value: function setNativeProps(nativeProps) {
+        if (__DEV__) {
+          (0, _warnForStyleProps.default)(nativeProps, this._viewConfig.validAttributes);
+        }
+        var updatePayload = (0, _$$_REQUIRE(_dependencyMap[8], "./ReactNativeAttributePayload").create)(nativeProps, this._viewConfig.validAttributes);
+        var node = (0, _$$_REQUIRE(_dependencyMap[7], "../../ReactNative/RendererProxy").getNodeFromInternalInstanceHandle)(this.__internalInstanceHandle);
+        if (node != null && updatePayload != null) {
+          _setNativeProps(node, updatePayload);
+        }
+      }
+    }]);
+  }();
+},331,[1,11,12,130,134,80,82,106,135],"../../node_modules/react-native/Libraries/ReactNative/ReactFabricPublicInstance/ReactFabricHostComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _DebuggingOverlayRegistry = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./DebuggingOverlayRegistry"));
+  var _react = _$$_REQUIRE(_dependencyMap[2], "react");
+  var useSubscribeToDebuggingOverlayRegistry = function useSubscribeToDebuggingOverlayRegistry(rootViewRef, debuggingOverlayRef) {
+    (0, _react.useEffect)(function () {
+      var subscriber = {
+        rootViewRef: rootViewRef,
+        debuggingOverlayRef: debuggingOverlayRef
+      };
+      _DebuggingOverlayRegistry.default.subscribe(subscriber);
+      return function () {
+        return _DebuggingOverlayRegistry.default.unsubscribe(subscriber);
+      };
+    }, [rootViewRef, debuggingOverlayRef]);
+  };
+  var _default = exports.default = useSubscribeToDebuggingOverlayRegistry;
+},332,[1,333,73],"../../node_modules/react-native/Libraries/Debugging/useSubscribeToDebuggingOverlayRegistry.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+  var _classPrivateFieldLooseBase2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classPrivateFieldLooseBase"));
+  var _classPrivateFieldLooseKey2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/classPrivateFieldLooseKey"));
+  var _processColor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../StyleSheet/processColor"));
+  var reactDevToolsHook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+  var _registry = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("registry");
+  var _reactDevToolsAgent = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("reactDevToolsAgent");
+  var _onReactDevToolsAgentAttached = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("onReactDevToolsAgentAttached");
+  var _getPublicInstanceFromInstance = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("getPublicInstanceFromInstance");
+  var _findLowestParentFromRegistryForInstance = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("findLowestParentFromRegistryForInstance");
+  var _findLowestParentFromRegistryForInstanceLegacy = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("findLowestParentFromRegistryForInstanceLegacy");
+  var _onDrawTraceUpdates = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("onDrawTraceUpdates");
+  var _drawTraceUpdatesModern = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("drawTraceUpdatesModern");
+  var _drawTraceUpdatesLegacy = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("drawTraceUpdatesLegacy");
+  var _onHighlightElements = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("onHighlightElements");
+  var _onHighlightElementsModern = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("onHighlightElementsModern");
+  var _onHighlightElementsLegacy = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("onHighlightElementsLegacy");
+  var _onClearElementsHighlights = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("onClearElementsHighlights");
+  var DebuggingOverlayRegistry = /*#__PURE__*/function () {
+    function DebuggingOverlayRegistry() {
+      var _this = this;
+      (0, _classCallCheck2.default)(this, DebuggingOverlayRegistry);
+      Object.defineProperty(this, _onHighlightElementsLegacy, {
+        value: _onHighlightElementsLegacy2
+      });
+      Object.defineProperty(this, _onHighlightElementsModern, {
+        value: _onHighlightElementsModern2
+      });
+      Object.defineProperty(this, _drawTraceUpdatesLegacy, {
+        value: _drawTraceUpdatesLegacy2
+      });
+      Object.defineProperty(this, _drawTraceUpdatesModern, {
+        value: _drawTraceUpdatesModern2
+      });
+      Object.defineProperty(this, _findLowestParentFromRegistryForInstanceLegacy, {
+        value: _findLowestParentFromRegistryForInstanceLegacy2
+      });
+      Object.defineProperty(this, _findLowestParentFromRegistryForInstance, {
+        value: _findLowestParentFromRegistryForInstance2
+      });
+      Object.defineProperty(this, _registry, {
+        writable: true,
+        value: new Set()
+      });
+      Object.defineProperty(this, _reactDevToolsAgent, {
+        writable: true,
+        value: null
+      });
+      Object.defineProperty(this, _onReactDevToolsAgentAttached, {
+        writable: true,
+        value: function value(agent) {
+          (0, _classPrivateFieldLooseBase2.default)(_this, _reactDevToolsAgent)[_reactDevToolsAgent] = agent;
+          agent.addListener('drawTraceUpdates', (0, _classPrivateFieldLooseBase2.default)(_this, _onDrawTraceUpdates)[_onDrawTraceUpdates]);
+          agent.addListener('showNativeHighlight', (0, _classPrivateFieldLooseBase2.default)(_this, _onHighlightElements)[_onHighlightElements]);
+          agent.addListener('hideNativeHighlight', (0, _classPrivateFieldLooseBase2.default)(_this, _onClearElementsHighlights)[_onClearElementsHighlights]);
+        }
+      });
+      Object.defineProperty(this, _getPublicInstanceFromInstance, {
+        writable: true,
+        value: function value(instanceHandle) {
+          var _instanceHandle$canon;
+          if (((_instanceHandle$canon = instanceHandle.canonical) == null ? void 0 : _instanceHandle$canon.publicInstance) != null) {
+            var _instanceHandle$canon2;
+            return (_instanceHandle$canon2 = instanceHandle.canonical) == null ? void 0 : _instanceHandle$canon2.publicInstance;
+          }
+          if (instanceHandle.canonical != null) {
+            return instanceHandle.canonical;
+          }
+          if (instanceHandle.measure != null) {
+            return instanceHandle;
+          }
+          return null;
+        }
+      });
+      Object.defineProperty(this, _onDrawTraceUpdates, {
+        writable: true,
+        value: function value(traceUpdates) {
+          var modernNodesUpdates = [];
+          var legacyNodesUpdates = [];
+          for (var _ref of traceUpdates) {
+            var node = _ref.node;
+            var color = _ref.color;
+            var publicInstance = (0, _classPrivateFieldLooseBase2.default)(_this, _getPublicInstanceFromInstance)[_getPublicInstanceFromInstance](node);
+            if (publicInstance == null) {
+              return;
+            }
+            var instanceReactTag = (0, _$$_REQUIRE(_dependencyMap[7], "../ReactNative/RendererProxy").findNodeHandle)(node);
+            if (instanceReactTag == null) {
+              return;
+            }
+            var ReactNativeElementClass = _$$_REQUIRE(_dependencyMap[8], "../../src/private/webapis/dom/nodes/ReactNativeElement").default;
+            if (publicInstance instanceof ReactNativeElementClass) {
+              modernNodesUpdates.push({
+                id: instanceReactTag,
+                instance: publicInstance,
+                color: color
+              });
+            } else {
+              legacyNodesUpdates.push({
+                id: instanceReactTag,
+                instance: publicInstance,
+                color: color
+              });
+            }
+          }
+          if (modernNodesUpdates.length > 0) {
+            (0, _classPrivateFieldLooseBase2.default)(_this, _drawTraceUpdatesModern)[_drawTraceUpdatesModern](modernNodesUpdates);
+          }
+          if (legacyNodesUpdates.length > 0) {
+            (0, _classPrivateFieldLooseBase2.default)(_this, _drawTraceUpdatesLegacy)[_drawTraceUpdatesLegacy](legacyNodesUpdates);
+          }
+        }
+      });
+      Object.defineProperty(this, _onHighlightElements, {
+        writable: true,
+        value: function value(nodes) {
+          for (var subscriber of (0, _classPrivateFieldLooseBase2.default)(_this, _registry)[_registry]) {
+            var _subscriber$debugging;
+            (_subscriber$debugging = subscriber.debuggingOverlayRef.current) == null || _subscriber$debugging.clearElementsHighlight();
+          }
+          var ReactNativeElementClass = _$$_REQUIRE(_dependencyMap[8], "../../src/private/webapis/dom/nodes/ReactNativeElement").default;
+          var reactNativeElements = [];
+          var legacyPublicInstances = [];
+          for (var node of nodes) {
+            var publicInstance = (0, _classPrivateFieldLooseBase2.default)(_this, _getPublicInstanceFromInstance)[_getPublicInstanceFromInstance](node);
+            if (publicInstance == null) {
+              continue;
+            }
+            if (publicInstance instanceof ReactNativeElementClass) {
+              reactNativeElements.push(publicInstance);
+            } else {
+              legacyPublicInstances.push(publicInstance);
+            }
+          }
+          if (reactNativeElements.length > 0) {
+            (0, _classPrivateFieldLooseBase2.default)(_this, _onHighlightElementsModern)[_onHighlightElementsModern](reactNativeElements);
+          }
+          if (legacyPublicInstances.length > 0) {
+            (0, _classPrivateFieldLooseBase2.default)(_this, _onHighlightElementsLegacy)[_onHighlightElementsLegacy](legacyPublicInstances);
+          }
+        }
+      });
+      Object.defineProperty(this, _onClearElementsHighlights, {
+        writable: true,
+        value: function value() {
+          for (var subscriber of (0, _classPrivateFieldLooseBase2.default)(_this, _registry)[_registry]) {
+            var _subscriber$debugging2;
+            (_subscriber$debugging2 = subscriber.debuggingOverlayRef.current) == null || _subscriber$debugging2.clearElementsHighlight();
+          }
+        }
+      });
+      if ((reactDevToolsHook == null ? void 0 : reactDevToolsHook.reactDevtoolsAgent) != null) {
+        (0, _classPrivateFieldLooseBase2.default)(this, _onReactDevToolsAgentAttached)[_onReactDevToolsAgentAttached](reactDevToolsHook.reactDevtoolsAgent);
+      }
+      reactDevToolsHook == null || reactDevToolsHook.on == null || reactDevToolsHook.on('react-devtools', (0, _classPrivateFieldLooseBase2.default)(this, _onReactDevToolsAgentAttached)[_onReactDevToolsAgentAttached]);
+    }
+    return (0, _createClass2.default)(DebuggingOverlayRegistry, [{
+      key: "subscribe",
+      value: function subscribe(subscriber) {
+        (0, _classPrivateFieldLooseBase2.default)(this, _registry)[_registry].add(subscriber);
+      }
+    }, {
+      key: "unsubscribe",
+      value: function unsubscribe(subscriber) {
+        var wasPresent = (0, _classPrivateFieldLooseBase2.default)(this, _registry)[_registry].delete(subscriber);
+        if (!wasPresent) {
+          console.error('[DebuggingOverlayRegistry] Unexpected argument for unsubscription, which was not previously subscribed:', subscriber);
+        }
+      }
+    }]);
+  }();
+  function _findLowestParentFromRegistryForInstance2(instance) {
+    var iterator = instance;
+    while (iterator != null) {
+      for (var subscriber of (0, _classPrivateFieldLooseBase2.default)(this, _registry)[_registry]) {
+        if (subscriber.rootViewRef.current === iterator) {
+          return subscriber;
+        }
+      }
+      iterator = iterator.parentElement;
+    }
+    return null;
+  }
+  function _findLowestParentFromRegistryForInstanceLegacy2(instance) {
+    var candidates = [];
+    for (var subscriber of (0, _classPrivateFieldLooseBase2.default)(this, _registry)[_registry]) {
+      if (subscriber.rootViewRef.current != null && (0, _$$_REQUIRE(_dependencyMap[7], "../ReactNative/RendererProxy").isChildPublicInstance)(subscriber.rootViewRef.current, instance)) {
+        candidates.push(subscriber);
+      }
+    }
+    if (candidates.length === 0) {
+      return null;
+    }
+    if (candidates.length === 1) {
+      return candidates[0];
+    }
+    var candidatesWithNoChildren = [];
+    for (var potentialParent of candidates) {
+      var shouldSkipThisParent = false;
+      if (potentialParent.rootViewRef.current == null) {
+        continue;
+      }
+      for (var potentialChild of candidates) {
+        if (potentialChild === potentialParent) {
+          continue;
+        }
+        if (potentialChild.rootViewRef.current == null) {
+          continue;
+        }
+        if ((0, _$$_REQUIRE(_dependencyMap[7], "../ReactNative/RendererProxy").isChildPublicInstance)(potentialParent.rootViewRef.current, potentialChild.rootViewRef.current)) {
+          shouldSkipThisParent = true;
+          break;
+        }
+      }
+      if (!shouldSkipThisParent) {
+        candidatesWithNoChildren.push(potentialParent);
+      }
+    }
+    if (candidatesWithNoChildren.length === 0) {
+      console.error('[DebuggingOverlayRegistry] Unexpected circular relationship between AppContainers');
+      return null;
+    } else if (candidatesWithNoChildren.length > 1) {
+      console.error('[DebuggingOverlayRegistry] Unexpected multiple options for lowest parent AppContainer');
+      return null;
+    }
+    return candidatesWithNoChildren[0];
+  }
+  function _drawTraceUpdatesModern2(updates) {
+    var parentToTraceUpdatesMap = new Map();
+    for (var _ref2 of updates) {
+      var id = _ref2.id;
+      var instance = _ref2.instance;
+      var color = _ref2.color;
+      var parent = (0, _classPrivateFieldLooseBase2.default)(this, _findLowestParentFromRegistryForInstance)[_findLowestParentFromRegistryForInstance](instance);
+      if (parent == null) {
+        continue;
+      }
+      var traceUpdatesForParent = parentToTraceUpdatesMap.get(parent);
+      if (traceUpdatesForParent == null) {
+        traceUpdatesForParent = [];
+        parentToTraceUpdatesMap.set(parent, traceUpdatesForParent);
+      }
+      var _instance$getBounding = instance.getBoundingClientRect(),
+        x = _instance$getBounding.x,
+        y = _instance$getBounding.y,
+        width = _instance$getBounding.width,
+        height = _instance$getBounding.height;
+      var rootViewInstance = parent.rootViewRef.current;
+      if (rootViewInstance == null) {
+        continue;
+      }
+      var _rootViewInstance$get = rootViewInstance.getBoundingClientRect(),
+        parentX = _rootViewInstance$get.x,
+        parentY = _rootViewInstance$get.y;
+      traceUpdatesForParent.push({
+        id: id,
+        rectangle: {
+          x: x - parentX,
+          y: y - parentY,
+          width: width,
+          height: height
+        },
+        color: (0, _processColor.default)(color)
+      });
+    }
+    for (var _ref3 of parentToTraceUpdatesMap.entries()) {
+      var _debuggingOverlayRef$;
+      var _ref4 = (0, _slicedToArray2.default)(_ref3, 2);
+      var _parent = _ref4[0];
+      var traceUpdates = _ref4[1];
+      var debuggingOverlayRef = _parent.debuggingOverlayRef;
+      (_debuggingOverlayRef$ = debuggingOverlayRef.current) == null || _debuggingOverlayRef$.highlightTraceUpdates(traceUpdates);
+    }
+  }
+  function _drawTraceUpdatesLegacy2(updates) {
+    var _this2 = this;
+    var parentToTraceUpdatesPromisesMap = new Map();
+    var _loop = function _loop(id, instance, color) {
+      var parent = (0, _classPrivateFieldLooseBase2.default)(_this2, _findLowestParentFromRegistryForInstanceLegacy)[_findLowestParentFromRegistryForInstanceLegacy](instance);
+      if (parent == null) {
+        return 1; // continue
+      }
+      var traceUpdatesPromisesForParent = parentToTraceUpdatesPromisesMap.get(parent);
+      if (traceUpdatesPromisesForParent == null) {
+        traceUpdatesPromisesForParent = [];
+        parentToTraceUpdatesPromisesMap.set(parent, traceUpdatesPromisesForParent);
+      }
+      var frameToDrawPromise = new Promise(function (resolve, reject) {
+        instance.measure(function (x, y, width, height, left, top) {
+          if (left == null || top == null || width == null || height == null) {
+            reject('Unexpectedly failed to call measure on an instance.');
+          }
+          resolve({
+            id: id,
+            rectangle: {
+              x: left,
+              y: top,
+              width: width,
+              height: height
+            },
+            color: (0, _processColor.default)(color)
+          });
+        });
+      });
+      traceUpdatesPromisesForParent.push(frameToDrawPromise);
+    };
+    for (var _ref5 of updates) {
+      var id = _ref5.id;
+      var instance = _ref5.instance;
+      var color = _ref5.color;
+      if (_loop(id, instance, color)) continue;
+    }
+    var _loop2 = function _loop2(parent) {
+      Promise.all(traceUpdatesPromises).then(function (resolvedTraceUpdates) {
+        var _parent$debuggingOver;
+        return (_parent$debuggingOver = parent.debuggingOverlayRef.current) == null ? void 0 : _parent$debuggingOver.highlightTraceUpdates(resolvedTraceUpdates);
+      }).catch(function () {});
+    };
+    for (var _ref6 of parentToTraceUpdatesPromisesMap.entries()) {
+      var _ref7 = (0, _slicedToArray2.default)(_ref6, 2);
+      var parent = _ref7[0];
+      var traceUpdatesPromises = _ref7[1];
+      _loop2(parent);
+    }
+  }
+  function _onHighlightElementsModern2(elements) {
+    var parentToElementsMap = new Map();
+    for (var element of elements) {
+      var parent = (0, _classPrivateFieldLooseBase2.default)(this, _findLowestParentFromRegistryForInstance)[_findLowestParentFromRegistryForInstance](element);
+      if (parent == null) {
+        continue;
+      }
+      var childElementOfAParent = parentToElementsMap.get(parent);
+      if (childElementOfAParent == null) {
+        childElementOfAParent = [];
+        parentToElementsMap.set(parent, childElementOfAParent);
+      }
+      childElementOfAParent.push(element);
+    }
+    var _loop3 = function _loop3() {
+        var _parent2$debuggingOve;
+        var rootViewInstance = _parent2.rootViewRef.current;
+        if (rootViewInstance == null) {
+          return {
+            v: void 0
+          };
+        }
+        var _rootViewInstance$get2 = rootViewInstance.getBoundingClientRect(),
+          parentX = _rootViewInstance$get2.x,
+          parentY = _rootViewInstance$get2.y;
+        var elementsRectangles = elementsToHighlight.map(function (element) {
+          var _element$getBoundingC = element.getBoundingClientRect(),
+            x = _element$getBoundingC.x,
+            y = _element$getBoundingC.y,
+            width = _element$getBoundingC.width,
+            height = _element$getBoundingC.height;
+          return {
+            x: x - parentX,
+            y: y - parentY,
+            width: width,
+            height: height
+          };
+        });
+        (_parent2$debuggingOve = _parent2.debuggingOverlayRef.current) == null || _parent2$debuggingOve.highlightElements(elementsRectangles);
+      },
+      _ret;
+    for (var _ref8 of parentToElementsMap.entries()) {
+      var _ref9 = (0, _slicedToArray2.default)(_ref8, 2);
+      var _parent2 = _ref9[0];
+      var elementsToHighlight = _ref9[1];
+      _ret = _loop3();
+      if (_ret) return _ret.v;
+    }
+  }
+  function _onHighlightElementsLegacy2(elements) {
+    var parentToElementsMap = new Map();
+    for (var element of elements) {
+      var parent = (0, _classPrivateFieldLooseBase2.default)(this, _findLowestParentFromRegistryForInstanceLegacy)[_findLowestParentFromRegistryForInstanceLegacy](element);
+      if (parent == null) {
+        continue;
+      }
+      var childElementOfAParent = parentToElementsMap.get(parent);
+      if (childElementOfAParent == null) {
+        childElementOfAParent = [];
+        parentToElementsMap.set(parent, childElementOfAParent);
+      }
+      childElementOfAParent.push(element);
+    }
+    var _loop4 = function _loop4(_parent3) {
+      var promises = elementsToHighlight.map(function (element) {
+        return new Promise(function (resolve, reject) {
+          element.measure(function (x, y, width, height, left, top) {
+            if (left == null || top == null || width == null || height == null) {
+              reject('Unexpectedly failed to call measure on an instance.');
+            }
+            resolve({
+              x: left,
+              y: top,
+              width: width,
+              height: height
+            });
+          });
+        });
+      });
+      Promise.all(promises).then(function (resolvedElementsRectangles) {
+        var _parent3$debuggingOve;
+        return (_parent3$debuggingOve = _parent3.debuggingOverlayRef.current) == null ? void 0 : _parent3$debuggingOve.highlightElements(resolvedElementsRectangles);
+      }).catch(function () {});
+    };
+    for (var _ref0 of parentToElementsMap.entries()) {
+      var _ref1 = (0, _slicedToArray2.default)(_ref0, 2);
+      var _parent3 = _ref1[0];
+      var elementsToHighlight = _ref1[1];
+      _loop4(_parent3);
+    }
+  }
+  var debuggingOverlayRegistryInstance = new DebuggingOverlayRegistry();
+  var _default = exports.default = debuggingOverlayRegistryInstance;
+},333,[1,34,11,12,26,27,57,106,129],"../../node_modules/react-native/Libraries/Debugging/DebuggingOverlayRegistry.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports._LogBoxNotificationContainer = _LogBoxNotificationContainer;
+  exports.default = void 0;
+  var _SafeAreaView_INTERNAL_DO_NOT_USE = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../src/private/components/safeareaview/SafeAreaView_INTERNAL_DO_NOT_USE"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../Components/View/View"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../StyleSheet/StyleSheet"));
+  var LogBoxData = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[4], "./Data/LogBoxData"));
+  var _LogBoxLog = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./Data/LogBoxLog"));
+  var _LogBoxNotification = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./UI/LogBoxNotification"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[8], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/LogBox/LogBoxNotificationContainer.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _LogBoxNotificationContainer(props) {
+    var logs = props.logs;
+    var onDismissWarns = function onDismissWarns() {
+      LogBoxData.clearWarnings();
+    };
+    var onDismissErrors = function onDismissErrors() {
+      LogBoxData.clearErrors();
+    };
+    var setSelectedLog = function setSelectedLog(index) {
+      LogBoxData.setSelectedLog(index);
+    };
+    function openLog(log) {
+      if (log.onNotificationPress) {
+        log.onNotificationPress();
+        return;
+      }
+      var index = logs.length - 1;
+      while (index > 0 && logs[index] !== log) {
+        index -= 1;
+      }
+      setSelectedLog(index);
+    }
+    if (logs.length === 0 || props.isDisabled === true) {
+      return null;
+    }
+    var warnings = logs.filter(function (log) {
+      return log.level === 'warn';
+    });
+    var errors = logs.filter(function (log) {
+      return log.level === 'error' || log.level === 'fatal';
+    });
+    return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_SafeAreaView_INTERNAL_DO_NOT_USE.default, {
+      style: styles.list,
+      children: [warnings.length > 0 && /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+        style: styles.toast,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxNotification.default, {
+          log: warnings[warnings.length - 1],
+          level: "warn",
+          totalLogCount: warnings.length,
+          onPressOpen: function onPressOpen() {
+            return openLog(warnings[warnings.length - 1]);
+          },
+          onPressDismiss: onDismissWarns
+        })
+      }), errors.length > 0 && /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+        style: styles.toast,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxNotification.default, {
+          log: errors[errors.length - 1],
+          level: "error",
+          totalLogCount: errors.length,
+          onPressOpen: function onPressOpen() {
+            return openLog(errors[errors.length - 1]);
+          },
+          onPressDismiss: onDismissErrors
+        })
+      })]
+    });
+  }
+  var styles = _StyleSheet.default.create({
+    list: {
+      bottom: 20,
+      left: 10,
+      right: 10,
+      position: 'absolute'
+    },
+    toast: {
+      borderRadius: 8,
+      marginBottom: 5,
+      overflow: 'hidden'
+    }
+  });
+  var _default = exports.default = LogBoxData.withSubscription(_LogBoxNotificationContainer);
+},334,[1,335,71,6,155,164,337,73,171],"../../node_modules/react-native/Libraries/LogBox/LogBoxNotificationContainer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../../../Libraries/Components/View/View"));
+  var _UIManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../../../Libraries/ReactNative/UIManager"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../../../Libraries/Utilities/Platform"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[4], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var exported = _Platform.default.select({
+    ios: _$$_REQUIRE(_dependencyMap[5], "../../../../src/private/specs_DEPRECATED/components/RCTSafeAreaViewNativeComponent").default,
+    android: _UIManager.default.hasViewManagerConfig('RCTSafeAreaView') ? _$$_REQUIRE(_dependencyMap[5], "../../../../src/private/specs_DEPRECATED/components/RCTSafeAreaViewNativeComponent").default : _View.default,
+    default: _View.default
+  });
+  var _default = exports.default = exported;
+},335,[1,71,79,68,73,336],"../../node_modules/react-native/src/private/components/safeareaview/SafeAreaView_INTERNAL_DO_NOT_USE.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = exports.__INTERNAL_VIEW_CONFIG = void 0;
+  var _codegenNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../../../Libraries/Utilities/codegenNativeComponent"));
+  var nativeComponentName = 'RCTSafeAreaView';
+  var __INTERNAL_VIEW_CONFIG = exports.__INTERNAL_VIEW_CONFIG = {
+    uiViewClassName: "RCTSafeAreaView",
+    validAttributes: {}
+  };
+  var _default = exports.default = _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/NativeComponent/NativeComponentRegistry").get(nativeComponentName, function () {
+    return __INTERNAL_VIEW_CONFIG;
+  });
+},336,[1,319,77],"../../node_modules/react-native/src/private/specs_DEPRECATED/components/RCTSafeAreaViewNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = LogBoxNotification;
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Components/View/View"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../StyleSheet/StyleSheet"));
+  var LogBoxData = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[3], "../Data/LogBoxData"));
+  var _LogBoxLog = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../Data/LogBoxLog"));
+  var _LogBoxButton = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./LogBoxButton"));
+  var _LogBoxNotificationCountBadge = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./LogBoxNotificationCountBadge"));
+  var _LogBoxNotificationDismissButton = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./LogBoxNotificationDismissButton"));
+  var _LogBoxNotificationMessage = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./LogBoxNotificationMessage"));
+  var LogBoxStyle = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[9], "./LogBoxStyle"));
+  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[10], "react"));
+  var React = _react;
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[11], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/LogBox/UI/LogBoxNotification.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function LogBoxNotification(props) {
+    var totalLogCount = props.totalLogCount,
+      level = props.level,
+      log = props.log;
+    (0, _react.useEffect)(function () {
+      LogBoxData.symbolicateLogLazy(log);
+    }, [log]);
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+      id: "logbox_notification",
+      style: styles.container,
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxButton.default, {
+        id: `logbox_open_button_${level}`,
+        onPress: props.onPressOpen,
+        style: styles.press,
+        backgroundColor: {
+          default: LogBoxStyle.getBackgroundColor(1),
+          pressed: LogBoxStyle.getBackgroundColor(0.9)
+        },
+        children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_View.default, {
+          style: styles.content,
+          children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxNotificationCountBadge.default, {
+            count: totalLogCount,
+            level: level
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxNotificationMessage.default, {
+            message: log.message
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxNotificationDismissButton.default, {
+            id: `logbox_dismiss_button_${level}`,
+            onPress: props.onPressDismiss
+          })]
+        })
+      })
+    });
+  }
+  var styles = _StyleSheet.default.create({
+    container: {
+      height: 48,
+      position: 'relative',
+      width: '100%',
+      justifyContent: 'center',
+      marginTop: 0.5,
+      backgroundColor: LogBoxStyle.getTextColor(1)
+    },
+    press: {
+      height: 48,
+      position: 'relative',
+      width: '100%',
+      justifyContent: 'center',
+      marginTop: 0.5,
+      paddingHorizontal: 12
+    },
+    content: {
+      alignItems: 'flex-start',
+      flexDirection: 'row',
+      borderRadius: 8,
+      flexGrow: 0,
+      flexShrink: 0,
+      flexBasis: 'auto'
+    }
+  });
+},337,[1,71,6,155,164,338,351,354,368,350,73,171],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxNotification.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _TouchableWithoutFeedback = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../Components/Touchable/TouchableWithoutFeedback"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../Components/View/View"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../../StyleSheet/StyleSheet"));
+  var LogBoxStyle = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[5], "./LogBoxStyle"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[6], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[7], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/LogBox/UI/LogBoxButton.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function LogBoxButton(props) {
+    var _React$useState = React.useState(false),
+      _React$useState2 = (0, _slicedToArray2.default)(_React$useState, 2),
+      pressed = _React$useState2[0],
+      setPressed = _React$useState2[1];
+    var backgroundColor = props.backgroundColor;
+    if (!backgroundColor) {
+      backgroundColor = {
+        default: LogBoxStyle.getBackgroundColor(0.95),
+        pressed: LogBoxStyle.getBackgroundColor(0.6)
+      };
+    }
+    var content = /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+      id: props.id,
+      style: _StyleSheet.default.compose({
+        backgroundColor: pressed ? backgroundColor.pressed : backgroundColor.default
+      }, props.style),
+      children: props.children
+    });
+    return props.onPress == null ? content : /*#__PURE__*/(0, _jsxRuntime.jsx)(_TouchableWithoutFeedback.default, {
+      hitSlop: props.hitSlop,
+      onPress: props.onPress,
+      onPressIn: function onPressIn() {
+        return setPressed(true);
+      },
+      onPressOut: function onPressOut() {
+        return setPressed(false);
+      },
+      children: content
+    });
+  }
+  var _default = exports.default = LogBoxButton;
+},338,[1,34,339,71,6,350,73,171],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxButton.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = TouchableWithoutFeedback;
+  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../Components/View/View"));
+  var _usePressability = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../Pressability/usePressability"));
+  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[4], "react"));
+  var React = _react;
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[5], "react/jsx-runtime");
+  var _excluded = ["onBlur", "onFocus"];
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Components/Touchable/TouchableWithoutFeedback.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var PASSTHROUGH_PROPS = ['accessibilityActions', 'accessibilityElementsHidden', 'accessibilityHint', 'accessibilityLanguage', 'accessibilityIgnoresInvertColors', 'accessibilityLabel', 'accessibilityLiveRegion', 'accessibilityRole', 'accessibilityValue', 'aria-valuemax', 'aria-valuemin', 'aria-valuenow', 'aria-valuetext', 'accessibilityViewIsModal', 'aria-modal', 'hitSlop', 'importantForAccessibility', 'nativeID', 'onAccessibilityAction', 'onBlur', 'onFocus', 'onLayout', 'testID'];
+  function TouchableWithoutFeedback(props) {
+    var _props$ariaBusy, _props$accessibilityS, _props$ariaChecked, _props$accessibilityS2, _props$ariaDisabled, _props$accessibilityS3, _props$ariaExpanded, _props$accessibilityS4, _props$ariaSelected, _props$accessibilityS5, _props$ariaHidden, _props$id;
+    var disabled = props.disabled,
+      rejectResponderTermination = props.rejectResponderTermination,
+      ariaDisabled = props['aria-disabled'],
+      accessibilityState = props.accessibilityState,
+      hitSlop = props.hitSlop,
+      delayLongPress = props.delayLongPress,
+      delayPressIn = props.delayPressIn,
+      delayPressOut = props.delayPressOut,
+      pressRetentionOffset = props.pressRetentionOffset,
+      touchSoundDisabled = props.touchSoundDisabled,
+      _onBlur = props.onBlur,
+      _onFocus = props.onFocus,
+      onLongPress = props.onLongPress,
+      onPress = props.onPress,
+      onPressIn = props.onPressIn,
+      onPressOut = props.onPressOut;
+    var pressabilityConfig = (0, _react.useMemo)(function () {
+      return {
+        cancelable: !rejectResponderTermination,
+        disabled: disabled !== null ? disabled : ariaDisabled != null ? ariaDisabled : accessibilityState == null ? void 0 : accessibilityState.disabled,
+        hitSlop: hitSlop,
+        delayLongPress: delayLongPress,
+        delayPressIn: delayPressIn,
+        delayPressOut: delayPressOut,
+        minPressDuration: 0,
+        pressRectOffset: pressRetentionOffset,
+        android_disableSound: touchSoundDisabled,
+        onBlur: _onBlur,
+        onFocus: _onFocus,
+        onLongPress: onLongPress,
+        onPress: onPress,
+        onPressIn: onPressIn,
+        onPressOut: onPressOut
+      };
+    }, [rejectResponderTermination, disabled, ariaDisabled, accessibilityState == null ? void 0 : accessibilityState.disabled, hitSlop, delayLongPress, delayPressIn, delayPressOut, pressRetentionOffset, touchSoundDisabled, _onBlur, _onFocus, onLongPress, onPress, onPressIn, onPressOut]);
+    var eventHandlers = (0, _usePressability.default)(pressabilityConfig);
+    var element = React.Children.only(props.children);
+    var children = [element.props.children];
+    var ariaLive = props['aria-live'];
+    if (__DEV__) {
+      if (element.type === _View.default) {
+        children.push(/*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[6], "../../Pressability/PressabilityDebug").PressabilityDebugView, {
+          color: "red",
+          hitSlop: props.hitSlop
+        }));
+      }
+    }
+    var _accessibilityState = {
+      busy: (_props$ariaBusy = props['aria-busy']) != null ? _props$ariaBusy : (_props$accessibilityS = props.accessibilityState) == null ? void 0 : _props$accessibilityS.busy,
+      checked: (_props$ariaChecked = props['aria-checked']) != null ? _props$ariaChecked : (_props$accessibilityS2 = props.accessibilityState) == null ? void 0 : _props$accessibilityS2.checked,
+      disabled: (_props$ariaDisabled = props['aria-disabled']) != null ? _props$ariaDisabled : (_props$accessibilityS3 = props.accessibilityState) == null ? void 0 : _props$accessibilityS3.disabled,
+      expanded: (_props$ariaExpanded = props['aria-expanded']) != null ? _props$ariaExpanded : (_props$accessibilityS4 = props.accessibilityState) == null ? void 0 : _props$accessibilityS4.expanded,
+      selected: (_props$ariaSelected = props['aria-selected']) != null ? _props$ariaSelected : (_props$accessibilityS5 = props.accessibilityState) == null ? void 0 : _props$accessibilityS5.selected
+    };
+    var onBlur = eventHandlers.onBlur,
+      onFocus = eventHandlers.onFocus,
+      eventHandlersWithoutBlurAndFocus = (0, _objectWithoutProperties2.default)(eventHandlers, _excluded);
+    var elementProps = Object.assign({}, eventHandlersWithoutBlurAndFocus, {
+      accessible: props.accessible !== false,
+      accessibilityState: props.disabled != null ? Object.assign({}, _accessibilityState, {
+        disabled: props.disabled
+      }) : _accessibilityState,
+      focusable: props.focusable !== false && props.onPress !== undefined && !props.disabled,
+      accessibilityElementsHidden: (_props$ariaHidden = props['aria-hidden']) != null ? _props$ariaHidden : props.accessibilityElementsHidden,
+      importantForAccessibility: props['aria-hidden'] === true ? 'no-hide-descendants' : props.importantForAccessibility,
+      accessibilityLiveRegion: ariaLive === 'off' ? 'none' : ariaLive != null ? ariaLive : props.accessibilityLiveRegion,
+      nativeID: (_props$id = props.id) != null ? _props$id : props.nativeID
+    });
+    for (var prop of PASSTHROUGH_PROPS) {
+      if (props[prop] !== undefined) {
+        elementProps[prop] = props[prop];
+      }
+    }
+    return React.cloneElement.apply(React, [element, elementProps].concat(children));
+  }
+},339,[1,4,71,340,73,171,349],"../../node_modules/react-native/Libraries/Components/Touchable/TouchableWithoutFeedback.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = usePressability;
+  var _Pressability = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./Pressability"));
+  var _react = _$$_REQUIRE(_dependencyMap[2], "react");
+  function usePressability(config) {
+    var pressabilityRef = (0, _react.useRef)(null);
+    if (config != null && pressabilityRef.current == null) {
+      pressabilityRef.current = new _Pressability.default(config);
+    }
+    var pressability = pressabilityRef.current;
+    (0, _react.useEffect)(function () {
+      if (config != null && pressability != null) {
+        pressability.configure(config);
+      }
+    }, [config, pressability]);
+    (0, _react.useEffect)(function () {
+      if (pressability != null) {
+        return function () {
+          pressability.reset();
+        };
+      }
+    }, [pressability]);
+    return pressability == null ? null : pressability.getEventHandlers();
+  }
+},340,[1,341,73],"../../node_modules/react-native/Libraries/Pressability/usePressability.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _SoundManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../Components/Sound/SoundManager"));
+  var _ReactNativeFeatureFlags = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../ReactNative/ReactNativeFeatureFlags"));
+  var _UIManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../ReactNative/UIManager"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../Utilities/Platform"));
+  var _PressabilityPerformanceEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./PressabilityPerformanceEventEmitter.js"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "invariant"));
+  var Transitions = Object.freeze({
+    NOT_RESPONDER: {
+      DELAY: 'ERROR',
+      RESPONDER_GRANT: 'RESPONDER_INACTIVE_PRESS_IN',
+      RESPONDER_RELEASE: 'ERROR',
+      RESPONDER_TERMINATED: 'ERROR',
+      ENTER_PRESS_RECT: 'ERROR',
+      LEAVE_PRESS_RECT: 'ERROR',
+      LONG_PRESS_DETECTED: 'ERROR'
+    },
+    RESPONDER_INACTIVE_PRESS_IN: {
+      DELAY: 'RESPONDER_ACTIVE_PRESS_IN',
+      RESPONDER_GRANT: 'ERROR',
+      RESPONDER_RELEASE: 'NOT_RESPONDER',
+      RESPONDER_TERMINATED: 'NOT_RESPONDER',
+      ENTER_PRESS_RECT: 'RESPONDER_INACTIVE_PRESS_IN',
+      LEAVE_PRESS_RECT: 'RESPONDER_INACTIVE_PRESS_OUT',
+      LONG_PRESS_DETECTED: 'ERROR'
+    },
+    RESPONDER_INACTIVE_PRESS_OUT: {
+      DELAY: 'RESPONDER_ACTIVE_PRESS_OUT',
+      RESPONDER_GRANT: 'ERROR',
+      RESPONDER_RELEASE: 'NOT_RESPONDER',
+      RESPONDER_TERMINATED: 'NOT_RESPONDER',
+      ENTER_PRESS_RECT: 'RESPONDER_INACTIVE_PRESS_IN',
+      LEAVE_PRESS_RECT: 'RESPONDER_INACTIVE_PRESS_OUT',
+      LONG_PRESS_DETECTED: 'ERROR'
+    },
+    RESPONDER_ACTIVE_PRESS_IN: {
+      DELAY: 'ERROR',
+      RESPONDER_GRANT: 'ERROR',
+      RESPONDER_RELEASE: 'NOT_RESPONDER',
+      RESPONDER_TERMINATED: 'NOT_RESPONDER',
+      ENTER_PRESS_RECT: 'RESPONDER_ACTIVE_PRESS_IN',
+      LEAVE_PRESS_RECT: 'RESPONDER_ACTIVE_PRESS_OUT',
+      LONG_PRESS_DETECTED: 'RESPONDER_ACTIVE_LONG_PRESS_IN'
+    },
+    RESPONDER_ACTIVE_PRESS_OUT: {
+      DELAY: 'ERROR',
+      RESPONDER_GRANT: 'ERROR',
+      RESPONDER_RELEASE: 'NOT_RESPONDER',
+      RESPONDER_TERMINATED: 'NOT_RESPONDER',
+      ENTER_PRESS_RECT: 'RESPONDER_ACTIVE_PRESS_IN',
+      LEAVE_PRESS_RECT: 'RESPONDER_ACTIVE_PRESS_OUT',
+      LONG_PRESS_DETECTED: 'ERROR'
+    },
+    RESPONDER_ACTIVE_LONG_PRESS_IN: {
+      DELAY: 'ERROR',
+      RESPONDER_GRANT: 'ERROR',
+      RESPONDER_RELEASE: 'NOT_RESPONDER',
+      RESPONDER_TERMINATED: 'NOT_RESPONDER',
+      ENTER_PRESS_RECT: 'RESPONDER_ACTIVE_LONG_PRESS_IN',
+      LEAVE_PRESS_RECT: 'RESPONDER_ACTIVE_LONG_PRESS_OUT',
+      LONG_PRESS_DETECTED: 'RESPONDER_ACTIVE_LONG_PRESS_IN'
+    },
+    RESPONDER_ACTIVE_LONG_PRESS_OUT: {
+      DELAY: 'ERROR',
+      RESPONDER_GRANT: 'ERROR',
+      RESPONDER_RELEASE: 'NOT_RESPONDER',
+      RESPONDER_TERMINATED: 'NOT_RESPONDER',
+      ENTER_PRESS_RECT: 'RESPONDER_ACTIVE_LONG_PRESS_IN',
+      LEAVE_PRESS_RECT: 'RESPONDER_ACTIVE_LONG_PRESS_OUT',
+      LONG_PRESS_DETECTED: 'ERROR'
+    },
+    ERROR: {
+      DELAY: 'NOT_RESPONDER',
+      RESPONDER_GRANT: 'RESPONDER_INACTIVE_PRESS_IN',
+      RESPONDER_RELEASE: 'NOT_RESPONDER',
+      RESPONDER_TERMINATED: 'NOT_RESPONDER',
+      ENTER_PRESS_RECT: 'NOT_RESPONDER',
+      LEAVE_PRESS_RECT: 'NOT_RESPONDER',
+      LONG_PRESS_DETECTED: 'NOT_RESPONDER'
+    }
+  });
+  var isActiveSignal = function isActiveSignal(signal) {
+    return signal === 'RESPONDER_ACTIVE_PRESS_IN' || signal === 'RESPONDER_ACTIVE_LONG_PRESS_IN';
+  };
+  var isActivationSignal = function isActivationSignal(signal) {
+    return signal === 'RESPONDER_ACTIVE_PRESS_OUT' || signal === 'RESPONDER_ACTIVE_PRESS_IN';
+  };
+  var isPressInSignal = function isPressInSignal(signal) {
+    return signal === 'RESPONDER_INACTIVE_PRESS_IN' || signal === 'RESPONDER_ACTIVE_PRESS_IN' || signal === 'RESPONDER_ACTIVE_LONG_PRESS_IN';
+  };
+  var isTerminalSignal = function isTerminalSignal(signal) {
+    return signal === 'RESPONDER_TERMINATED' || signal === 'RESPONDER_RELEASE';
+  };
+  var DEFAULT_LONG_PRESS_DELAY_MS = 500;
+  var DEFAULT_PRESS_RECT_OFFSETS = {
+    bottom: 30,
+    left: 20,
+    right: 20,
+    top: 20
+  };
+  var DEFAULT_MIN_PRESS_DURATION = 130;
+  var DEFAULT_LONG_PRESS_DEACTIVATION_DISTANCE = 10;
+  var longPressDeactivationDistance = DEFAULT_LONG_PRESS_DEACTIVATION_DISTANCE;
+  var Pressability = exports.default = /*#__PURE__*/function () {
+    function Pressability(config) {
+      var _this = this;
+      (0, _classCallCheck2.default)(this, Pressability);
+      this._eventHandlers = null;
+      this._hoverInDelayTimeout = null;
+      this._hoverOutDelayTimeout = null;
+      this._isHovered = false;
+      this._longPressDelayTimeout = null;
+      this._pressDelayTimeout = null;
+      this._pressOutDelayTimeout = null;
+      this._responderID = null;
+      this._responderRegion = null;
+      this._touchState = 'NOT_RESPONDER';
+      this._measureCallback = function (left, top, width, height, pageX, pageY) {
+        if (!left && !top && !width && !height && !pageX && !pageY) {
+          return;
+        }
+        _this._responderRegion = {
+          bottom: pageY + height,
+          left: pageX,
+          right: pageX + width,
+          top: pageY
+        };
+      };
+      this.configure(config);
+    }
+    return (0, _createClass2.default)(Pressability, [{
+      key: "configure",
+      value: function configure(config) {
+        this._config = config;
+      }
+    }, {
+      key: "reset",
+      value: function reset() {
+        this._cancelHoverInDelayTimeout();
+        this._cancelHoverOutDelayTimeout();
+        this._cancelLongPressDelayTimeout();
+        this._cancelPressDelayTimeout();
+        this._cancelPressOutDelayTimeout();
+        this._config = Object.freeze({});
+      }
+    }, {
+      key: "getEventHandlers",
+      value: function getEventHandlers() {
+        if (this._eventHandlers == null) {
+          this._eventHandlers = this._createEventHandlers();
+        }
+        return this._eventHandlers;
+      }
+    }, {
+      key: "_createEventHandlers",
+      value: function _createEventHandlers() {
+        var _this2 = this;
+        var focusEventHandlers = {
+          onBlur: function onBlur(event) {
+            var onBlur = _this2._config.onBlur;
+            if (onBlur != null) {
+              onBlur(event);
+            }
+          },
+          onFocus: function onFocus(event) {
+            var onFocus = _this2._config.onFocus;
+            if (onFocus != null) {
+              onFocus(event);
+            }
+          }
+        };
+        var responderEventHandlers = {
+          onStartShouldSetResponder: function onStartShouldSetResponder() {
+            var _disabled;
+            var disabled = _this2._config.disabled;
+            return (_disabled = !disabled) != null ? _disabled : true;
+          },
+          onResponderGrant: function onResponderGrant(event) {
+            event.persist();
+            _this2._cancelPressOutDelayTimeout();
+            _this2._responderID = event.currentTarget;
+            _this2._touchState = 'NOT_RESPONDER';
+            _this2._receiveSignal('RESPONDER_GRANT', event);
+            var delayPressIn = normalizeDelay(_this2._config.delayPressIn);
+            if (delayPressIn > 0) {
+              _this2._pressDelayTimeout = setTimeout(function () {
+                _this2._receiveSignal('DELAY', event);
+              }, delayPressIn);
+            } else {
+              _this2._receiveSignal('DELAY', event);
+            }
+            var delayLongPress = normalizeDelay(_this2._config.delayLongPress, 10, DEFAULT_LONG_PRESS_DELAY_MS - delayPressIn);
+            _this2._longPressDelayTimeout = setTimeout(function () {
+              _this2._handleLongPress(event);
+            }, delayLongPress + delayPressIn);
+            return _this2._config.blockNativeResponder === true;
+          },
+          onResponderMove: function onResponderMove(event) {
+            var onPressMove = _this2._config.onPressMove;
+            if (onPressMove != null) {
+              onPressMove(event);
+            }
+            var responderRegion = _this2._responderRegion;
+            if (responderRegion == null) {
+              return;
+            }
+            var touch = getTouchFromPressEvent(event);
+            if (touch == null) {
+              _this2._cancelLongPressDelayTimeout();
+              _this2._receiveSignal('LEAVE_PRESS_RECT', event);
+              return;
+            }
+            if (_this2._touchActivatePosition != null) {
+              var deltaX = _this2._touchActivatePosition.pageX - touch.pageX;
+              var deltaY = _this2._touchActivatePosition.pageY - touch.pageY;
+              if (Math.hypot(deltaX, deltaY) > longPressDeactivationDistance) {
+                _this2._cancelLongPressDelayTimeout();
+              }
+            }
+            if (_this2._isTouchWithinResponderRegion(touch, responderRegion)) {
+              _this2._receiveSignal('ENTER_PRESS_RECT', event);
+            } else {
+              _this2._cancelLongPressDelayTimeout();
+              _this2._receiveSignal('LEAVE_PRESS_RECT', event);
+            }
+          },
+          onResponderRelease: function onResponderRelease(event) {
+            _this2._receiveSignal('RESPONDER_RELEASE', event);
+          },
+          onResponderTerminate: function onResponderTerminate(event) {
+            _this2._receiveSignal('RESPONDER_TERMINATED', event);
+          },
+          onResponderTerminationRequest: function onResponderTerminationRequest() {
+            var cancelable = _this2._config.cancelable;
+            return cancelable != null ? cancelable : true;
+          },
+          onClick: function onClick(event) {
+            var _event$nativeEvent;
+            if (event != null && (_event$nativeEvent = event.nativeEvent) != null && _event$nativeEvent.hasOwnProperty != null && _event$nativeEvent.hasOwnProperty('pointerType')) {
+              return;
+            }
+            if ((event == null ? void 0 : event.currentTarget) !== (event == null ? void 0 : event.target)) {
+              event == null || event.stopPropagation();
+              return;
+            }
+            var _this2$_config = _this2._config,
+              onPress = _this2$_config.onPress,
+              disabled = _this2$_config.disabled;
+            if (onPress != null && disabled !== true) {
+              onPress(event);
+            }
+          }
+        };
+        if (process.env.NODE_ENV === 'test') {
+          responderEventHandlers.onStartShouldSetResponder.testOnly_pressabilityConfig = function () {
+            return _this2._config;
+          };
+        }
+        if (_ReactNativeFeatureFlags.default.shouldPressibilityUseW3CPointerEventsForHover()) {
+          var hoverPointerEvents = {
+            onPointerEnter: undefined,
+            onPointerLeave: undefined
+          };
+          var _this$_config = this._config,
+            onHoverIn = _this$_config.onHoverIn,
+            onHoverOut = _this$_config.onHoverOut;
+          if (onHoverIn != null) {
+            hoverPointerEvents.onPointerEnter = function (event) {
+              _this2._isHovered = true;
+              _this2._cancelHoverOutDelayTimeout();
+              if (onHoverIn != null) {
+                var delayHoverIn = normalizeDelay(_this2._config.delayHoverIn);
+                if (delayHoverIn > 0) {
+                  event.persist();
+                  _this2._hoverInDelayTimeout = setTimeout(function () {
+                    onHoverIn(convertPointerEventToMouseEvent(event));
+                  }, delayHoverIn);
+                } else {
+                  onHoverIn(convertPointerEventToMouseEvent(event));
+                }
+              }
+            };
+          }
+          if (onHoverOut != null) {
+            hoverPointerEvents.onPointerLeave = function (event) {
+              if (_this2._isHovered) {
+                _this2._isHovered = false;
+                _this2._cancelHoverInDelayTimeout();
+                if (onHoverOut != null) {
+                  var delayHoverOut = normalizeDelay(_this2._config.delayHoverOut);
+                  if (delayHoverOut > 0) {
+                    event.persist();
+                    _this2._hoverOutDelayTimeout = setTimeout(function () {
+                      onHoverOut(convertPointerEventToMouseEvent(event));
+                    }, delayHoverOut);
+                  } else {
+                    onHoverOut(convertPointerEventToMouseEvent(event));
+                  }
+                }
+              }
+            };
+          }
+          return Object.assign({}, focusEventHandlers, responderEventHandlers, hoverPointerEvents);
+        } else {
+          var mouseEventHandlers = _Platform.default.OS === 'ios' || _Platform.default.OS === 'android' ? null : {
+            onMouseEnter: function onMouseEnter(event) {
+              if ((0, _$$_REQUIRE(_dependencyMap[9], "./HoverState").isHoverEnabled)()) {
+                _this2._isHovered = true;
+                _this2._cancelHoverOutDelayTimeout();
+                var _onHoverIn = _this2._config.onHoverIn;
+                if (_onHoverIn != null) {
+                  var delayHoverIn = normalizeDelay(_this2._config.delayHoverIn);
+                  if (delayHoverIn > 0) {
+                    event.persist();
+                    _this2._hoverInDelayTimeout = setTimeout(function () {
+                      _onHoverIn(event);
+                    }, delayHoverIn);
+                  } else {
+                    _onHoverIn(event);
+                  }
+                }
+              }
+            },
+            onMouseLeave: function onMouseLeave(event) {
+              if (_this2._isHovered) {
+                _this2._isHovered = false;
+                _this2._cancelHoverInDelayTimeout();
+                var _onHoverOut = _this2._config.onHoverOut;
+                if (_onHoverOut != null) {
+                  var delayHoverOut = normalizeDelay(_this2._config.delayHoverOut);
+                  if (delayHoverOut > 0) {
+                    event.persist();
+                    _this2._hoverInDelayTimeout = setTimeout(function () {
+                      _onHoverOut(event);
+                    }, delayHoverOut);
+                  } else {
+                    _onHoverOut(event);
+                  }
+                }
+              }
+            }
+          };
+          return Object.assign({}, focusEventHandlers, responderEventHandlers, mouseEventHandlers);
+        }
+      }
+    }, {
+      key: "_receiveSignal",
+      value: function _receiveSignal(signal, event) {
+        var _Transitions$prevStat;
+        if (event.nativeEvent.timestamp != null) {
+          _PressabilityPerformanceEventEmitter.default.emitEvent(function () {
+            return {
+              signal: signal,
+              nativeTimestamp: event.nativeEvent.timestamp
+            };
+          });
+        }
+        var prevState = this._touchState;
+        var nextState = (_Transitions$prevStat = Transitions[prevState]) == null ? void 0 : _Transitions$prevStat[signal];
+        if (this._responderID == null && signal === 'RESPONDER_RELEASE') {
+          return;
+        }
+        (0, _invariant.default)(nextState != null && nextState !== 'ERROR', 'Pressability: Invalid signal `%s` for state `%s` on responder: %s', signal, prevState, typeof this._responderID === 'number' ? this._responderID : '<<host component>>');
+        if (prevState !== nextState) {
+          this._performTransitionSideEffects(prevState, nextState, signal, event);
+          this._touchState = nextState;
+        }
+      }
+    }, {
+      key: "_performTransitionSideEffects",
+      value: function _performTransitionSideEffects(prevState, nextState, signal, event) {
+        if (isTerminalSignal(signal)) {
+          this._touchActivatePosition = null;
+          this._cancelLongPressDelayTimeout();
+        }
+        var isInitialTransition = prevState === 'NOT_RESPONDER' && nextState === 'RESPONDER_INACTIVE_PRESS_IN';
+        var isActivationTransition = !isActivationSignal(prevState) && isActivationSignal(nextState);
+        if (isInitialTransition || isActivationTransition) {
+          this._measureResponderRegion();
+        }
+        if (isPressInSignal(prevState) && signal === 'LONG_PRESS_DETECTED') {
+          var onLongPress = this._config.onLongPress;
+          if (onLongPress != null) {
+            onLongPress(event);
+          }
+        }
+        var isPrevActive = isActiveSignal(prevState);
+        var isNextActive = isActiveSignal(nextState);
+        if (!isPrevActive && isNextActive) {
+          this._activate(event);
+        } else if (isPrevActive && !isNextActive) {
+          this._deactivate(event);
+        }
+        if (isPressInSignal(prevState) && signal === 'RESPONDER_RELEASE') {
+          if (!isNextActive && !isPrevActive) {
+            this._activate(event);
+            this._deactivate(event);
+          }
+          var _this$_config2 = this._config,
+            _onLongPress = _this$_config2.onLongPress,
+            onPress = _this$_config2.onPress,
+            android_disableSound = _this$_config2.android_disableSound;
+          if (onPress != null) {
+            var isPressCanceledByLongPress = _onLongPress != null && prevState === 'RESPONDER_ACTIVE_LONG_PRESS_IN';
+            if (!isPressCanceledByLongPress) {
+              if (_Platform.default.OS === 'android' && android_disableSound !== true) {
+                _SoundManager.default.playTouchSound();
+              }
+              onPress(event);
+            }
+          }
+        }
+        this._cancelPressDelayTimeout();
+      }
+    }, {
+      key: "_activate",
+      value: function _activate(event) {
+        var onPressIn = this._config.onPressIn;
+        var _getTouchFromPressEve = getTouchFromPressEvent(event),
+          pageX = _getTouchFromPressEve.pageX,
+          pageY = _getTouchFromPressEve.pageY;
+        this._touchActivatePosition = {
+          pageX: pageX,
+          pageY: pageY
+        };
+        this._touchActivateTime = Date.now();
+        if (onPressIn != null) {
+          onPressIn(event);
+        }
+      }
+    }, {
+      key: "_deactivate",
+      value: function _deactivate(event) {
+        var onPressOut = this._config.onPressOut;
+        if (onPressOut != null) {
+          var _this$_touchActivateT;
+          var minPressDuration = normalizeDelay(this._config.minPressDuration, 0, DEFAULT_MIN_PRESS_DURATION);
+          var pressDuration = Date.now() - ((_this$_touchActivateT = this._touchActivateTime) != null ? _this$_touchActivateT : 0);
+          var delayPressOut = Math.max(minPressDuration - pressDuration, normalizeDelay(this._config.delayPressOut));
+          if (delayPressOut > 0) {
+            event.persist();
+            this._pressOutDelayTimeout = setTimeout(function () {
+              onPressOut(event);
+            }, delayPressOut);
+          } else {
+            onPressOut(event);
+          }
+        }
+        this._touchActivateTime = null;
+      }
+    }, {
+      key: "_measureResponderRegion",
+      value: function _measureResponderRegion() {
+        if (this._responderID == null) {
+          return;
+        }
+        if (typeof this._responderID === 'number') {
+          _UIManager.default.measure(this._responderID, this._measureCallback);
+        } else {
+          this._responderID.measure(this._measureCallback);
+        }
+      }
+    }, {
+      key: "_isTouchWithinResponderRegion",
+      value: function _isTouchWithinResponderRegion(touch, responderRegion) {
+        var _pressRectOffset$bott, _pressRectOffset$left, _pressRectOffset$righ, _pressRectOffset$top;
+        var hitSlop = (0, _$$_REQUIRE(_dependencyMap[10], "../StyleSheet/Rect").normalizeRect)(this._config.hitSlop);
+        var pressRectOffset = (0, _$$_REQUIRE(_dependencyMap[10], "../StyleSheet/Rect").normalizeRect)(this._config.pressRectOffset);
+        var regionBottom = responderRegion.bottom;
+        var regionLeft = responderRegion.left;
+        var regionRight = responderRegion.right;
+        var regionTop = responderRegion.top;
+        if (hitSlop != null) {
+          if (hitSlop.bottom != null) {
+            regionBottom += hitSlop.bottom;
+          }
+          if (hitSlop.left != null) {
+            regionLeft -= hitSlop.left;
+          }
+          if (hitSlop.right != null) {
+            regionRight += hitSlop.right;
+          }
+          if (hitSlop.top != null) {
+            regionTop -= hitSlop.top;
+          }
+        }
+        regionBottom += (_pressRectOffset$bott = pressRectOffset == null ? void 0 : pressRectOffset.bottom) != null ? _pressRectOffset$bott : DEFAULT_PRESS_RECT_OFFSETS.bottom;
+        regionLeft -= (_pressRectOffset$left = pressRectOffset == null ? void 0 : pressRectOffset.left) != null ? _pressRectOffset$left : DEFAULT_PRESS_RECT_OFFSETS.left;
+        regionRight += (_pressRectOffset$righ = pressRectOffset == null ? void 0 : pressRectOffset.right) != null ? _pressRectOffset$righ : DEFAULT_PRESS_RECT_OFFSETS.right;
+        regionTop -= (_pressRectOffset$top = pressRectOffset == null ? void 0 : pressRectOffset.top) != null ? _pressRectOffset$top : DEFAULT_PRESS_RECT_OFFSETS.top;
+        return touch.pageX > regionLeft && touch.pageX < regionRight && touch.pageY > regionTop && touch.pageY < regionBottom;
+      }
+    }, {
+      key: "_handleLongPress",
+      value: function _handleLongPress(event) {
+        if (this._touchState === 'RESPONDER_ACTIVE_PRESS_IN' || this._touchState === 'RESPONDER_ACTIVE_LONG_PRESS_IN') {
+          this._receiveSignal('LONG_PRESS_DETECTED', event);
+        }
+      }
+    }, {
+      key: "_cancelHoverInDelayTimeout",
+      value: function _cancelHoverInDelayTimeout() {
+        if (this._hoverInDelayTimeout != null) {
+          clearTimeout(this._hoverInDelayTimeout);
+          this._hoverInDelayTimeout = null;
+        }
+      }
+    }, {
+      key: "_cancelHoverOutDelayTimeout",
+      value: function _cancelHoverOutDelayTimeout() {
+        if (this._hoverOutDelayTimeout != null) {
+          clearTimeout(this._hoverOutDelayTimeout);
+          this._hoverOutDelayTimeout = null;
+        }
+      }
+    }, {
+      key: "_cancelLongPressDelayTimeout",
+      value: function _cancelLongPressDelayTimeout() {
+        if (this._longPressDelayTimeout != null) {
+          clearTimeout(this._longPressDelayTimeout);
+          this._longPressDelayTimeout = null;
+        }
+      }
+    }, {
+      key: "_cancelPressDelayTimeout",
+      value: function _cancelPressDelayTimeout() {
+        if (this._pressDelayTimeout != null) {
+          clearTimeout(this._pressDelayTimeout);
+          this._pressDelayTimeout = null;
+        }
+      }
+    }, {
+      key: "_cancelPressOutDelayTimeout",
+      value: function _cancelPressOutDelayTimeout() {
+        if (this._pressOutDelayTimeout != null) {
+          clearTimeout(this._pressOutDelayTimeout);
+          this._pressOutDelayTimeout = null;
+        }
+      }
+    }], [{
+      key: "setLongPressDeactivationDistance",
+      value: function setLongPressDeactivationDistance(distance) {
+        longPressDeactivationDistance = distance;
+      }
+    }]);
+  }();
+  function normalizeDelay(delay) {
+    var min = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    var fallback = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    return Math.max(min, delay != null ? delay : fallback);
+  }
+  var getTouchFromPressEvent = function getTouchFromPressEvent(event) {
+    var _event$nativeEvent2 = event.nativeEvent,
+      changedTouches = _event$nativeEvent2.changedTouches,
+      touches = _event$nativeEvent2.touches;
+    if (touches != null && touches.length > 0) {
+      return touches[0];
+    }
+    if (changedTouches != null && changedTouches.length > 0) {
+      return changedTouches[0];
+    }
+    return event.nativeEvent;
+  };
+  function convertPointerEventToMouseEvent(input) {
+    var _input$nativeEvent = input.nativeEvent,
+      clientX = _input$nativeEvent.clientX,
+      clientY = _input$nativeEvent.clientY;
+    return Object.assign({}, input, {
+      nativeEvent: {
+        clientX: clientX,
+        clientY: clientY,
+        pageX: clientX,
+        pageY: clientY,
+        timestamp: input.timeStamp
+      }
+    });
+  }
+},341,[1,11,12,342,345,79,68,346,32,347,348],"../../node_modules/react-native/Libraries/Pressability/Pressability.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _NativeSoundManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativeSoundManager"));
+  var SoundManager = {
+    playTouchSound: function playTouchSound() {
+      if (_NativeSoundManager.default) {
+        _NativeSoundManager.default.playTouchSound();
+      }
+    }
+  };
+  var _default = exports.default = SoundManager;
+},342,[1,343],"../../node_modules/react-native/Libraries/Components/Sound/SoundManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeSoundManager = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../src/private/specs_DEPRECATED/modules/NativeSoundManager"));
+  Object.keys(_NativeSoundManager).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeSoundManager[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeSoundManager[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeSoundManager.default;
+},343,[344],"../../node_modules/react-native/Libraries/Components/Sound/NativeSoundManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.get('SoundManager');
+},344,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeSoundManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var ReactNativeFeatureFlags = {
+    shouldEmitW3CPointerEvents: function shouldEmitW3CPointerEvents() {
+      return false;
+    },
+    shouldPressibilityUseW3CPointerEventsForHover: function shouldPressibilityUseW3CPointerEventsForHover() {
+      return false;
+    }
+  };
+  var _default = exports.default = ReactNativeFeatureFlags;
+},345,[],"../../node_modules/react-native/Libraries/ReactNative/ReactNativeFeatureFlags.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var PressabilityPerformanceEventEmitter = /*#__PURE__*/function () {
+    function PressabilityPerformanceEventEmitter() {
+      (0, _classCallCheck2.default)(this, PressabilityPerformanceEventEmitter);
+      this._listeners = [];
+    }
+    return (0, _createClass2.default)(PressabilityPerformanceEventEmitter, [{
+      key: "addListener",
+      value: function addListener(listener) {
+        this._listeners.push(listener);
+      }
+    }, {
+      key: "removeListener",
+      value: function removeListener(listener) {
+        var index = this._listeners.indexOf(listener);
+        if (index > -1) {
+          this._listeners.splice(index, 1);
+        }
+      }
+    }, {
+      key: "emitEvent",
+      value: function emitEvent(constructEvent) {
+        if (this._listeners.length === 0) {
+          return;
+        }
+        var event = constructEvent();
+        this._listeners.forEach(function (listener) {
+          return listener(event);
+        });
+      }
+    }]);
+  }();
+  var PressabilityPerformanceEventEmitterSingleton = new PressabilityPerformanceEventEmitter();
+  var _default = exports.default = PressabilityPerformanceEventEmitterSingleton;
+},346,[1,11,12],"../../node_modules/react-native/Libraries/Pressability/PressabilityPerformanceEventEmitter.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.isHoverEnabled = isHoverEnabled;
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../Utilities/Platform"));
+  var isEnabled = false;
+  if (_Platform.default.OS === 'web') {
+    var canUseDOM = Boolean(typeof window !== 'undefined' && window.document && window.document.createElement);
+    if (canUseDOM) {
+      var HOVER_THRESHOLD_MS = 1000;
+      var lastTouchTimestamp = 0;
+      var enableHover = function enableHover() {
+        if (isEnabled || Date.now() - lastTouchTimestamp < HOVER_THRESHOLD_MS) {
+          return;
+        }
+        isEnabled = true;
+      };
+      var disableHover = function disableHover() {
+        lastTouchTimestamp = Date.now();
+        if (isEnabled) {
+          isEnabled = false;
+        }
+      };
+      document.addEventListener('touchstart', disableHover, true);
+      document.addEventListener('touchmove', disableHover, true);
+      document.addEventListener('mousemove', enableHover, true);
+    }
+  }
+  function isHoverEnabled() {
+    return isEnabled;
+  }
+},347,[1,68],"../../node_modules/react-native/Libraries/Pressability/HoverState.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.createSquare = createSquare;
+  exports.normalizeRect = normalizeRect;
+  function createSquare(size) {
+    return {
+      bottom: size,
+      left: size,
+      right: size,
+      top: size
+    };
+  }
+  function normalizeRect(rectOrSize) {
+    return typeof rectOrSize === 'number' ? createSquare(rectOrSize) : rectOrSize;
+  }
+},348,[],"../../node_modules/react-native/Libraries/StyleSheet/Rect.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.PressabilityDebugView = PressabilityDebugView;
+  exports.isEnabled = isEnabled;
+  exports.setEnabled = setEnabled;
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../Components/View/View"));
+  var _normalizeColor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../StyleSheet/normalizeColor"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[3], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[4], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Pressability/PressabilityDebug.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function PressabilityDebugView(props) {
+    if (__DEV__) {
+      if (isEnabled()) {
+        var _hitSlop$bottom, _hitSlop$left, _hitSlop$right, _hitSlop$top;
+        var normalizedColor = (0, _normalizeColor.default)(props.color);
+        if (typeof normalizedColor !== 'number') {
+          return null;
+        }
+        var baseColor = '#' + (normalizedColor != null ? normalizedColor : 0).toString(16).padStart(8, '0');
+        var hitSlop = (0, _$$_REQUIRE(_dependencyMap[5], "../StyleSheet/Rect").normalizeRect)(props.hitSlop);
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+          pointerEvents: "none",
+          style: {
+            backgroundColor: baseColor.slice(0, -2) + '0F',
+            borderColor: baseColor.slice(0, -2) + '55',
+            borderStyle: 'dashed',
+            borderWidth: 1,
+            bottom: -((_hitSlop$bottom = hitSlop == null ? void 0 : hitSlop.bottom) != null ? _hitSlop$bottom : 0),
+            left: -((_hitSlop$left = hitSlop == null ? void 0 : hitSlop.left) != null ? _hitSlop$left : 0),
+            position: 'absolute',
+            right: -((_hitSlop$right = hitSlop == null ? void 0 : hitSlop.right) != null ? _hitSlop$right : 0),
+            top: -((_hitSlop$top = hitSlop == null ? void 0 : hitSlop.top) != null ? _hitSlop$top : 0)
+          }
+        });
+      }
+    }
+    return null;
+  }
+  var isDebugEnabled = false;
+  function isEnabled() {
+    if (__DEV__) {
+      return isDebugEnabled;
+    }
+    return false;
+  }
+  function setEnabled(value) {
+    if (__DEV__) {
+      isDebugEnabled = value;
+    }
+  }
+},349,[1,71,58,73,171,348],"../../node_modules/react-native/Libraries/Pressability/PressabilityDebug.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.getBackgroundColor = getBackgroundColor;
+  exports.getBackgroundDarkColor = getBackgroundDarkColor;
+  exports.getBackgroundLightColor = getBackgroundLightColor;
+  exports.getDividerColor = getDividerColor;
+  exports.getErrorColor = getErrorColor;
+  exports.getErrorDarkColor = getErrorDarkColor;
+  exports.getFatalColor = getFatalColor;
+  exports.getFatalDarkColor = getFatalDarkColor;
+  exports.getHighlightColor = getHighlightColor;
+  exports.getLogColor = getLogColor;
+  exports.getTextColor = getTextColor;
+  exports.getWarningColor = getWarningColor;
+  exports.getWarningDarkColor = getWarningDarkColor;
+  exports.getWarningHighlightColor = getWarningHighlightColor;
+  function getBackgroundColor(opacity) {
+    return `rgba(51, 51, 51, ${opacity == null ? 1 : opacity})`;
+  }
+  function getBackgroundLightColor(opacity) {
+    return `rgba(69, 69, 69, ${opacity == null ? 1 : opacity})`;
+  }
+  function getBackgroundDarkColor(opacity) {
+    return `rgba(34, 34, 34, ${opacity == null ? 1 : opacity})`;
+  }
+  function getWarningColor(opacity) {
+    return `rgba(250, 186, 48, ${opacity == null ? 1 : opacity})`;
+  }
+  function getWarningDarkColor(opacity) {
+    return `rgba(224, 167, 8, ${opacity == null ? 1 : opacity})`;
+  }
+  function getFatalColor(opacity) {
+    return `rgba(243, 83, 105, ${opacity == null ? 1 : opacity})`;
+  }
+  function getFatalDarkColor(opacity) {
+    return `rgba(208, 75, 95, ${opacity == null ? 1 : opacity})`;
+  }
+  function getErrorColor(opacity) {
+    return `rgba(243, 83, 105, ${opacity == null ? 1 : opacity})`;
+  }
+  function getErrorDarkColor(opacity) {
+    return `rgba(208, 75, 95, ${opacity == null ? 1 : opacity})`;
+  }
+  function getLogColor(opacity) {
+    return `rgba(119, 119, 119, ${opacity == null ? 1 : opacity})`;
+  }
+  function getWarningHighlightColor(opacity) {
+    return `rgba(252, 176, 29, ${opacity == null ? 1 : opacity})`;
+  }
+  function getDividerColor(opacity) {
+    return `rgba(255, 255, 255, ${opacity == null ? 1 : opacity})`;
+  }
+  function getHighlightColor(opacity) {
+    return `rgba(252, 176, 29, ${opacity == null ? 1 : opacity})`;
+  }
+  function getTextColor(opacity) {
+    return `rgba(255, 255, 255, ${opacity == null ? 1 : opacity})`;
+  }
+},350,[],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxStyle.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = LogBoxNotificationCountBadge;
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Components/View/View"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../StyleSheet/StyleSheet"));
+  var _Text = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../Text/Text"));
+  var LogBoxStyle = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[4], "./LogBoxStyle"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[5], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[6], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/LogBox/UI/LogBoxNotificationCountBadge.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function LogBoxNotificationCountBadge(props) {
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+      style: styles.outside,
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+        style: [styles.inside, styles[props.level]],
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+          id: "logbox_notification_count_text",
+          style: styles.text,
+          children: props.count <= 1 ? '!' : props.count
+        })
+      })
+    });
+  }
+  var styles = _StyleSheet.default.create({
+    warn: {
+      backgroundColor: LogBoxStyle.getWarningColor(1)
+    },
+    error: {
+      backgroundColor: LogBoxStyle.getErrorColor(1)
+    },
+    outside: {
+      padding: 2,
+      borderRadius: 25,
+      backgroundColor: '#fff',
+      marginRight: 8
+    },
+    inside: {
+      minWidth: 18,
+      paddingLeft: 4,
+      paddingRight: 4,
+      borderRadius: 25,
+      fontWeight: '600'
+    },
+    text: {
+      color: LogBoxStyle.getTextColor(1),
+      fontSize: 14,
+      lineHeight: 18,
+      textAlign: 'center',
+      fontWeight: '600',
+      textShadowColor: LogBoxStyle.getBackgroundColor(0.4),
+      textShadowOffset: {
+        width: 0,
+        height: 0
+      },
+      textShadowRadius: 3
+    }
+  });
+},351,[1,71,6,352,350,73,171],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxNotificationCountBadge.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/objectWithoutProperties"));
+  var PressabilityDebug = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[3], "../Pressability/PressabilityDebug"));
+  var _usePressability = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../Pressability/usePressability"));
+  var _flattenStyle = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../StyleSheet/flattenStyle"));
+  var _processColor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../StyleSheet/processColor"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../Utilities/Platform"));
+  var _TextAncestor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./TextAncestor"));
+  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[9], "react"));
+  var React = _react;
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[10], "react/jsx-runtime");
+  var _excluded = ["accessible", "accessibilityLabel", "accessibilityState", "allowFontScaling", "aria-busy", "aria-checked", "aria-disabled", "aria-expanded", "aria-label", "aria-selected", "children", "ellipsizeMode", "disabled", "id", "nativeID", "numberOfLines", "onLongPress", "onPress", "onPressIn", "onPressOut", "onResponderGrant", "onResponderMove", "onResponderRelease", "onResponderTerminate", "onResponderTerminationRequest", "onStartShouldSetResponder", "pressRetentionOffset", "selectable", "selectionColor", "suppressHighlighting", "style"];
+  var _this = this,
+    _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Text/Text.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var TextImpl = React.forwardRef(function (_ref, forwardedRef) {
+    var _accessibilityState2;
+    var accessible = _ref.accessible,
+      accessibilityLabel = _ref.accessibilityLabel,
+      accessibilityState = _ref.accessibilityState,
+      allowFontScaling = _ref.allowFontScaling,
+      ariaBusy = _ref['aria-busy'],
+      ariaChecked = _ref['aria-checked'],
+      ariaDisabled = _ref['aria-disabled'],
+      ariaExpanded = _ref['aria-expanded'],
+      ariaLabel = _ref['aria-label'],
+      ariaSelected = _ref['aria-selected'],
+      children = _ref.children,
+      ellipsizeMode = _ref.ellipsizeMode,
+      disabled = _ref.disabled,
+      id = _ref.id,
+      nativeID = _ref.nativeID,
+      numberOfLines = _ref.numberOfLines,
+      onLongPress = _ref.onLongPress,
+      onPress = _ref.onPress,
+      onPressIn = _ref.onPressIn,
+      onPressOut = _ref.onPressOut,
+      onResponderGrant = _ref.onResponderGrant,
+      onResponderMove = _ref.onResponderMove,
+      onResponderRelease = _ref.onResponderRelease,
+      onResponderTerminate = _ref.onResponderTerminate,
+      onResponderTerminationRequest = _ref.onResponderTerminationRequest,
+      onStartShouldSetResponder = _ref.onStartShouldSetResponder,
+      pressRetentionOffset = _ref.pressRetentionOffset,
+      selectable = _ref.selectable,
+      selectionColor = _ref.selectionColor,
+      suppressHighlighting = _ref.suppressHighlighting,
+      style = _ref.style,
+      restProps = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+    var _accessibilityLabel = ariaLabel != null ? ariaLabel : accessibilityLabel;
+    var _accessibilityState = accessibilityState;
+    if (ariaBusy != null || ariaChecked != null || ariaDisabled != null || ariaExpanded != null || ariaSelected != null) {
+      if (_accessibilityState != null) {
+        _accessibilityState = {
+          busy: ariaBusy != null ? ariaBusy : _accessibilityState.busy,
+          checked: ariaChecked != null ? ariaChecked : _accessibilityState.checked,
+          disabled: ariaDisabled != null ? ariaDisabled : _accessibilityState.disabled,
+          expanded: ariaExpanded != null ? ariaExpanded : _accessibilityState.expanded,
+          selected: ariaSelected != null ? ariaSelected : _accessibilityState.selected
+        };
+      } else {
+        _accessibilityState = {
+          busy: ariaBusy,
+          checked: ariaChecked,
+          disabled: ariaDisabled,
+          expanded: ariaExpanded,
+          selected: ariaSelected
+        };
+      }
+    }
+    var _accessibilityStateDisabled = (_accessibilityState2 = _accessibilityState) == null ? void 0 : _accessibilityState2.disabled;
+    var _disabled = disabled != null ? disabled : _accessibilityStateDisabled;
+    var isPressable = (onPress != null || onLongPress != null || onStartShouldSetResponder != null) && _disabled !== true;
+    var _selectionColor = selectionColor != null ? (0, _processColor.default)(selectionColor) : undefined;
+    var _style = style;
+    if (__DEV__) {
+      if (PressabilityDebug.isEnabled() && onPress != null) {
+        _style = [style, {
+          color: 'magenta'
+        }];
+      }
+    }
+    var _numberOfLines = numberOfLines;
+    if (_numberOfLines != null && !(_numberOfLines >= 0)) {
+      if (__DEV__) {
+        console.error(`'numberOfLines' in <Text> must be a non-negative number, received: ${_numberOfLines}. The value will be set to 0.`);
+      }
+      _numberOfLines = 0;
+    }
+    var _selectable = selectable;
+    var processedStyle = (0, _flattenStyle.default)(_style);
+    if (processedStyle != null) {
+      var overrides = null;
+      if (typeof processedStyle.fontWeight === 'number') {
+        overrides = overrides || {};
+        overrides.fontWeight = processedStyle.fontWeight.toString();
+      }
+      if (processedStyle.userSelect != null) {
+        _selectable = userSelectToSelectableMap[processedStyle.userSelect];
+        overrides = overrides || {};
+        overrides.userSelect = undefined;
+      }
+      if (processedStyle.verticalAlign != null) {
+        overrides = overrides || {};
+        overrides.textAlignVertical = verticalAlignToTextAlignVerticalMap[processedStyle.verticalAlign];
+        overrides.verticalAlign = undefined;
+      }
+      if (overrides != null) {
+        _style = [_style, overrides];
+      }
+    }
+    var _nativeID = id != null ? id : nativeID;
+    var hasTextAncestor = (0, _react.useContext)(_TextAncestor.default);
+    if (hasTextAncestor) {
+      if (isPressable) {
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(NativePressableVirtualText, {
+          ref: forwardedRef,
+          textProps: Object.assign({}, restProps, {
+            accessibilityLabel: _accessibilityLabel,
+            accessibilityState: _accessibilityState,
+            nativeID: _nativeID,
+            numberOfLines: _numberOfLines,
+            selectable: _selectable,
+            selectionColor: _selectionColor,
+            style: _style,
+            disabled: disabled,
+            children: children
+          }),
+          textPressabilityProps: {
+            onLongPress: onLongPress,
+            onPress: onPress,
+            onPressIn: onPressIn,
+            onPressOut: onPressOut,
+            onResponderGrant: onResponderGrant,
+            onResponderMove: onResponderMove,
+            onResponderRelease: onResponderRelease,
+            onResponderTerminate: onResponderTerminate,
+            onResponderTerminationRequest: onResponderTerminationRequest,
+            onStartShouldSetResponder: onStartShouldSetResponder,
+            pressRetentionOffset: pressRetentionOffset,
+            suppressHighlighting: suppressHighlighting
+          }
+        });
+      }
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[11], "./TextNativeComponent").NativeVirtualText, Object.assign({}, restProps, {
+        accessibilityLabel: _accessibilityLabel,
+        accessibilityState: _accessibilityState,
+        nativeID: _nativeID,
+        numberOfLines: _numberOfLines,
+        ref: forwardedRef,
+        selectable: _selectable,
+        selectionColor: _selectionColor,
+        style: _style,
+        disabled: disabled,
+        children: children
+      }));
+    }
+    if (_disabled !== _accessibilityStateDisabled && (_disabled != null && _disabled !== false || _accessibilityStateDisabled != null && _accessibilityStateDisabled !== false)) {
+      _accessibilityState = Object.assign({}, _accessibilityState, {
+        disabled: _disabled
+      });
+    }
+    var _accessible = _Platform.default.select({
+      ios: accessible !== false,
+      android: accessible == null ? onPress != null || onLongPress != null : accessible,
+      default: accessible
+    });
+    var nativeText = null;
+    if (isPressable) {
+      nativeText = /*#__PURE__*/(0, _jsxRuntime.jsx)(NativePressableText, {
+        ref: forwardedRef,
+        textProps: Object.assign({}, restProps, {
+          accessibilityLabel: _accessibilityLabel,
+          accessibilityState: _accessibilityState,
+          accessible: _accessible,
+          allowFontScaling: allowFontScaling !== false,
+          disabled: _disabled,
+          ellipsizeMode: ellipsizeMode != null ? ellipsizeMode : 'tail',
+          nativeID: _nativeID,
+          numberOfLines: _numberOfLines,
+          selectable: _selectable,
+          selectionColor: _selectionColor,
+          style: _style,
+          children: children
+        }),
+        textPressabilityProps: {
+          onLongPress: onLongPress,
+          onPress: onPress,
+          onPressIn: onPressIn,
+          onPressOut: onPressOut,
+          onResponderGrant: onResponderGrant,
+          onResponderMove: onResponderMove,
+          onResponderRelease: onResponderRelease,
+          onResponderTerminate: onResponderTerminate,
+          onResponderTerminationRequest: onResponderTerminationRequest,
+          onStartShouldSetResponder: onStartShouldSetResponder,
+          pressRetentionOffset: pressRetentionOffset,
+          suppressHighlighting: suppressHighlighting
+        }
+      });
+    } else {
+      nativeText = /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[11], "./TextNativeComponent").NativeText, Object.assign({}, restProps, {
+        accessibilityLabel: _accessibilityLabel,
+        accessibilityState: _accessibilityState,
+        accessible: _accessible,
+        allowFontScaling: allowFontScaling !== false,
+        disabled: _disabled,
+        ellipsizeMode: ellipsizeMode != null ? ellipsizeMode : 'tail',
+        nativeID: _nativeID,
+        numberOfLines: _numberOfLines,
+        ref: forwardedRef,
+        selectable: _selectable,
+        selectionColor: _selectionColor,
+        style: _style,
+        children: children
+      }));
+    }
+    if (children == null) {
+      return nativeText;
+    }
+    if (Array.isArray(children) && children.length <= 3) {
+      var hasNonTextChild = false;
+      for (var child of children) {
+        if (child != null && typeof child === 'object') {
+          hasNonTextChild = true;
+          break;
+        }
+      }
+      if (!hasNonTextChild) {
+        return nativeText;
+      }
+    } else if (typeof children !== 'object') {
+      return nativeText;
+    }
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_TextAncestor.default.Provider, {
+      value: true,
+      children: nativeText
+    });
+  });
+  TextImpl.displayName = 'Text';
+  function useTextPressability(_ref2) {
+    var onLongPress = _ref2.onLongPress,
+      onPress = _ref2.onPress,
+      onPressIn = _ref2.onPressIn,
+      onPressOut = _ref2.onPressOut,
+      _onResponderGrant = _ref2.onResponderGrant,
+      _onResponderMove = _ref2.onResponderMove,
+      _onResponderRelease = _ref2.onResponderRelease,
+      _onResponderTerminate = _ref2.onResponderTerminate,
+      onResponderTerminationRequest = _ref2.onResponderTerminationRequest,
+      onStartShouldSetResponder = _ref2.onStartShouldSetResponder,
+      pressRetentionOffset = _ref2.pressRetentionOffset,
+      suppressHighlighting = _ref2.suppressHighlighting;
+    var _useState = (0, _react.useState)(false),
+      _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+      isHighlighted = _useState2[0],
+      setHighlighted = _useState2[1];
+    var config = (0, _react.useMemo)(function () {
+      var _onPressIn = onPressIn;
+      var _onPressOut = onPressOut;
+      if (_Platform.default.OS === 'ios') {
+        _onPressIn = function _onPressIn(event) {
+          setHighlighted(suppressHighlighting == null || !suppressHighlighting);
+          onPressIn == null || onPressIn(event);
+        };
+        _onPressOut = function _onPressOut(event) {
+          setHighlighted(false);
+          onPressOut == null || onPressOut(event);
+        };
+      }
+      return {
+        disabled: false,
+        pressRectOffset: pressRetentionOffset,
+        onLongPress: onLongPress,
+        onPress: onPress,
+        onPressIn: _onPressIn,
+        onPressOut: _onPressOut
+      };
+    }, [pressRetentionOffset, onLongPress, onPress, onPressIn, onPressOut, suppressHighlighting]);
+    var eventHandlers = (0, _usePressability.default)(config);
+    var eventHandlersForText = (0, _react.useMemo)(function () {
+      return eventHandlers == null ? null : {
+        onResponderGrant: function onResponderGrant(event) {
+          eventHandlers.onResponderGrant(event);
+          if (_onResponderGrant != null) {
+            _onResponderGrant(event);
+          }
+        },
+        onResponderMove: function onResponderMove(event) {
+          eventHandlers.onResponderMove(event);
+          if (_onResponderMove != null) {
+            _onResponderMove(event);
+          }
+        },
+        onResponderRelease: function onResponderRelease(event) {
+          eventHandlers.onResponderRelease(event);
+          if (_onResponderRelease != null) {
+            _onResponderRelease(event);
+          }
+        },
+        onResponderTerminate: function onResponderTerminate(event) {
+          eventHandlers.onResponderTerminate(event);
+          if (_onResponderTerminate != null) {
+            _onResponderTerminate(event);
+          }
+        },
+        onClick: eventHandlers.onClick,
+        onResponderTerminationRequest: onResponderTerminationRequest != null ? onResponderTerminationRequest : eventHandlers.onResponderTerminationRequest,
+        onStartShouldSetResponder: onStartShouldSetResponder != null ? onStartShouldSetResponder : eventHandlers.onStartShouldSetResponder
+      };
+    }, [eventHandlers, _onResponderGrant, _onResponderMove, _onResponderRelease, _onResponderTerminate, onResponderTerminationRequest, onStartShouldSetResponder]);
+    return (0, _react.useMemo)(function () {
+      return [isHighlighted, eventHandlersForText];
+    }, [isHighlighted, eventHandlersForText]);
+  }
+  var NativePressableVirtualText = React.forwardRef(function (_ref3, forwardedRef) {
+    var textProps = _ref3.textProps,
+      textPressabilityProps = _ref3.textPressabilityProps;
+    var _useTextPressability = useTextPressability(textPressabilityProps),
+      _useTextPressability2 = (0, _slicedToArray2.default)(_useTextPressability, 2),
+      isHighlighted = _useTextPressability2[0],
+      eventHandlersForText = _useTextPressability2[1];
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[11], "./TextNativeComponent").NativeVirtualText, Object.assign({}, textProps, eventHandlersForText, {
+      isHighlighted: isHighlighted,
+      isPressable: true,
+      ref: forwardedRef
+    }));
+  });
+  var NativePressableText = React.forwardRef(function (_ref4, forwardedRef) {
+    var textProps = _ref4.textProps,
+      textPressabilityProps = _ref4.textPressabilityProps;
+    var _useTextPressability3 = useTextPressability(textPressabilityProps),
+      _useTextPressability4 = (0, _slicedToArray2.default)(_useTextPressability3, 2),
+      isHighlighted = _useTextPressability4[0],
+      eventHandlersForText = _useTextPressability4[1];
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[11], "./TextNativeComponent").NativeText, Object.assign({}, textProps, eventHandlersForText, {
+      isHighlighted: isHighlighted,
+      isPressable: true,
+      ref: forwardedRef
+    }));
+  });
+  var userSelectToSelectableMap = {
+    auto: true,
+    text: true,
+    none: false,
+    contain: true,
+    all: true
+  };
+  var verticalAlignToTextAlignVerticalMap = {
+    auto: 'auto',
+    top: 'top',
+    bottom: 'bottom',
+    middle: 'center'
+  };
+  var _default = exports.default = TextImpl;
+},352,[1,34,4,349,340,9,57,68,72,73,171,353],"../../node_modules/react-native/Libraries/Text/Text.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.NativeVirtualText = exports.NativeText = void 0;
+  var _UIManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../ReactNative/UIManager"));
+  var _createReactNativeComponentClass = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../Renderer/shims/createReactNativeComponentClass"));
+  var textViewConfig = {
+    validAttributes: {
+      isHighlighted: true,
+      isPressable: true,
+      numberOfLines: true,
+      ellipsizeMode: true,
+      allowFontScaling: true,
+      dynamicTypeRamp: true,
+      maxFontSizeMultiplier: true,
+      disabled: true,
+      selectable: true,
+      selectionColor: true,
+      adjustsFontSizeToFit: true,
+      minimumFontScale: true,
+      textBreakStrategy: true,
+      onTextLayout: true,
+      dataDetectorType: true,
+      android_hyphenationFrequency: true,
+      lineBreakStrategyIOS: true
+    },
+    directEventTypes: {
+      topTextLayout: {
+        registrationName: 'onTextLayout'
+      }
+    },
+    uiViewClassName: 'RCTText'
+  };
+  var virtualTextViewConfig = {
+    validAttributes: {
+      isHighlighted: true,
+      isPressable: true,
+      maxFontSizeMultiplier: true
+    },
+    uiViewClassName: 'RCTVirtualText'
+  };
+  var NativeText = exports.NativeText = (0, _createReactNativeComponentClass.default)('RCTText', function () {
+    return (0, _$$_REQUIRE(_dependencyMap[3], "../NativeComponent/ViewConfig").createViewConfig)(textViewConfig);
+  });
+  var NativeVirtualText = exports.NativeVirtualText = !global.RN$Bridgeless && !_UIManager.default.hasViewManagerConfig('RCTVirtualText') ? NativeText : (0, _createReactNativeComponentClass.default)('RCTVirtualText', function () {
+    return (0, _$$_REQUIRE(_dependencyMap[3], "../NativeComponent/ViewConfig").createViewConfig)(virtualTextViewConfig);
+  });
+},353,[1,79,321,101],"../../node_modules/react-native/Libraries/Text/TextNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = LogBoxNotificationDismissButton;
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Components/View/View"));
+  var _Image = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../Image/Image"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/StyleSheet"));
+  var _LogBoxButton = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./LogBoxButton"));
+  var LogBoxStyle = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[5], "./LogBoxStyle"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[6], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[7], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/LogBox/UI/LogBoxNotificationDismissButton.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function LogBoxNotificationDismissButton(props) {
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+      style: styles.container,
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxButton.default, {
+        id: props.id,
+        backgroundColor: {
+          default: LogBoxStyle.getTextColor(0.3),
+          pressed: LogBoxStyle.getTextColor(0.5)
+        },
+        hitSlop: {
+          top: 12,
+          right: 10,
+          bottom: 12,
+          left: 10
+        },
+        onPress: props.onPress,
+        style: styles.press,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_Image.default, {
+          source: _$$_REQUIRE(_dependencyMap[8], "./LogBoxImages/close.png"),
+          style: styles.image
+        })
+      })
+    });
+  }
+  var styles = _StyleSheet.default.create({
+    container: {
+      alignSelf: 'center',
+      flexDirection: 'row',
+      flexGrow: 0,
+      flexShrink: 0,
+      flexBasis: 'auto',
+      marginLeft: 5
+    },
+    press: {
+      height: 20,
+      width: 20,
+      borderRadius: 25,
+      alignSelf: 'flex-end',
+      alignItems: 'center',
+      justifyContent: 'center'
+    },
+    image: {
+      height: 8,
+      width: 8,
+      tintColor: LogBoxStyle.getBackgroundColor(1)
+    }
+  });
+},354,[1,71,355,6,338,350,73,171,366],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxNotificationDismissButton.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties"));
+  var _asyncToGenerator2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/asyncToGenerator"));
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/slicedToArray"));
+  var _flattenStyle = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../StyleSheet/flattenStyle"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../StyleSheet/StyleSheet"));
+  var _ImageAnalyticsTagContext = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./ImageAnalyticsTagContext"));
+  var _ImageViewNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./ImageViewNativeComponent"));
+  var _NativeImageLoaderIOS = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./NativeImageLoaderIOS"));
+  var _resolveAssetSource = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./resolveAssetSource"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[10], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[11], "react/jsx-runtime");
+  var _excluded = ["aria-busy", "aria-checked", "aria-disabled", "aria-expanded", "aria-selected", "src"];
+  var _this = this,
+    _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Image/Image.ios.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function getSize(uri, success, failure) {
+    var promise = _NativeImageLoaderIOS.default.getSize(uri).then(function (_ref) {
+      var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
+        width = _ref2[0],
+        height = _ref2[1];
+      return {
+        width: width,
+        height: height
+      };
+    });
+    if (typeof success !== 'function') {
+      return promise;
+    }
+    promise.then(function (sizes) {
+      return success(sizes.width, sizes.height);
+    }).catch(failure || function () {
+      console.warn('Failed to get size for image: ' + uri);
+    });
+  }
+  function getSizeWithHeaders(uri, headers, success, failure) {
+    var promise = _NativeImageLoaderIOS.default.getSizeWithHeaders(uri, headers);
+    if (typeof success !== 'function') {
+      return promise;
+    }
+    promise.then(function (sizes) {
+      return success(sizes.width, sizes.height);
+    }).catch(failure || function () {
+      console.warn('Failed to get size for image: ' + uri);
+    });
+  }
+  function prefetchWithMetadata(url, queryRootName, rootTag) {
+    if (_NativeImageLoaderIOS.default.prefetchImageWithMetadata) {
+      return _NativeImageLoaderIOS.default.prefetchImageWithMetadata(url, queryRootName, rootTag != null ? rootTag : (0, _$$_REQUIRE(_dependencyMap[12], "../ReactNative/RootTag").createRootTag)(0));
+    } else {
+      return _NativeImageLoaderIOS.default.prefetchImage(url);
+    }
+  }
+  function prefetch(url) {
+    return _NativeImageLoaderIOS.default.prefetchImage(url);
+  }
+  function queryCache(_x) {
+    return _queryCache.apply(this, arguments);
+  }
+  function _queryCache() {
+    _queryCache = (0, _asyncToGenerator2.default)(function* (urls) {
+      return _NativeImageLoaderIOS.default.queryCache(urls);
+    });
+    return _queryCache.apply(this, arguments);
+  }
+  var BaseImage = React.forwardRef(function (props, forwardedRef) {
+    var _props$tintColor, _props$accessibilityS, _props$accessibilityS2, _props$accessibilityS3, _props$accessibilityS4, _props$accessibilityS5, _props$ariaLabel;
+    var source = (0, _$$_REQUIRE(_dependencyMap[13], "./ImageSourceUtils").getImageSourcesFromImageProps)(props) || {
+      uri: undefined,
+      width: undefined,
+      height: undefined
+    };
+    var style;
+    var sources;
+    if (Array.isArray(source)) {
+      style = [styles.base, props.style];
+      sources = source;
+    } else {
+      var _source$width, _source$height;
+      var uri = source.uri;
+      if (uri === '') {
+        console.warn('source.uri should not be an empty string');
+      }
+      var _width = (_source$width = source.width) != null ? _source$width : props.width;
+      var _height = (_source$height = source.height) != null ? _source$height : props.height;
+      style = [{
+        width: _width,
+        height: _height
+      }, styles.base, props.style];
+      sources = [source];
+    }
+    var flattenedStyle = (0, _flattenStyle.default)(style);
+    var objectFit = (0, _$$_REQUIRE(_dependencyMap[14], "./ImageUtils").convertObjectFitToResizeMode)(flattenedStyle == null ? void 0 : flattenedStyle.objectFit);
+    var resizeMode = objectFit || props.resizeMode || (flattenedStyle == null ? void 0 : flattenedStyle.resizeMode) || 'cover';
+    var tintColor = (_props$tintColor = props.tintColor) != null ? _props$tintColor : flattenedStyle == null ? void 0 : flattenedStyle.tintColor;
+    if (props.children != null) {
+      throw new Error('The <Image> component cannot contain children. If you want to render content on top of the image, consider using the <ImageBackground> component or absolute positioning.');
+    }
+    var ariaBusy = props['aria-busy'],
+      ariaChecked = props['aria-checked'],
+      ariaDisabled = props['aria-disabled'],
+      ariaExpanded = props['aria-expanded'],
+      ariaSelected = props['aria-selected'],
+      src = props.src,
+      restProps = (0, _objectWithoutProperties2.default)(props, _excluded);
+    var _accessibilityState = {
+      busy: ariaBusy != null ? ariaBusy : (_props$accessibilityS = props.accessibilityState) == null ? void 0 : _props$accessibilityS.busy,
+      checked: ariaChecked != null ? ariaChecked : (_props$accessibilityS2 = props.accessibilityState) == null ? void 0 : _props$accessibilityS2.checked,
+      disabled: ariaDisabled != null ? ariaDisabled : (_props$accessibilityS3 = props.accessibilityState) == null ? void 0 : _props$accessibilityS3.disabled,
+      expanded: ariaExpanded != null ? ariaExpanded : (_props$accessibilityS4 = props.accessibilityState) == null ? void 0 : _props$accessibilityS4.expanded,
+      selected: ariaSelected != null ? ariaSelected : (_props$accessibilityS5 = props.accessibilityState) == null ? void 0 : _props$accessibilityS5.selected
+    };
+    var accessibilityLabel = (_props$ariaLabel = props['aria-label']) != null ? _props$ariaLabel : props.accessibilityLabel;
+    var actualRef = (0, _$$_REQUIRE(_dependencyMap[15], "./ImageInjection").useWrapRefWithImageAttachedCallbacks)(forwardedRef);
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_ImageAnalyticsTagContext.default.Consumer, {
+      children: function children(analyticTag) {
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(_ImageViewNativeComponent.default, Object.assign({
+          accessibilityState: _accessibilityState
+        }, restProps, {
+          accessible: props.alt !== undefined ? true : props.accessible,
+          accessibilityLabel: accessibilityLabel != null ? accessibilityLabel : props.alt,
+          ref: actualRef,
+          style: style,
+          resizeMode: resizeMode,
+          tintColor: tintColor,
+          source: sources,
+          internal_analyticTag: analyticTag
+        }));
+      }
+    });
+  });
+  var imageComponentDecorator = (0, _$$_REQUIRE(_dependencyMap[15], "./ImageInjection").unstable_getImageComponentDecorator)();
+  if (imageComponentDecorator != null) {
+    BaseImage = imageComponentDecorator(BaseImage);
+  }
+  var Image = BaseImage;
+  Image.displayName = 'Image';
+  Image.getSize = getSize;
+  Image.getSizeWithHeaders = getSizeWithHeaders;
+  Image.prefetch = prefetch;
+  Image.prefetchWithMetadata = prefetchWithMetadata;
+  Image.queryCache = queryCache;
+  Image.resolveAssetSource = _resolveAssetSource.default;
+  var styles = _StyleSheet.default.create({
+    base: {
+      overflow: 'hidden'
+    }
+  });
+  var _default = exports.default = Image;
+},355,[1,4,167,34,9,6,356,357,358,92,73,171,360,361,362,363],"../../node_modules/react-native/Libraries/Image/Image.ios.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var Context = React.createContext(null);
+  if (__DEV__) {
+    Context.displayName = 'ImageAnalyticsTagContext';
+  }
+  var _default = exports.default = Context;
+},356,[73],"../../node_modules/react-native/Libraries/Image/ImageAnalyticsTagContext.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = exports.__INTERNAL_VIEW_CONFIG = exports.Commands = void 0;
+  var NativeComponentRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../NativeComponent/NativeComponentRegistry"));
+  var _codegenNativeCommands = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../Utilities/codegenNativeCommands"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../Utilities/Platform"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var Commands = exports.Commands = (0, _codegenNativeCommands.default)({
+    supportedCommands: ['setIsVisible_EXPERIMENTAL']
+  });
+  var __INTERNAL_VIEW_CONFIG = exports.__INTERNAL_VIEW_CONFIG = _Platform.default.OS === 'android' ? {
+    uiViewClassName: 'RCTImageView',
+    bubblingEventTypes: {},
+    directEventTypes: {
+      topLoadStart: {
+        registrationName: 'onLoadStart'
+      },
+      topProgress: {
+        registrationName: 'onProgress'
+      },
+      topError: {
+        registrationName: 'onError'
+      },
+      topLoad: {
+        registrationName: 'onLoad'
+      },
+      topLoadEnd: {
+        registrationName: 'onLoadEnd'
+      }
+    },
+    validAttributes: {
+      blurRadius: true,
+      defaultSource: true,
+      internal_analyticTag: true,
+      resizeMethod: true,
+      resizeMode: true,
+      resizeMultiplier: true,
+      tintColor: {
+        process: _$$_REQUIRE(_dependencyMap[4], "../StyleSheet/processColor").default
+      },
+      borderBottomLeftRadius: true,
+      borderTopLeftRadius: true,
+      src: true,
+      source: true,
+      borderRadius: true,
+      headers: true,
+      shouldNotifyLoadEvents: true,
+      overlayColor: {
+        process: _$$_REQUIRE(_dependencyMap[4], "../StyleSheet/processColor").default
+      },
+      borderColor: {
+        process: _$$_REQUIRE(_dependencyMap[4], "../StyleSheet/processColor").default
+      },
+      accessible: true,
+      progressiveRenderingEnabled: true,
+      fadeDuration: true,
+      borderBottomRightRadius: true,
+      borderTopRightRadius: true,
+      loadingIndicatorSrc: true
+    }
+  } : {
+    uiViewClassName: 'RCTImageView',
+    bubblingEventTypes: {},
+    directEventTypes: {
+      topLoadStart: {
+        registrationName: 'onLoadStart'
+      },
+      topProgress: {
+        registrationName: 'onProgress'
+      },
+      topError: {
+        registrationName: 'onError'
+      },
+      topPartialLoad: {
+        registrationName: 'onPartialLoad'
+      },
+      topLoad: {
+        registrationName: 'onLoad'
+      },
+      topLoadEnd: {
+        registrationName: 'onLoadEnd'
+      }
+    },
+    validAttributes: Object.assign({
+      blurRadius: true,
+      capInsets: {
+        diff: _$$_REQUIRE(_dependencyMap[5], "../Utilities/differ/insetsDiffer").default
+      },
+      defaultSource: {
+        process: _$$_REQUIRE(_dependencyMap[6], "./resolveAssetSource").default
+      },
+      internal_analyticTag: true,
+      resizeMode: true,
+      source: true,
+      tintColor: {
+        process: _$$_REQUIRE(_dependencyMap[4], "../StyleSheet/processColor").default
+      }
+    }, (0, _$$_REQUIRE(_dependencyMap[7], "../NativeComponent/ViewConfigIgnore").ConditionallyIgnoredEventHandlers)({
+      onLoadStart: true,
+      onLoad: true,
+      onLoadEnd: true,
+      onProgress: true,
+      onError: true,
+      onPartialLoad: true
+    }))
+  };
+  var ImageViewNativeComponent = NativeComponentRegistry.get('RCTImageView', function () {
+    return __INTERNAL_VIEW_CONFIG;
+  });
+  var _default = exports.default = ImageViewNativeComponent;
+},357,[1,77,105,68,57,90,92,104],"../../node_modules/react-native/Libraries/Image/ImageViewNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeImageLoaderIOS = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativeImageLoaderIOS"));
+  Object.keys(_NativeImageLoaderIOS).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeImageLoaderIOS[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeImageLoaderIOS[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeImageLoaderIOS.default;
+},358,[359],"../../node_modules/react-native/Libraries/Image/NativeImageLoaderIOS.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.getEnforcing('ImageLoader');
+},359,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeImageLoaderIOS.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.RootTagContext = void 0;
+  exports.createRootTag = createRootTag;
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var RootTagContext = exports.RootTagContext = React.createContext(0);
+  if (__DEV__) {
+    RootTagContext.displayName = 'RootTagContext';
+  }
+  function createRootTag(rootTag) {
+    return rootTag;
+  }
+},360,[73],"../../node_modules/react-native/Libraries/ReactNative/RootTag.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.getImageSourcesFromImageProps = getImageSourcesFromImageProps;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _resolveAssetSource = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./resolveAssetSource"));
+  function getImageSourcesFromImageProps(imageProps) {
+    var source = (0, _resolveAssetSource.default)(imageProps.source);
+    var sources;
+    var crossOrigin = imageProps.crossOrigin,
+      referrerPolicy = imageProps.referrerPolicy,
+      src = imageProps.src,
+      srcSet = imageProps.srcSet,
+      width = imageProps.width,
+      height = imageProps.height;
+    var headers = {};
+    if (crossOrigin === 'use-credentials') {
+      headers['Access-Control-Allow-Credentials'] = 'true';
+    }
+    if (referrerPolicy != null) {
+      headers['Referrer-Policy'] = referrerPolicy;
+    }
+    if (srcSet != null) {
+      var sourceList = [];
+      var srcSetList = srcSet.split(', ');
+      var shouldUseSrcForDefaultScale = true;
+      srcSetList.forEach(function (imageSrc) {
+        var _imageSrc$split = imageSrc.split(' '),
+          _imageSrc$split2 = (0, _slicedToArray2.default)(_imageSrc$split, 2),
+          uri = _imageSrc$split2[0],
+          _imageSrc$split2$ = _imageSrc$split2[1],
+          xScale = _imageSrc$split2$ === void 0 ? '1x' : _imageSrc$split2$;
+        if (!xScale.endsWith('x')) {
+          console.warn('The provided format for scale is not supported yet. Please use scales like 1x, 2x, etc.');
+        } else {
+          var scale = parseInt(xScale.split('x')[0], 10);
+          if (!isNaN(scale)) {
+            shouldUseSrcForDefaultScale = scale === 1 ? false : shouldUseSrcForDefaultScale;
+            sourceList.push({
+              headers: headers,
+              scale: scale,
+              uri: uri,
+              width: width,
+              height: height
+            });
+          }
+        }
+      });
+      if (shouldUseSrcForDefaultScale && src != null) {
+        sourceList.push({
+          headers: headers,
+          scale: 1,
+          uri: src,
+          width: width,
+          height: height
+        });
+      }
+      if (sourceList.length === 0) {
+        console.warn('The provided value for srcSet is not valid.');
+      }
+      sources = sourceList;
+    } else if (src != null) {
+      sources = [{
+        uri: src,
+        headers: headers,
+        width: width,
+        height: height
+      }];
+    } else if (source != null && source.uri && Object.keys(headers).length > 0) {
+      sources = [Object.assign({}, source, {
+        headers: headers
+      })];
+    } else {
+      sources = source;
+    }
+    return sources;
+  }
+},361,[1,34,92],"../../node_modules/react-native/Libraries/Image/ImageSourceUtils.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.convertObjectFitToResizeMode = convertObjectFitToResizeMode;
+  var objectFitMap = {
+    contain: 'contain',
+    cover: 'cover',
+    fill: 'stretch',
+    'scale-down': 'contain',
+    none: 'none'
+  };
+  function convertObjectFitToResizeMode(objectFit) {
+    return objectFit != null ? objectFitMap[objectFit] : undefined;
+  }
+},362,[],"../../node_modules/react-native/Libraries/Image/ImageUtils.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.unstable_getImageComponentDecorator = unstable_getImageComponentDecorator;
+  exports.unstable_registerImageAttachedCallback = unstable_registerImageAttachedCallback;
+  exports.unstable_setImageComponentDecorator = unstable_setImageComponentDecorator;
+  exports.unstable_unregisterImageAttachedCallback = unstable_unregisterImageAttachedCallback;
+  exports.useWrapRefWithImageAttachedCallbacks = useWrapRefWithImageAttachedCallbacks;
+  var _useMergeRefs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../Utilities/useMergeRefs"));
+  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[2], "react"));
+  var React = _react;
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var injectedImageComponentDecorator;
+  function unstable_setImageComponentDecorator(imageComponentDecorator) {
+    injectedImageComponentDecorator = imageComponentDecorator;
+  }
+  function unstable_getImageComponentDecorator() {
+    return injectedImageComponentDecorator;
+  }
+  var imageAttachedCallbacks = new Set();
+  function unstable_registerImageAttachedCallback(callback) {
+    imageAttachedCallbacks.add(callback);
+  }
+  function unstable_unregisterImageAttachedCallback(callback) {
+    imageAttachedCallbacks.delete(callback);
+  }
+  function useWrapRefWithImageAttachedCallbacks(forwardedRef) {
+    var pendingCleanupCallbacks = (0, _react.useRef)([]);
+    var imageAttachedCallbacksRef = (0, _react.useRef)(null);
+    if (imageAttachedCallbacksRef.current == null) {
+      imageAttachedCallbacksRef.current = function (node) {
+        if (node == null) {
+          if (pendingCleanupCallbacks.current.length > 0) {
+            pendingCleanupCallbacks.current.forEach(function (cb) {
+              return cb();
+            });
+            pendingCleanupCallbacks.current = [];
+          }
+        } else {
+          imageAttachedCallbacks.forEach(function (imageAttachedCallback) {
+            var maybeCleanupCallback = imageAttachedCallback(node);
+            if (maybeCleanupCallback != null) {
+              pendingCleanupCallbacks.current.push(maybeCleanupCallback);
+            }
+          });
+        }
+      };
+    }
+    return (0, _useMergeRefs.default)(forwardedRef, imageAttachedCallbacksRef.current);
+  }
+},363,[1,364,73],"../../node_modules/react-native/Libraries/Image/ImageInjection.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = useMergeRefs;
+  var _useRefEffect = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./useRefEffect"));
+  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[2], "react"));
+  var React = _react;
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function useMergeRefs() {
+    for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
+      refs[_key] = arguments[_key];
+    }
+    var refEffect = (0, _react.useCallback)(function (current) {
+      var cleanups = refs.map(function (ref) {
+        if (ref == null) {
+          return undefined;
+        } else {
+          if (typeof ref === 'function') {
+            var cleanup = ref(current);
+            return typeof cleanup === 'function' ? cleanup : function () {
+              ref(null);
+            };
+          } else {
+            ref.current = current;
+            return function () {
+              ref.current = null;
+            };
+          }
+        }
+      });
+      return function () {
+        for (var cleanup of cleanups) {
+          cleanup == null || cleanup();
+        }
+      };
+    }, [].concat(refs));
+    return (0, _useRefEffect.default)(refEffect);
+  }
+},364,[1,365,73],"../../node_modules/react-native/Libraries/Utilities/useMergeRefs.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = useRefEffect;
+  var _react = _$$_REQUIRE(_dependencyMap[0], "react");
+  function useRefEffect(effect) {
+    var cleanupRef = (0, _react.useRef)(undefined);
+    return (0, _react.useCallback)(function (instance) {
+      if (cleanupRef.current) {
+        cleanupRef.current();
+        cleanupRef.current = undefined;
+      }
+      if (instance != null) {
+        cleanupRef.current = effect(instance);
+      }
+    }, [effect]);
+  }
+},365,[73],"../../node_modules/react-native/Libraries/Utilities/useRefEffect.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  module.exports = _$$_REQUIRE(_dependencyMap[0], "react-native/Libraries/Image/AssetRegistry").registerAsset({
+    "__packager_asset": true,
+    "httpServerLocation": "/assets/../../node_modules/react-native/Libraries/LogBox/UI/LogBoxImages",
+    "width": 28,
+    "height": 28,
+    "scales": [1],
+    "hash": "369745d4a4a6fa62fa0ed495f89aa964",
+    "name": "close",
+    "type": "png"
+  });
+},366,[367],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxImages/close.png");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  module.exports = _$$_REQUIRE(_dependencyMap[0], "@react-native/assets-registry/registry");
+},367,[95],"../../node_modules/react-native/Libraries/Image/AssetRegistry.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = LogBoxNotificationMessage;
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Components/View/View"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../StyleSheet/StyleSheet"));
+  var _Text = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../Text/Text"));
+  var _LogBoxMessage = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./LogBoxMessage"));
+  var LogBoxStyle = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[5], "./LogBoxStyle"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[6], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[7], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/LogBox/UI/LogBoxNotificationMessage.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function LogBoxNotificationMessage(props) {
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+      style: styles.container,
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+        id: "logbox_notification_message_text",
+        numberOfLines: 1,
+        style: styles.text,
+        children: props.message && /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxMessage.default, {
+          plaintext: true,
+          message: props.message,
+          style: styles.substitutionText
+        })
+      })
+    });
+  }
+  var styles = _StyleSheet.default.create({
+    container: {
+      alignSelf: 'stretch',
+      flexGrow: 1,
+      flexShrink: 1,
+      flexBasis: 'auto',
+      borderLeftColor: LogBoxStyle.getTextColor(0.2),
+      borderLeftWidth: 1,
+      paddingLeft: 8
+    },
+    text: {
+      color: LogBoxStyle.getTextColor(1),
+      flex: 1,
+      fontSize: 14,
+      lineHeight: 22
+    },
+    substitutionText: {
+      color: LogBoxStyle.getTextColor(0.6)
+    }
+  });
+},368,[1,71,6,352,369,350,73,171],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxNotificationMessage.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _Linking = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Linking/Linking"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../StyleSheet/StyleSheet"));
+  var _Text = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../Text/Text"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[4], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[5], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/LogBox/UI/LogBoxMessage.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function getLinkRanges(string) {
+    var regex = /https?:\/\/[^\s$.?#].[^\s]*/gi;
+    var matches = [];
+    var regexResult;
+    while ((regexResult = regex.exec(string)) !== null) {
+      if (regexResult != null) {
+        matches.push({
+          lowerBound: regexResult.index,
+          upperBound: regex.lastIndex
+        });
+      }
+    }
+    return matches;
+  }
+  function TappableLinks(props) {
+    var _this = this;
+    var matches = getLinkRanges(props.content);
+    if (matches.length === 0) {
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+        style: props.style,
+        children: props.content
+      });
+    }
+    var fragments = [];
+    var indexCounter = 0;
+    var startIndex = 0;
+    var _loop = function _loop() {
+      if (startIndex < linkRange.lowerBound) {
+        var _text = props.content.substring(startIndex, linkRange.lowerBound);
+        fragments.push(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+          children: _text
+        }, ++indexCounter));
+      }
+      var link = props.content.substring(linkRange.lowerBound, linkRange.upperBound);
+      fragments.push(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+        onPress: function onPress() {
+          _Linking.default.openURL(link);
+        },
+        style: styles.linkText,
+        children: link
+      }, ++indexCounter));
+      startIndex = linkRange.upperBound;
+    };
+    for (var linkRange of matches) {
+      _loop();
+    }
+    if (startIndex < props.content.length) {
+      var text = props.content.substring(startIndex);
+      fragments.push(/*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+        style: props.style,
+        children: text
+      }, ++indexCounter));
+    }
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+      style: props.style,
+      children: fragments
+    });
+  }
+  var cleanContent = function cleanContent(content) {
+    return content.replace(/^(TransformError |Warning: (Warning: )?|Error: )/g, '');
+  };
+  function LogBoxMessage(props) {
+    var _this2 = this;
+    var _props$message = props.message,
+      content = _props$message.content,
+      substitutions = _props$message.substitutions;
+    if (props.plaintext === true) {
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+        children: cleanContent(content)
+      });
+    }
+    var maxLength = props.maxLength != null ? props.maxLength : Infinity;
+    var substitutionStyle = props.style;
+    var elements = [];
+    var length = 0;
+    var createUnderLength = function createUnderLength(key, message, style) {
+      var cleanMessage = cleanContent(message);
+      if (props.maxLength != null) {
+        cleanMessage = cleanMessage.slice(0, props.maxLength - length);
+      }
+      if (length < maxLength) {
+        elements.push(/*#__PURE__*/(0, _jsxRuntime.jsx)(TappableLinks, {
+          content: cleanMessage,
+          style: style
+        }, key));
+      }
+      length += cleanMessage.length;
+    };
+    var lastOffset = substitutions.reduce(function (prevOffset, substitution, index) {
+      var key = String(index);
+      if (substitution.offset > prevOffset) {
+        var prevPart = content.slice(prevOffset, substitution.offset);
+        createUnderLength(key, prevPart);
+      }
+      var substitutionPart = content.slice(substitution.offset, substitution.offset + substitution.length);
+      createUnderLength(key + '.5', substitutionPart, substitutionStyle);
+      return substitution.offset + substitution.length;
+    }, 0);
+    if (lastOffset < content.length) {
+      var lastPart = content.slice(lastOffset);
+      createUnderLength('-1', lastPart);
+    }
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_jsxRuntime.Fragment, {
+      children: elements
+    });
+  }
+  var styles = _StyleSheet.default.create({
+    linkText: {
+      textDecorationLine: 'underline'
+    }
+  });
+  var _default = exports.default = LogBoxMessage;
+},369,[1,370,6,352,73,171],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxMessage.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var _NativeEventEmitter2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../EventEmitter/NativeEventEmitter"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../Utilities/Platform"));
+  var _NativeIntentAndroid = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./NativeIntentAndroid"));
+  var _NativeLinkingManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./NativeLinkingManager"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "invariant"));
+  var _nullthrows = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "nullthrows"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var LinkingImpl = /*#__PURE__*/function (_NativeEventEmitter) {
+    function LinkingImpl() {
+      (0, _classCallCheck2.default)(this, LinkingImpl);
+      return _callSuper(this, LinkingImpl, [_Platform.default.OS === 'ios' ? (0, _nullthrows.default)(_NativeLinkingManager.default) : undefined]);
+    }
+    (0, _inherits2.default)(LinkingImpl, _NativeEventEmitter);
+    return (0, _createClass2.default)(LinkingImpl, [{
+      key: "addEventListener",
+      value: function addEventListener(eventType, listener) {
+        return this.addListener(eventType, listener);
+      }
+    }, {
+      key: "openURL",
+      value: function openURL(url) {
+        this._validateURL(url);
+        if (_Platform.default.OS === 'android') {
+          return (0, _nullthrows.default)(_NativeIntentAndroid.default).openURL(url);
+        } else {
+          return (0, _nullthrows.default)(_NativeLinkingManager.default).openURL(url);
+        }
+      }
+    }, {
+      key: "canOpenURL",
+      value: function canOpenURL(url) {
+        this._validateURL(url);
+        if (_Platform.default.OS === 'android') {
+          return (0, _nullthrows.default)(_NativeIntentAndroid.default).canOpenURL(url);
+        } else {
+          return (0, _nullthrows.default)(_NativeLinkingManager.default).canOpenURL(url);
+        }
+      }
+    }, {
+      key: "openSettings",
+      value: function openSettings() {
+        if (_Platform.default.OS === 'android') {
+          return (0, _nullthrows.default)(_NativeIntentAndroid.default).openSettings();
+        } else {
+          return (0, _nullthrows.default)(_NativeLinkingManager.default).openSettings();
+        }
+      }
+    }, {
+      key: "getInitialURL",
+      value: function getInitialURL() {
+        return _Platform.default.OS === 'android' ? (0, _nullthrows.default)(_NativeIntentAndroid.default).getInitialURL() : (0, _nullthrows.default)(_NativeLinkingManager.default).getInitialURL();
+      }
+    }, {
+      key: "sendIntent",
+      value: function sendIntent(action, extras) {
+        if (_Platform.default.OS === 'android') {
+          return (0, _nullthrows.default)(_NativeIntentAndroid.default).sendIntent(action, extras);
+        } else {
+          return new Promise(function (resolve, reject) {
+            return reject(new Error('Unsupported'));
+          });
+        }
+      }
+    }, {
+      key: "_validateURL",
+      value: function _validateURL(url) {
+        (0, _invariant.default)(typeof url === 'string', 'Invalid URL: should be a string. Was: ' + url);
+        (0, _invariant.default)(url, 'Invalid URL: cannot be empty');
+      }
+    }]);
+  }(_NativeEventEmitter2.default);
+  var Linking = new LinkingImpl();
+  var _default = exports.default = Linking;
+},370,[1,11,12,18,20,23,221,68,371,373,32,80],"../../node_modules/react-native/Libraries/Linking/Linking.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeIntentAndroid = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativeIntentAndroid"));
+  Object.keys(_NativeIntentAndroid).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeIntentAndroid[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeIntentAndroid[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeIntentAndroid.default;
+},371,[372],"../../node_modules/react-native/Libraries/Linking/NativeIntentAndroid.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.get('IntentAndroid');
+},372,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeIntentAndroid.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeLinkingManager = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativeLinkingManager"));
+  Object.keys(_NativeLinkingManager).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeLinkingManager[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeLinkingManager[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeLinkingManager.default;
+},373,[374],"../../node_modules/react-native/Libraries/Linking/NativeLinkingManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.get('LinkingManager');
+},374,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeLinkingManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _SafeAreaView_INTERNAL_DO_NOT_USE = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../../components/safeareaview/SafeAreaView_INTERNAL_DO_NOT_USE"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[3], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[4], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/src/private/devsupport/devmenu/elementinspector/Inspector.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var useState = React.useState;
+  function Inspector(_ref) {
+    var inspectedViewRef = _ref.inspectedViewRef,
+      onRequestRerenderApp = _ref.onRequestRerenderApp,
+      reactDevToolsAgent = _ref.reactDevToolsAgent;
+    var _useState = useState('elements-inspector'),
+      _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+      selectedTab = _useState2[0],
+      setSelectedTab = _useState2[1];
+    var _useState3 = useState('bottom'),
+      _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
+      panelPosition = _useState4[0],
+      setPanelPosition = _useState4[1];
+    var _useState5 = useState(null),
+      _useState6 = (0, _slicedToArray2.default)(_useState5, 2),
+      inspectedElement = _useState6[0],
+      setInspectedElement = _useState6[1];
+    var _useState7 = useState(null),
+      _useState8 = (0, _slicedToArray2.default)(_useState7, 2),
+      selectionIndex = _useState8[0],
+      setSelectionIndex = _useState8[1];
+    var _useState9 = useState(null),
+      _useState0 = (0, _slicedToArray2.default)(_useState9, 2),
+      elementsHierarchy = _useState0[0],
+      setElementsHierarchy = _useState0[1];
+    var setSelection = function setSelection(i) {
+      var hierarchyItem = elementsHierarchy == null ? void 0 : elementsHierarchy[i];
+      if (hierarchyItem == null) {
+        return;
+      }
+      var _hierarchyItem$getIns = hierarchyItem.getInspectorData(_$$_REQUIRE(_dependencyMap[5], "../../../../../Libraries/ReactNative/RendererProxy").findNodeHandle),
+        measure = _hierarchyItem$getIns.measure,
+        props = _hierarchyItem$getIns.props;
+      measure(function (x, y, width, height, left, top) {
+        setInspectedElement({
+          frame: {
+            left: left,
+            top: top,
+            width: width,
+            height: height
+          },
+          style: props.style
+        });
+        setSelectionIndex(i);
+      });
+    };
+    var onTouchPoint = function onTouchPoint(locationX, locationY) {
+      var setTouchedViewData = function setTouchedViewData(viewData) {
+        var hierarchy = viewData.hierarchy,
+          props = viewData.props,
+          selectedIndex = viewData.selectedIndex,
+          frame = viewData.frame,
+          pointerY = viewData.pointerY,
+          touchedViewTag = viewData.touchedViewTag,
+          closestInstance = viewData.closestInstance;
+        if (reactDevToolsAgent) {
+          reactDevToolsAgent.selectNode(_$$_REQUIRE(_dependencyMap[5], "../../../../../Libraries/ReactNative/RendererProxy").findNodeHandle(touchedViewTag));
+          if (closestInstance != null) {
+            reactDevToolsAgent.selectNode(closestInstance);
+          }
+        }
+        setPanelPosition(pointerY > _$$_REQUIRE(_dependencyMap[6], "../../../../../Libraries/Utilities/Dimensions").default.get('window').height / 2 ? 'top' : 'bottom');
+        setSelectionIndex(selectedIndex);
+        setElementsHierarchy(hierarchy);
+        setInspectedElement({
+          frame: frame,
+          style: props.style
+        });
+      };
+      _$$_REQUIRE(_dependencyMap[7], "./getInspectorDataForViewAtPoint").default(inspectedViewRef.current, locationX, locationY, function (viewData) {
+        setTouchedViewData(viewData);
+        return false;
+      });
+    };
+    var setInspecting = function setInspecting(enabled) {
+      setSelectedTab(enabled ? 'elements-inspector' : null);
+      setInspectedElement(null);
+    };
+    var setPerfing = function setPerfing(enabled) {
+      setSelectedTab(enabled ? 'performance-profiling' : null);
+      setInspectedElement(null);
+    };
+    var setNetworking = function setNetworking(enabled) {
+      setSelectedTab(enabled ? 'network-profiling' : null);
+      setInspectedElement(null);
+    };
+    var setTouchTargeting = function setTouchTargeting(val) {
+      _$$_REQUIRE(_dependencyMap[8], "../../../../../Libraries/Pressability/PressabilityDebug").setEnabled(val);
+      onRequestRerenderApp();
+    };
+    var panelContainerStyle = panelPosition === 'bottom' ? {
+      bottom: 0
+    } : {
+      top: 0
+    };
+    return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_$$_REQUIRE(_dependencyMap[9], "../../../../../Libraries/Components/View/View").default, {
+      style: styles.container,
+      pointerEvents: "box-none",
+      children: [selectedTab === 'elements-inspector' && /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[10], "./InspectorOverlay").default, {
+        inspected: inspectedElement,
+        onTouchPoint: onTouchPoint
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_SafeAreaView_INTERNAL_DO_NOT_USE.default, {
+        style: [styles.panelContainer, panelContainerStyle],
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[11], "./InspectorPanel").default, {
+          devtoolsIsOpen: !!reactDevToolsAgent,
+          inspecting: selectedTab === 'elements-inspector',
+          perfing: selectedTab === 'performance-profiling',
+          setPerfing: setPerfing,
+          setInspecting: setInspecting,
+          inspected: inspectedElement,
+          hierarchy: elementsHierarchy,
+          selection: selectionIndex,
+          setSelection: setSelection,
+          touchTargeting: _$$_REQUIRE(_dependencyMap[8], "../../../../../Libraries/Pressability/PressabilityDebug").isEnabled(),
+          setTouchTargeting: setTouchTargeting,
+          networking: selectedTab === 'network-profiling',
+          setNetworking: setNetworking
+        })
+      })]
+    });
+  }
+  var styles = _$$_REQUIRE(_dependencyMap[12], "../../../../../Libraries/StyleSheet/StyleSheet").default.create({
+    container: {
+      position: 'absolute',
+      backgroundColor: 'transparent',
+      top: 0,
+      left: 0,
+      right: 0,
+      bottom: 0
+    },
+    panelContainer: {
+      position: 'absolute',
+      left: 0,
+      right: 0
+    }
+  });
+  var _default = exports.default = Inspector;
+},375,[1,34,335,73,171,106,16,376,349,71,377,384,6],"../../node_modules/react-native/src/private/devsupport/devmenu/elementinspector/Inspector.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var reactDevToolsHook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+  _$$_REQUIRE(_dependencyMap[0], "invariant")(Boolean(reactDevToolsHook), 'getInspectorDataForViewAtPoint should not be used if React DevTools hook is not injected');
+  var renderers = Array.from(window.__REACT_DEVTOOLS_GLOBAL_HOOK__.renderers.values());
+  var appendRenderer = function appendRenderer(_ref) {
+    var renderer = _ref.renderer;
+    return renderers.push(renderer);
+  };
+  reactDevToolsHook.on('renderer', appendRenderer);
+  function validateRenderers() {
+    _$$_REQUIRE(_dependencyMap[0], "invariant")(renderers.length > 0, 'Expected to find at least one React Native renderer on DevTools hook.');
+  }
+  function getInspectorDataForViewAtPoint(inspectedView, locationX, locationY, callback) {
+    validateRenderers();
+    var shouldBreak = false;
+    for (var renderer of renderers) {
+      var _renderer$rendererCon;
+      if (shouldBreak) {
+        break;
+      }
+      if ((renderer == null || (_renderer$rendererCon = renderer.rendererConfig) == null ? void 0 : _renderer$rendererCon.getInspectorDataForViewAtPoint) != null) {
+        renderer.rendererConfig.getInspectorDataForViewAtPoint(inspectedView, locationX, locationY, function (viewData) {
+          if (viewData && viewData.hierarchy.length > 0) {
+            shouldBreak = callback(viewData);
+          }
+        });
+      }
+    }
+  }
+  var _default = exports.default = getInspectorDataForViewAtPoint;
+},376,[32],"../../node_modules/react-native/src/private/devsupport/devmenu/elementinspector/getInspectorDataForViewAtPoint.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[1], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/src/private/devsupport/devmenu/elementinspector/InspectorOverlay.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function InspectorOverlay(_ref) {
+    var inspected = _ref.inspected,
+      onTouchPoint = _ref.onTouchPoint;
+    var findViewForTouchEvent = function findViewForTouchEvent(e) {
+      var _e$nativeEvent$touche = e.nativeEvent.touches[0],
+        locationX = _e$nativeEvent$touche.locationX,
+        locationY = _e$nativeEvent$touche.locationY;
+      onTouchPoint(locationX, locationY);
+    };
+    var handleStartShouldSetResponder = function handleStartShouldSetResponder(e) {
+      findViewForTouchEvent(e);
+      return true;
+    };
+    var content = null;
+    if (inspected) {
+      content = /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[2], "./ElementBox").default, {
+        frame: inspected.frame,
+        style: inspected.style
+      });
+    }
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[3], "../../../../../Libraries/Components/View/View").default, {
+      onStartShouldSetResponder: handleStartShouldSetResponder,
+      onResponderMove: findViewForTouchEvent,
+      nativeID: "inspectorOverlay",
+      style: styles.inspector,
+      children: content
+    });
+  }
+  var styles = _$$_REQUIRE(_dependencyMap[4], "../../../../../Libraries/StyleSheet/StyleSheet").default.create({
+    inspector: {
+      backgroundColor: 'transparent',
+      position: 'absolute',
+      left: 0,
+      top: 0,
+      right: 0,
+      bottom: 0
+    }
+  });
+  var _default = exports.default = InspectorOverlay;
+},377,[73,171,378,71,6],"../../node_modules/react-native/src/private/devsupport/devmenu/elementinspector/InspectorOverlay.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[1], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/src/private/devsupport/devmenu/elementinspector/ElementBox.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function ElementBox(_ref) {
+    var frame = _ref.frame,
+      style = _ref.style;
+    var flattenedStyle = _$$_REQUIRE(_dependencyMap[2], "../../../../../Libraries/StyleSheet/flattenStyle").default(style) || {};
+    var margin = _$$_REQUIRE(_dependencyMap[3], "./resolveBoxStyle").default('margin', flattenedStyle);
+    var padding = _$$_REQUIRE(_dependencyMap[3], "./resolveBoxStyle").default('padding', flattenedStyle);
+    var frameStyle = Object.assign({}, frame);
+    var contentStyle = {
+      width: frame.width,
+      height: frame.height
+    };
+    if (margin != null) {
+      margin = resolveRelativeSizes(margin);
+      frameStyle.top -= margin.top;
+      frameStyle.left -= margin.left;
+      frameStyle.height += margin.top + margin.bottom;
+      frameStyle.width += margin.left + margin.right;
+      if (margin.top < 0) {
+        contentStyle.height += margin.top;
+      }
+      if (margin.bottom < 0) {
+        contentStyle.height += margin.bottom;
+      }
+      if (margin.left < 0) {
+        contentStyle.width += margin.left;
+      }
+      if (margin.right < 0) {
+        contentStyle.width += margin.right;
+      }
+    }
+    if (padding != null) {
+      padding = resolveRelativeSizes(padding);
+      contentStyle.width -= padding.left + padding.right;
+      contentStyle.height -= padding.top + padding.bottom;
+    }
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[4], "../../../../../Libraries/Components/View/View").default, {
+      style: [styles.frame, frameStyle],
+      pointerEvents: "none",
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[5], "./BorderBox").default, {
+        box: margin,
+        style: styles.margin,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[5], "./BorderBox").default, {
+          box: padding,
+          style: styles.padding,
+          children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[4], "../../../../../Libraries/Components/View/View").default, {
+            style: [styles.content, contentStyle]
+          })
+        })
+      })
+    });
+  }
+  var styles = _$$_REQUIRE(_dependencyMap[6], "../../../../../Libraries/StyleSheet/StyleSheet").default.create({
+    frame: {
+      position: 'absolute'
+    },
+    content: {
+      backgroundColor: 'rgba(200, 230, 255, 0.8)'
+    },
+    padding: {
+      borderColor: 'rgba(77, 255, 0, 0.3)'
+    },
+    margin: {
+      borderColor: 'rgba(255, 132, 0, 0.3)'
+    }
+  });
+  function resolveRelativeSizes(style) {
+    var resolvedStyle = Object.assign({}, style);
+    resolveSizeInPlace(resolvedStyle, 'top', 'height');
+    resolveSizeInPlace(resolvedStyle, 'right', 'width');
+    resolveSizeInPlace(resolvedStyle, 'bottom', 'height');
+    resolveSizeInPlace(resolvedStyle, 'left', 'width');
+    return resolvedStyle;
+  }
+  function resolveSizeInPlace(style, direction, dimension) {
+    if (style[direction] !== null && typeof style[direction] === 'string') {
+      if (style[direction].indexOf('%') !== -1) {
+        style[direction] = parseFloat(style[direction]) / 100.0 * _$$_REQUIRE(_dependencyMap[7], "../../../../../Libraries/Utilities/Dimensions").default.get('window')[dimension];
+      }
+      if (style[direction] === 'auto') {
+        style[direction] = 0;
+      }
+    }
+  }
+  var _default = exports.default = ElementBox;
+},378,[73,171,9,379,71,383,6,16],"../../node_modules/react-native/src/private/devsupport/devmenu/elementinspector/ElementBox.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  function resolveBoxStyle(prefix, style) {
+    var hasParts = false;
+    var result = {
+      bottom: 0,
+      left: 0,
+      right: 0,
+      top: 0
+    };
+    var styleForAll = style[prefix];
+    if (styleForAll != null) {
+      for (var key of Object.keys(result)) {
+        result[key] = styleForAll;
+      }
+      hasParts = true;
+    }
+    var styleForHorizontal = style[prefix + 'Horizontal'];
+    if (styleForHorizontal != null) {
+      result.left = styleForHorizontal;
+      result.right = styleForHorizontal;
+      hasParts = true;
+    } else {
+      var styleForLeft = style[prefix + 'Left'];
+      if (styleForLeft != null) {
+        result.left = styleForLeft;
+        hasParts = true;
+      }
+      var styleForRight = style[prefix + 'Right'];
+      if (styleForRight != null) {
+        result.right = styleForRight;
+        hasParts = true;
+      }
+      var styleForEnd = style[prefix + 'End'];
+      if (styleForEnd != null) {
+        var constants = _$$_REQUIRE(_dependencyMap[0], "../../../../../Libraries/ReactNative/I18nManager").default.getConstants();
+        if (constants.isRTL && constants.doLeftAndRightSwapInRTL) {
+          result.left = styleForEnd;
+        } else {
+          result.right = styleForEnd;
+        }
+        hasParts = true;
+      }
+      var styleForStart = style[prefix + 'Start'];
+      if (styleForStart != null) {
+        var _constants = _$$_REQUIRE(_dependencyMap[0], "../../../../../Libraries/ReactNative/I18nManager").default.getConstants();
+        if (_constants.isRTL && _constants.doLeftAndRightSwapInRTL) {
+          result.right = styleForStart;
+        } else {
+          result.left = styleForStart;
+        }
+        hasParts = true;
+      }
+    }
+    var styleForVertical = style[prefix + 'Vertical'];
+    if (styleForVertical != null) {
+      result.bottom = styleForVertical;
+      result.top = styleForVertical;
+      hasParts = true;
+    } else {
+      var styleForBottom = style[prefix + 'Bottom'];
+      if (styleForBottom != null) {
+        result.bottom = styleForBottom;
+        hasParts = true;
+      }
+      var styleForTop = style[prefix + 'Top'];
+      if (styleForTop != null) {
+        result.top = styleForTop;
+        hasParts = true;
+      }
+    }
+    return hasParts ? result : null;
+  }
+  var _default = exports.default = resolveBoxStyle;
+},379,[380],"../../node_modules/react-native/src/private/devsupport/devmenu/elementinspector/resolveBoxStyle.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _NativeI18nManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativeI18nManager"));
+  var i18nConstants = getI18nManagerConstants();
+  function getI18nManagerConstants() {
+    if (_NativeI18nManager.default) {
+      var _NativeI18nManager$ge = _NativeI18nManager.default.getConstants(),
+        isRTL = _NativeI18nManager$ge.isRTL,
+        doLeftAndRightSwapInRTL = _NativeI18nManager$ge.doLeftAndRightSwapInRTL,
+        localeIdentifier = _NativeI18nManager$ge.localeIdentifier;
+      return {
+        isRTL: isRTL,
+        doLeftAndRightSwapInRTL: doLeftAndRightSwapInRTL,
+        localeIdentifier: localeIdentifier
+      };
+    }
+    return {
+      isRTL: false,
+      doLeftAndRightSwapInRTL: true
+    };
+  }
+  var _default = exports.default = {
+    getConstants: function getConstants() {
+      return i18nConstants;
+    },
+    allowRTL: function allowRTL(shouldAllow) {
+      if (!_NativeI18nManager.default) {
+        return;
+      }
+      _NativeI18nManager.default.allowRTL(shouldAllow);
+    },
+    forceRTL: function forceRTL(shouldForce) {
+      if (!_NativeI18nManager.default) {
+        return;
+      }
+      _NativeI18nManager.default.forceRTL(shouldForce);
+    },
+    swapLeftAndRightInRTL: function swapLeftAndRightInRTL(flipStyles) {
+      if (!_NativeI18nManager.default) {
+        return;
+      }
+      _NativeI18nManager.default.swapLeftAndRightInRTL(flipStyles);
+    },
+    isRTL: i18nConstants.isRTL,
+    doLeftAndRightSwapInRTL: i18nConstants.doLeftAndRightSwapInRTL
+  };
+},380,[1,381],"../../node_modules/react-native/Libraries/ReactNative/I18nManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeI18nManager = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativeI18nManager"));
+  Object.keys(_NativeI18nManager).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeI18nManager[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeI18nManager[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeI18nManager.default;
+},381,[382],"../../node_modules/react-native/Libraries/ReactNative/NativeI18nManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.get('I18nManager');
+},382,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeI18nManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[1], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/src/private/devsupport/devmenu/elementinspector/BorderBox.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function BorderBox(_ref) {
+    var children = _ref.children,
+      box = _ref.box,
+      style = _ref.style;
+    if (!box) {
+      return children;
+    }
+    var borderStyle = {
+      borderTopWidth: box.top,
+      borderBottomWidth: box.bottom,
+      borderLeftWidth: box.left,
+      borderRightWidth: box.right
+    };
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[2], "../../../../../Libraries/Components/View/View").default, {
+      style: [borderStyle, style],
+      children: children
+    });
+  }
+  var _default = exports.default = BorderBox;
+},383,[73,171,71],"../../node_modules/react-native/src/private/devsupport/devmenu/elementinspector/BorderBox.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var _SafeAreaView = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../../../../../Libraries/Components/SafeAreaView/SafeAreaView"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[8], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/src/private/devsupport/devmenu/elementinspector/InspectorPanel.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var InspectorPanel = /*#__PURE__*/function (_React$Component) {
+    function InspectorPanel() {
+      (0, _classCallCheck2.default)(this, InspectorPanel);
+      return _callSuper(this, InspectorPanel, arguments);
+    }
+    (0, _inherits2.default)(InspectorPanel, _React$Component);
+    return (0, _createClass2.default)(InspectorPanel, [{
+      key: "renderWaiting",
+      value: function renderWaiting() {
+        if (this.props.inspecting) {
+          return /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[9], "../../../../../Libraries/Text/Text").default, {
+            style: styles.waitingText,
+            children: "Tap something to inspect it"
+          });
+        }
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[9], "../../../../../Libraries/Text/Text").default, {
+          style: styles.waitingText,
+          children: "Nothing is inspected"
+        });
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var contents;
+        if (this.props.inspected) {
+          contents = /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[10], "../../../../../Libraries/Components/ScrollView/ScrollView").default, {
+            style: styles.properties,
+            children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[11], "./ElementProperties").default, {
+              style: this.props.inspected.style,
+              frame: this.props.inspected.frame,
+              hierarchy: this.props.hierarchy,
+              selection: this.props.selection,
+              setSelection: this.props.setSelection
+            })
+          });
+        } else if (this.props.perfing) {
+          contents = /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[12], "../perfmonitor/PerformanceOverlay").default, {});
+        } else if (this.props.networking) {
+          contents = /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[13], "./NetworkOverlay").default, {});
+        } else {
+          contents = /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[14], "../../../../../Libraries/Components/View/View").default, {
+            style: styles.waiting,
+            children: this.renderWaiting()
+          });
+        }
+        return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_SafeAreaView.default, {
+          style: styles.container,
+          children: [!this.props.devtoolsIsOpen && contents, /*#__PURE__*/(0, _jsxRuntime.jsxs)(_$$_REQUIRE(_dependencyMap[14], "../../../../../Libraries/Components/View/View").default, {
+            style: styles.buttonRow,
+            children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(InspectorPanelButton, {
+              title: 'Inspect',
+              pressed: this.props.inspecting,
+              onClick: this.props.setInspecting
+            }), global.RN$Bridgeless === true ? null : /*#__PURE__*/(0, _jsxRuntime.jsxs)(_jsxRuntime.Fragment, {
+              children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(InspectorPanelButton, {
+                title: 'Perf',
+                pressed: this.props.perfing,
+                onClick: this.props.setPerfing
+              }), /*#__PURE__*/(0, _jsxRuntime.jsx)(InspectorPanelButton, {
+                title: 'Network',
+                pressed: this.props.networking,
+                onClick: this.props.setNetworking
+              })]
+            }), /*#__PURE__*/(0, _jsxRuntime.jsx)(InspectorPanelButton, {
+              title: 'Touchables',
+              pressed: this.props.touchTargeting,
+              onClick: this.props.setTouchTargeting
+            })]
+          })]
+        });
+      }
+    }]);
+  }(React.Component);
+  var InspectorPanelButton = /*#__PURE__*/function (_React$Component2) {
+    function InspectorPanelButton() {
+      (0, _classCallCheck2.default)(this, InspectorPanelButton);
+      return _callSuper(this, InspectorPanelButton, arguments);
+    }
+    (0, _inherits2.default)(InspectorPanelButton, _React$Component2);
+    return (0, _createClass2.default)(InspectorPanelButton, [{
+      key: "render",
+      value: function render() {
+        var _this = this;
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[15], "../../../../../Libraries/Components/Touchable/TouchableHighlight").default, {
+          onPress: function onPress() {
+            return _this.props.onClick(!_this.props.pressed);
+          },
+          style: [styles.button, this.props.pressed && styles.buttonPressed],
+          children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[9], "../../../../../Libraries/Text/Text").default, {
+            style: styles.buttonText,
+            children: this.props.title
+          })
+        });
+      }
+    }]);
+  }(React.Component);
+  var styles = _$$_REQUIRE(_dependencyMap[16], "../../../../../Libraries/StyleSheet/StyleSheet").default.create({
+    buttonRow: {
+      flexDirection: 'row'
+    },
+    button: {
+      backgroundColor: 'rgba(0, 0, 0, 0.3)',
+      margin: 2,
+      height: 30,
+      justifyContent: 'center',
+      alignItems: 'center'
+    },
+    buttonPressed: {
+      backgroundColor: 'rgba(255, 255, 255, 0.3)'
+    },
+    buttonText: {
+      textAlign: 'center',
+      color: 'white',
+      margin: 5
+    },
+    container: {
+      backgroundColor: 'rgba(0, 0, 0, 0.7)'
+    },
+    properties: {
+      height: 200
+    },
+    waiting: {
+      height: 100
+    },
+    waitingText: {
+      fontSize: 20,
+      textAlign: 'center',
+      marginVertical: 20,
+      color: 'white'
+    }
+  });
+  var _default = exports.default = InspectorPanel;
+},384,[1,11,12,18,20,23,385,73,171,352,387,481,486,487,71,483,6],"../../node_modules/react-native/src/private/devsupport/devmenu/elementinspector/InspectorPanel.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Utilities/Platform"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../View/View"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[3], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var exported = _Platform.default.select({
+    ios: _$$_REQUIRE(_dependencyMap[4], "./RCTSafeAreaViewNativeComponent").default,
+    default: _View.default
+  });
+  var _default = exports.default = exported;
+},385,[1,68,71,73,386],"../../node_modules/react-native/Libraries/Components/SafeAreaView/SafeAreaView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _RCTSafeAreaViewNativeComponent = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../src/private/specs_DEPRECATED/components/RCTSafeAreaViewNativeComponent"));
+  Object.keys(_RCTSafeAreaViewNativeComponent).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _RCTSafeAreaViewNativeComponent[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _RCTSafeAreaViewNativeComponent[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _RCTSafeAreaViewNativeComponent.default;
+},386,[336],"../../node_modules/react-native/Libraries/Components/SafeAreaView/RCTSafeAreaViewNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _AnimatedImplementation = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../../Animated/AnimatedImplementation"));
+  var _FrameRateLogger = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../../Interaction/FrameRateLogger"));
+  var _UIManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "../../ReactNative/UIManager"));
+  var _flattenStyle = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "../../StyleSheet/flattenStyle"));
+  var _splitLayoutProps2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "../../StyleSheet/splitLayoutProps"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "../../StyleSheet/StyleSheet"));
+  var _Dimensions = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[13], "../../Utilities/Dimensions"));
+  var _dismissKeyboard = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[14], "../../Utilities/dismissKeyboard"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[15], "../../Utilities/Platform"));
+  var _Keyboard = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[16], "../Keyboard/Keyboard"));
+  var _TextInputState = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[17], "../TextInput/TextInputState"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[18], "../View/View"));
+  var _processDecelerationRate = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[19], "./processDecelerationRate"));
+  var _ScrollViewCommands = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[20], "./ScrollViewCommands"));
+  var _ScrollViewContext = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[21], "./ScrollViewContext"));
+  var _ScrollViewStickyHeader = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[22], "./ScrollViewStickyHeader"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[23], "invariant"));
+  var _memoizeOne = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[24], "memoize-one"));
+  var _nullthrows = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[25], "nullthrows"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[26], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[27], "react/jsx-runtime");
+  var _excluded = ["experimental_endDraggingSensitivityMultiplier"];
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Components/ScrollView/ScrollView.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var IS_ANIMATING_TOUCH_START_THRESHOLD_MS = 16;
+  var ScrollView = /*#__PURE__*/function (_React$Component) {
+    function ScrollView(props) {
+      var _this$props$contentOf, _this$props$contentOf2, _this$props$contentIn, _this$props$contentIn2;
+      var _this;
+      (0, _classCallCheck2.default)(this, ScrollView);
+      _this = _callSuper(this, ScrollView, [props]);
+      _this._scrollAnimatedValueAttachment = null;
+      _this._stickyHeaderRefs = new Map();
+      _this._headerLayoutYs = new Map();
+      _this._keyboardMetrics = null;
+      _this._additionalScrollOffset = 0;
+      _this._isTouching = false;
+      _this._lastMomentumScrollBeginTime = 0;
+      _this._lastMomentumScrollEndTime = 0;
+      _this._observedScrollSinceBecomingResponder = false;
+      _this._becameResponderWhileAnimating = false;
+      _this._preventNegativeScrollOffset = null;
+      _this._animated = null;
+      _this._subscriptionKeyboardWillShow = null;
+      _this._subscriptionKeyboardWillHide = null;
+      _this._subscriptionKeyboardDidShow = null;
+      _this._subscriptionKeyboardDidHide = null;
+      _this.state = {
+        layoutHeight: null
+      };
+      _this.getScrollResponder = function () {
+        return _this;
+      };
+      _this.getScrollableNode = function () {
+        return (0, _$$_REQUIRE(_dependencyMap[28], "../../ReactNative/RendererProxy").findNodeHandle)(_this.getNativeScrollRef());
+      };
+      _this.getInnerViewNode = function () {
+        return (0, _$$_REQUIRE(_dependencyMap[28], "../../ReactNative/RendererProxy").findNodeHandle)(_this._innerView.nativeInstance);
+      };
+      _this.getInnerViewRef = function () {
+        return _this._innerView.nativeInstance;
+      };
+      _this.getNativeScrollRef = function () {
+        return _this._scrollView.nativeInstance;
+      };
+      _this.scrollTo = function (options, deprecatedX, deprecatedAnimated) {
+        var x, y, animated;
+        if (typeof options === 'number') {
+          console.warn('`scrollTo(y, x, animated)` is deprecated. Use `scrollTo({x: 5, y: 5, ' + 'animated: true})` instead.');
+          y = options;
+          x = deprecatedX;
+          animated = deprecatedAnimated;
+        } else if (options) {
+          y = options.y;
+          x = options.x;
+          animated = options.animated;
+        }
+        var component = _this.getNativeScrollRef();
+        if (component == null) {
+          return;
+        }
+        _ScrollViewCommands.default.scrollTo(component, x || 0, y || 0, animated !== false);
+      };
+      _this.scrollToEnd = function (options) {
+        var animated = (options && options.animated) !== false;
+        var component = _this.getNativeScrollRef();
+        if (component == null) {
+          return;
+        }
+        _ScrollViewCommands.default.scrollToEnd(component, animated);
+      };
+      _this.flashScrollIndicators = function () {
+        var component = _this.getNativeScrollRef();
+        if (component == null) {
+          return;
+        }
+        _ScrollViewCommands.default.flashScrollIndicators(component);
+      };
+      _this.scrollResponderScrollNativeHandleToKeyboard = function (nodeHandle, additionalOffset, preventNegativeScrollOffset) {
+        _this._additionalScrollOffset = additionalOffset || 0;
+        _this._preventNegativeScrollOffset = !!preventNegativeScrollOffset;
+        if (_this._innerView.nativeInstance == null) {
+          return;
+        }
+        if (typeof nodeHandle === 'number') {
+          _UIManager.default.measureLayout(nodeHandle, (0, _nullthrows.default)((0, _$$_REQUIRE(_dependencyMap[28], "../../ReactNative/RendererProxy").findNodeHandle)(_this)), _this._textInputFocusError, _this._inputMeasureAndScrollToKeyboard);
+        } else {
+          nodeHandle.measureLayout(_this._innerView.nativeInstance, _this._inputMeasureAndScrollToKeyboard, _this._textInputFocusError);
+        }
+      };
+      _this.scrollResponderZoomTo = function (rect, animated) {
+        (0, _invariant.default)(_Platform.default.OS === 'ios', 'zoomToRect is not implemented');
+        if ('animated' in rect) {
+          _this._animated = rect.animated;
+          delete rect.animated;
+        } else if (typeof animated !== 'undefined') {
+          console.warn('`scrollResponderZoomTo` `animated` argument is deprecated. Use `options.animated` instead');
+        }
+        var component = _this.getNativeScrollRef();
+        if (component == null) {
+          return;
+        }
+        _ScrollViewCommands.default.zoomToRect(component, rect, animated !== false);
+      };
+      _this._inputMeasureAndScrollToKeyboard = function (left, top, width, height) {
+        var keyboardScreenY = _Dimensions.default.get('window').height;
+        var scrollTextInputIntoVisibleRect = function scrollTextInputIntoVisibleRect() {
+          if (_this._keyboardMetrics != null) {
+            keyboardScreenY = _this._keyboardMetrics.screenY;
+          }
+          var scrollOffsetY = top - keyboardScreenY + height + _this._additionalScrollOffset;
+          if (_this._preventNegativeScrollOffset === true) {
+            scrollOffsetY = Math.max(0, scrollOffsetY);
+          }
+          _this.scrollTo({
+            x: 0,
+            y: scrollOffsetY,
+            animated: true
+          });
+          _this._additionalScrollOffset = 0;
+          _this._preventNegativeScrollOffset = false;
+        };
+        if (_this._keyboardMetrics == null) {
+          setTimeout(function () {
+            scrollTextInputIntoVisibleRect();
+          }, 0);
+        } else {
+          scrollTextInputIntoVisibleRect();
+        }
+      };
+      _this._handleScroll = function (e) {
+        _this._observedScrollSinceBecomingResponder = true;
+        _this.props.onScroll && _this.props.onScroll(e);
+      };
+      _this._handleLayout = function (e) {
+        if (_this.props.invertStickyHeaders === true) {
+          _this.setState({
+            layoutHeight: e.nativeEvent.layout.height
+          });
+        }
+        if (_this.props.onLayout) {
+          _this.props.onLayout(e);
+        }
+      };
+      _this._handleContentOnLayout = function (e) {
+        var _e$nativeEvent$layout = e.nativeEvent.layout,
+          width = _e$nativeEvent$layout.width,
+          height = _e$nativeEvent$layout.height;
+        _this.props.onContentSizeChange && _this.props.onContentSizeChange(width, height);
+      };
+      _this._innerView = createRefForwarder(function (instance) {
+        return instance;
+      });
+      _this._scrollView = createRefForwarder(function (nativeInstance) {
+        var publicInstance = Object.assign(nativeInstance, {
+          getScrollResponder: _this.getScrollResponder,
+          getScrollableNode: _this.getScrollableNode,
+          getInnerViewNode: _this.getInnerViewNode,
+          getInnerViewRef: _this.getInnerViewRef,
+          getNativeScrollRef: _this.getNativeScrollRef,
+          scrollTo: _this.scrollTo,
+          scrollToEnd: _this.scrollToEnd,
+          flashScrollIndicators: _this.flashScrollIndicators,
+          scrollResponderZoomTo: _this.scrollResponderZoomTo,
+          scrollResponderScrollNativeHandleToKeyboard: _this.scrollResponderScrollNativeHandleToKeyboard
+        });
+        return publicInstance;
+      });
+      _this.scrollResponderKeyboardWillShow = function (e) {
+        _this._keyboardMetrics = e.endCoordinates;
+        _this.props.onKeyboardWillShow && _this.props.onKeyboardWillShow(e);
+      };
+      _this.scrollResponderKeyboardWillHide = function (e) {
+        _this._keyboardMetrics = null;
+        _this.props.onKeyboardWillHide && _this.props.onKeyboardWillHide(e);
+      };
+      _this.scrollResponderKeyboardDidShow = function (e) {
+        _this._keyboardMetrics = e.endCoordinates;
+        _this.props.onKeyboardDidShow && _this.props.onKeyboardDidShow(e);
+      };
+      _this.scrollResponderKeyboardDidHide = function (e) {
+        _this._keyboardMetrics = null;
+        _this.props.onKeyboardDidHide && _this.props.onKeyboardDidHide(e);
+      };
+      _this._handleMomentumScrollBegin = function (e) {
+        _this._lastMomentumScrollBeginTime = global.performance.now();
+        _this.props.onMomentumScrollBegin && _this.props.onMomentumScrollBegin(e);
+      };
+      _this._handleMomentumScrollEnd = function (e) {
+        _FrameRateLogger.default.endScroll();
+        _this._lastMomentumScrollEndTime = global.performance.now();
+        _this.props.onMomentumScrollEnd && _this.props.onMomentumScrollEnd(e);
+      };
+      _this._handleScrollBeginDrag = function (e) {
+        _FrameRateLogger.default.beginScroll();
+        if (_Platform.default.OS === 'android' && _this.props.keyboardDismissMode === 'on-drag') {
+          (0, _dismissKeyboard.default)();
+        }
+        _this.props.onScrollBeginDrag && _this.props.onScrollBeginDrag(e);
+      };
+      _this._handleScrollEndDrag = function (e) {
+        var velocity = e.nativeEvent.velocity;
+        if (!_this._isAnimating() && (!velocity || velocity.x === 0 && velocity.y === 0)) {
+          _FrameRateLogger.default.endScroll();
+        }
+        _this.props.onScrollEndDrag && _this.props.onScrollEndDrag(e);
+      };
+      _this._isAnimating = function () {
+        var now = global.performance.now();
+        var timeSinceLastMomentumScrollEnd = now - _this._lastMomentumScrollEndTime;
+        var isAnimating = timeSinceLastMomentumScrollEnd < IS_ANIMATING_TOUCH_START_THRESHOLD_MS || _this._lastMomentumScrollEndTime < _this._lastMomentumScrollBeginTime;
+        return isAnimating;
+      };
+      _this._handleResponderGrant = function (e) {
+        _this._observedScrollSinceBecomingResponder = false;
+        _this.props.onResponderGrant && _this.props.onResponderGrant(e);
+        _this._becameResponderWhileAnimating = _this._isAnimating();
+      };
+      _this._handleResponderReject = function () {};
+      _this._handleResponderRelease = function (e) {
+        _this._isTouching = e.nativeEvent.touches.length !== 0;
+        _this.props.onResponderRelease && _this.props.onResponderRelease(e);
+        if (typeof e.target === 'number') {
+          if (__DEV__) {
+            console.error('Did not expect event target to be a number. Should have been a native component');
+          }
+          return;
+        }
+        var currentlyFocusedTextInput = _TextInputState.default.currentlyFocusedInput();
+        if (currentlyFocusedTextInput != null && _this.props.keyboardShouldPersistTaps !== true && _this.props.keyboardShouldPersistTaps !== 'always' && _this._keyboardIsDismissible() && e.target !== currentlyFocusedTextInput && !_this._observedScrollSinceBecomingResponder && !_this._becameResponderWhileAnimating) {
+          _TextInputState.default.blurTextInput(currentlyFocusedTextInput);
+        }
+      };
+      _this._handleResponderTerminationRequest = function () {
+        return !_this._observedScrollSinceBecomingResponder;
+      };
+      _this._handleScrollShouldSetResponder = function () {
+        if (_this.props.disableScrollViewPanResponder === true) {
+          return false;
+        }
+        return _this._isTouching;
+      };
+      _this._handleStartShouldSetResponder = function (e) {
+        if (_this.props.disableScrollViewPanResponder === true) {
+          return false;
+        }
+        var currentlyFocusedInput = _TextInputState.default.currentlyFocusedInput();
+        if (_this.props.keyboardShouldPersistTaps === 'handled' && _this._keyboardIsDismissible() && e.target !== currentlyFocusedInput) {
+          return true;
+        }
+        return false;
+      };
+      _this._handleStartShouldSetResponderCapture = function (e) {
+        if (_this._isAnimating()) {
+          return true;
+        }
+        if (_this.props.disableScrollViewPanResponder === true) {
+          return false;
+        }
+        var keyboardShouldPersistTaps = _this.props.keyboardShouldPersistTaps;
+        var keyboardNeverPersistTaps = !keyboardShouldPersistTaps || keyboardShouldPersistTaps === 'never';
+        if (typeof e.target === 'number') {
+          if (__DEV__) {
+            console.error('Did not expect event target to be a number. Should have been a native component');
+          }
+          return false;
+        }
+        if (_this._softKeyboardIsDetached()) {
+          return false;
+        }
+        if (keyboardNeverPersistTaps && _this._keyboardIsDismissible() && e.target != null && !_TextInputState.default.isTextInput(e.target)) {
+          return true;
+        }
+        return false;
+      };
+      _this._keyboardIsDismissible = function () {
+        var currentlyFocusedInput = _TextInputState.default.currentlyFocusedInput();
+        var hasFocusedTextInput = currentlyFocusedInput != null && _TextInputState.default.isTextInput(currentlyFocusedInput);
+        var softKeyboardMayBeOpen = _this._keyboardMetrics != null || _this._keyboardEventsAreUnreliable();
+        return hasFocusedTextInput && softKeyboardMayBeOpen;
+      };
+      _this._softKeyboardIsDetached = function () {
+        return _this._keyboardMetrics != null && _this._keyboardMetrics.height === 0;
+      };
+      _this._keyboardEventsAreUnreliable = function () {
+        return _Platform.default.OS === 'android' && _Platform.default.Version < 30;
+      };
+      _this._handleTouchEnd = function (e) {
+        var nativeEvent = e.nativeEvent;
+        _this._isTouching = nativeEvent.touches.length !== 0;
+        var keyboardShouldPersistTaps = _this.props.keyboardShouldPersistTaps;
+        var keyboardNeverPersistsTaps = !keyboardShouldPersistTaps || keyboardShouldPersistTaps === 'never';
+        var currentlyFocusedTextInput = _TextInputState.default.currentlyFocusedInput();
+        if (currentlyFocusedTextInput != null && e.target !== currentlyFocusedTextInput && _this._softKeyboardIsDetached() && _this._keyboardIsDismissible() && keyboardNeverPersistsTaps) {
+          _TextInputState.default.blurTextInput(currentlyFocusedTextInput);
+        }
+        _this.props.onTouchEnd && _this.props.onTouchEnd(e);
+      };
+      _this._handleTouchCancel = function (e) {
+        _this._isTouching = false;
+        _this.props.onTouchCancel && _this.props.onTouchCancel(e);
+      };
+      _this._handleTouchStart = function (e) {
+        _this._isTouching = true;
+        _this.props.onTouchStart && _this.props.onTouchStart(e);
+      };
+      _this._handleTouchMove = function (e) {
+        _this.props.onTouchMove && _this.props.onTouchMove(e);
+      };
+      _this._scrollAnimatedValue = new _AnimatedImplementation.default.Value((_this$props$contentOf = (_this$props$contentOf2 = _this.props.contentOffset) == null ? void 0 : _this$props$contentOf2.y) != null ? _this$props$contentOf : 0);
+      _this._scrollAnimatedValue.setOffset((_this$props$contentIn = (_this$props$contentIn2 = _this.props.contentInset) == null ? void 0 : _this$props$contentIn2.top) != null ? _this$props$contentIn : 0);
+      return _this;
+    }
+    (0, _inherits2.default)(ScrollView, _React$Component);
+    return (0, _createClass2.default)(ScrollView, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        if (typeof this.props.keyboardShouldPersistTaps === 'boolean') {
+          console.warn(`'keyboardShouldPersistTaps={${this.props.keyboardShouldPersistTaps === true ? 'true' : 'false'}}' is deprecated. ` + `Use 'keyboardShouldPersistTaps="${this.props.keyboardShouldPersistTaps ? 'always' : 'never'}"' instead`);
+        }
+        this._keyboardMetrics = _Keyboard.default.metrics();
+        this._additionalScrollOffset = 0;
+        this._subscriptionKeyboardWillShow = _Keyboard.default.addListener('keyboardWillShow', this.scrollResponderKeyboardWillShow);
+        this._subscriptionKeyboardWillHide = _Keyboard.default.addListener('keyboardWillHide', this.scrollResponderKeyboardWillHide);
+        this._subscriptionKeyboardDidShow = _Keyboard.default.addListener('keyboardDidShow', this.scrollResponderKeyboardDidShow);
+        this._subscriptionKeyboardDidHide = _Keyboard.default.addListener('keyboardDidHide', this.scrollResponderKeyboardDidHide);
+        this._updateAnimatedNodeAttachment();
+      }
+    }, {
+      key: "componentDidUpdate",
+      value: function componentDidUpdate(prevProps) {
+        var prevContentInsetTop = prevProps.contentInset ? prevProps.contentInset.top : 0;
+        var newContentInsetTop = this.props.contentInset ? this.props.contentInset.top : 0;
+        if (prevContentInsetTop !== newContentInsetTop) {
+          this._scrollAnimatedValue.setOffset(newContentInsetTop || 0);
+        }
+        this._updateAnimatedNodeAttachment();
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        if (this._subscriptionKeyboardWillShow != null) {
+          this._subscriptionKeyboardWillShow.remove();
+        }
+        if (this._subscriptionKeyboardWillHide != null) {
+          this._subscriptionKeyboardWillHide.remove();
+        }
+        if (this._subscriptionKeyboardDidShow != null) {
+          this._subscriptionKeyboardDidShow.remove();
+        }
+        if (this._subscriptionKeyboardDidHide != null) {
+          this._subscriptionKeyboardDidHide.remove();
+        }
+        if (this._scrollAnimatedValueAttachment) {
+          this._scrollAnimatedValueAttachment.detach();
+        }
+      }
+    }, {
+      key: "_textInputFocusError",
+      value: function _textInputFocusError() {
+        console.warn('Error measuring text field.');
+      }
+    }, {
+      key: "_getKeyForIndex",
+      value: function _getKeyForIndex(index, childArray) {
+        var child = childArray[index];
+        return child && child.key;
+      }
+    }, {
+      key: "_updateAnimatedNodeAttachment",
+      value: function _updateAnimatedNodeAttachment() {
+        if (this._scrollAnimatedValueAttachment) {
+          this._scrollAnimatedValueAttachment.detach();
+        }
+        if (this.props.stickyHeaderIndices && this.props.stickyHeaderIndices.length > 0) {
+          this._scrollAnimatedValueAttachment = _AnimatedImplementation.default.attachNativeEvent(this.getNativeScrollRef(), 'onScroll', [{
+            nativeEvent: {
+              contentOffset: {
+                y: this._scrollAnimatedValue
+              }
+            }
+          }]);
+        }
+      }
+    }, {
+      key: "_setStickyHeaderRef",
+      value: function _setStickyHeaderRef(key, ref) {
+        if (ref) {
+          this._stickyHeaderRefs.set(key, ref);
+        } else {
+          this._stickyHeaderRefs.delete(key);
+        }
+      }
+    }, {
+      key: "_onStickyHeaderLayout",
+      value: function _onStickyHeaderLayout(index, event, key) {
+        var stickyHeaderIndices = this.props.stickyHeaderIndices;
+        if (!stickyHeaderIndices) {
+          return;
+        }
+        var childArray = React.Children.toArray(this.props.children);
+        if (key !== this._getKeyForIndex(index, childArray)) {
+          return;
+        }
+        var layoutY = event.nativeEvent.layout.y;
+        this._headerLayoutYs.set(key, layoutY);
+        var indexOfIndex = stickyHeaderIndices.indexOf(index);
+        var previousHeaderIndex = stickyHeaderIndices[indexOfIndex - 1];
+        if (previousHeaderIndex != null) {
+          var previousHeader = this._stickyHeaderRefs.get(this._getKeyForIndex(previousHeaderIndex, childArray));
+          previousHeader && previousHeader.setNextHeaderY && previousHeader.setNextHeaderY(layoutY);
+        }
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this2 = this;
+        var horizontal = this.props.horizontal === true;
+        var NativeScrollView = horizontal ? _$$_REQUIRE(_dependencyMap[29], "../../../src/private/components/scrollview/HScrollViewNativeComponents").HScrollViewNativeComponent : _$$_REQUIRE(_dependencyMap[30], "../../../src/private/components/scrollview/VScrollViewNativeComponents").VScrollViewNativeComponent;
+        var NativeScrollContentView = horizontal ? _$$_REQUIRE(_dependencyMap[29], "../../../src/private/components/scrollview/HScrollViewNativeComponents").HScrollContentViewNativeComponent : _$$_REQUIRE(_dependencyMap[30], "../../../src/private/components/scrollview/VScrollViewNativeComponents").VScrollContentViewNativeComponent;
+        var contentContainerStyle = [horizontal && styles.contentContainerHorizontal, this.props.contentContainerStyle];
+        if (__DEV__ && this.props.style !== undefined) {
+          var style = (0, _flattenStyle.default)(this.props.style);
+          var childLayoutProps = ['alignItems', 'justifyContent'].filter(function (prop) {
+            return style && style[prop] !== undefined;
+          });
+          (0, _invariant.default)(childLayoutProps.length === 0, 'ScrollView child layout (' + JSON.stringify(childLayoutProps) + ') must be applied through the contentContainerStyle prop.');
+        }
+        var contentSizeChangeProps = this.props.onContentSizeChange == null ? null : {
+          onLayout: this._handleContentOnLayout
+        };
+        var stickyHeaderIndices = this.props.stickyHeaderIndices;
+        var children = this.props.children;
+        children = React.Children.toArray(children);
+        if (stickyHeaderIndices != null && stickyHeaderIndices.length > 0) {
+          children = children.map(function (child, index) {
+            var indexOfIndex = child ? stickyHeaderIndices.indexOf(index) : -1;
+            if (indexOfIndex > -1) {
+              var key = child.key;
+              var nextIndex = stickyHeaderIndices[indexOfIndex + 1];
+              var StickyHeaderComponent = _this2.props.StickyHeaderComponent || _ScrollViewStickyHeader.default;
+              return /*#__PURE__*/(0, _jsxRuntime.jsx)(StickyHeaderComponent, {
+                ref: function ref(_ref) {
+                  return _this2._setStickyHeaderRef(key, _ref);
+                },
+                nextHeaderLayoutY: _this2._headerLayoutYs.get(_this2._getKeyForIndex(nextIndex, children)),
+                onLayout: function onLayout(event) {
+                  return _this2._onStickyHeaderLayout(index, event, key);
+                },
+                scrollAnimatedValue: _this2._scrollAnimatedValue,
+                inverted: _this2.props.invertStickyHeaders,
+                hiddenOnScroll: _this2.props.stickyHeaderHiddenOnScroll,
+                scrollViewHeight: _this2.state.layoutHeight,
+                children: child
+              }, key);
+            } else {
+              return child;
+            }
+          });
+        }
+        children = /*#__PURE__*/(0, _jsxRuntime.jsx)(_ScrollViewContext.default.Provider, {
+          value: horizontal ? _ScrollViewContext.HORIZONTAL : _ScrollViewContext.VERTICAL,
+          children: children
+        });
+        var hasStickyHeaders = Array.isArray(stickyHeaderIndices) && stickyHeaderIndices.length > 0;
+        var preserveChildren = this.props.maintainVisibleContentPosition != null || _Platform.default.OS === 'android' && this.props.snapToAlignment != null;
+        var contentContainer = /*#__PURE__*/(0, _jsxRuntime.jsx)(NativeScrollContentView, Object.assign({}, contentSizeChangeProps, {
+          ref: this._innerView.getForwardingRef(this.props.innerViewRef),
+          style: contentContainerStyle,
+          removeClippedSubviews: _Platform.default.OS === 'android' && hasStickyHeaders ? false : this.props.removeClippedSubviews,
+          collapsable: false,
+          collapsableChildren: !preserveChildren,
+          children: children
+        }));
+        var alwaysBounceHorizontal = this.props.alwaysBounceHorizontal !== undefined ? this.props.alwaysBounceHorizontal : this.props.horizontal;
+        var alwaysBounceVertical = this.props.alwaysBounceVertical !== undefined ? this.props.alwaysBounceVertical : !this.props.horizontal;
+        var baseStyle = horizontal ? styles.baseHorizontal : styles.baseVertical;
+        var _this$props = this.props,
+          experimental_endDraggingSensitivityMultiplier = _this$props.experimental_endDraggingSensitivityMultiplier,
+          otherProps = (0, _objectWithoutProperties2.default)(_this$props, _excluded);
+        var props = Object.assign({}, otherProps, {
+          alwaysBounceHorizontal: alwaysBounceHorizontal,
+          alwaysBounceVertical: alwaysBounceVertical,
+          style: _StyleSheet.default.compose(baseStyle, this.props.style),
+          onContentSizeChange: null,
+          onLayout: this._handleLayout,
+          onMomentumScrollBegin: this._handleMomentumScrollBegin,
+          onMomentumScrollEnd: this._handleMomentumScrollEnd,
+          onResponderGrant: this._handleResponderGrant,
+          onResponderReject: this._handleResponderReject,
+          onResponderRelease: this._handleResponderRelease,
+          onResponderTerminationRequest: this._handleResponderTerminationRequest,
+          onScrollBeginDrag: this._handleScrollBeginDrag,
+          onScrollEndDrag: this._handleScrollEndDrag,
+          onScrollShouldSetResponder: this._handleScrollShouldSetResponder,
+          onStartShouldSetResponder: this._handleStartShouldSetResponder,
+          onStartShouldSetResponderCapture: this._handleStartShouldSetResponderCapture,
+          onTouchEnd: this._handleTouchEnd,
+          onTouchMove: this._handleTouchMove,
+          onTouchStart: this._handleTouchStart,
+          onTouchCancel: this._handleTouchCancel,
+          onScroll: this._handleScroll,
+          endDraggingSensitivityMultiplier: experimental_endDraggingSensitivityMultiplier,
+          scrollEventThrottle: hasStickyHeaders ? 1 : this.props.scrollEventThrottle,
+          sendMomentumEvents: this.props.onMomentumScrollBegin || this.props.onMomentumScrollEnd ? true : false,
+          snapToStart: this.props.snapToStart !== false,
+          snapToEnd: this.props.snapToEnd !== false,
+          pagingEnabled: _Platform.default.select({
+            ios: this.props.pagingEnabled === true && this.props.snapToInterval == null && this.props.snapToOffsets == null,
+            android: this.props.pagingEnabled === true || this.props.snapToInterval != null || this.props.snapToOffsets != null
+          })
+        });
+        var decelerationRate = this.props.decelerationRate;
+        if (decelerationRate != null) {
+          props.decelerationRate = (0, _processDecelerationRate.default)(decelerationRate);
+        }
+        var refreshControl = this.props.refreshControl;
+        var scrollViewRef = this._scrollView.getForwardingRef(this.props.scrollViewRef);
+        if (refreshControl != null) {
+          if (_Platform.default.OS === 'ios') {
+            return /*#__PURE__*/(0, _jsxRuntime.jsxs)(NativeScrollView, Object.assign({}, props, {
+              ref: scrollViewRef,
+              children: [refreshControl, contentContainer]
+            }));
+          } else if (_Platform.default.OS === 'android') {
+            var _splitLayoutProps = (0, _splitLayoutProps2.default)((0, _flattenStyle.default)(props.style)),
+              outer = _splitLayoutProps.outer,
+              inner = _splitLayoutProps.inner;
+            return React.cloneElement(refreshControl, {
+              style: _StyleSheet.default.compose(baseStyle, outer)
+            }, /*#__PURE__*/(0, _jsxRuntime.jsx)(NativeScrollView, Object.assign({}, props, {
+              style: _StyleSheet.default.compose(baseStyle, inner),
+              ref: scrollViewRef,
+              children: contentContainer
+            })));
+          }
+        }
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(NativeScrollView, Object.assign({}, props, {
+          ref: scrollViewRef,
+          children: contentContainer
+        }));
+      }
+    }]);
+  }(React.Component);
+  ScrollView.Context = _ScrollViewContext.default;
+  var styles = _StyleSheet.default.create({
+    baseVertical: {
+      flexGrow: 1,
+      flexShrink: 1,
+      flexDirection: 'column',
+      overflow: 'scroll'
+    },
+    baseHorizontal: {
+      flexGrow: 1,
+      flexShrink: 1,
+      flexDirection: 'row',
+      overflow: 'scroll'
+    },
+    contentContainerHorizontal: {
+      flexDirection: 'row'
+    }
+  });
+  function createRefForwarder(mutator) {
+    var state = {
+      getForwardingRef: (0, _memoizeOne.default)(function (forwardedRef) {
+        return function (nativeInstance) {
+          var publicInstance = nativeInstance == null ? null : mutator(nativeInstance);
+          state.nativeInstance = nativeInstance;
+          state.publicInstance = publicInstance;
+          if (forwardedRef != null) {
+            if (typeof forwardedRef === 'function') {
+              forwardedRef(publicInstance);
+            } else {
+              forwardedRef.current = publicInstance;
+            }
+          }
+        };
+      }),
+      nativeInstance: null,
+      publicInstance: null
+    };
+    return state;
+  }
+  var ScrollViewWrapper = React.forwardRef(function Wrapper(props, ref) {
+    return ref == null ? /*#__PURE__*/(0, _jsxRuntime.jsx)(ScrollView, Object.assign({}, props)) : /*#__PURE__*/(0, _jsxRuntime.jsx)(ScrollView, Object.assign({}, props, {
+      scrollViewRef: ref
+    }));
+  });
+  ScrollViewWrapper.displayName = 'ScrollView';
+  ScrollViewWrapper.Context = _ScrollViewContext.default;
+  var _default = exports.default = ScrollViewWrapper;
+},387,[1,4,11,12,18,20,23,388,429,79,9,432,6,16,433,68,434,130,71,438,439,440,441,32,462,80,73,171,106,475,480],"../../node_modules/react-native/Libraries/Components/ScrollView/ScrollView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _DecayAnimation = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./animations/DecayAnimation"));
+  var _SpringAnimation = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./animations/SpringAnimation"));
+  var _TimingAnimation = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./animations/TimingAnimation"));
+  var _createAnimatedComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./createAnimatedComponent"));
+  var _AnimatedAddition = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./nodes/AnimatedAddition"));
+  var _AnimatedColor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./nodes/AnimatedColor"));
+  var _AnimatedDiffClamp = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./nodes/AnimatedDiffClamp"));
+  var _AnimatedDivision = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./nodes/AnimatedDivision"));
+  var _AnimatedInterpolation = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./nodes/AnimatedInterpolation"));
+  var _AnimatedModulo = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./nodes/AnimatedModulo"));
+  var _AnimatedMultiplication = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "./nodes/AnimatedMultiplication"));
+  var _AnimatedNode = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "./nodes/AnimatedNode"));
+  var _AnimatedSubtraction = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[13], "./nodes/AnimatedSubtraction"));
+  var _AnimatedTracking = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[14], "./nodes/AnimatedTracking"));
+  var _AnimatedValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[15], "./nodes/AnimatedValue"));
+  var _AnimatedValueXY = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[16], "./nodes/AnimatedValueXY"));
+  var add = function add(a, b) {
+    return new _AnimatedAddition.default(a, b);
+  };
+  var subtract = function subtract(a, b) {
+    return new _AnimatedSubtraction.default(a, b);
+  };
+  var divide = function divide(a, b) {
+    return new _AnimatedDivision.default(a, b);
+  };
+  var multiply = function multiply(a, b) {
+    return new _AnimatedMultiplication.default(a, b);
+  };
+  var modulo = function modulo(a, modulus) {
+    return new _AnimatedModulo.default(a, modulus);
+  };
+  var diffClamp = function diffClamp(a, min, max) {
+    return new _AnimatedDiffClamp.default(a, min, max);
+  };
+  var _combineCallbacks = function _combineCallbacks(callback, config) {
+    if (callback && config.onComplete) {
+      return function () {
+        config.onComplete && config.onComplete.apply(config, arguments);
+        callback && callback.apply(void 0, arguments);
+      };
+    } else {
+      return callback || config.onComplete;
+    }
+  };
+  var maybeVectorAnim = function maybeVectorAnim(value, config, anim) {
+    if (value instanceof _AnimatedValueXY.default) {
+      var configX = Object.assign({}, config);
+      var configY = Object.assign({}, config);
+      for (var key in config) {
+        var _config$key = config[key],
+          x = _config$key.x,
+          y = _config$key.y;
+        if (x !== undefined && y !== undefined) {
+          configX[key] = x;
+          configY[key] = y;
+        }
+      }
+      var aX = anim(value.x, configX);
+      var aY = anim(value.y, configY);
+      return parallel([aX, aY], {
+        stopTogether: false
+      });
+    } else if (value instanceof _AnimatedColor.default) {
+      var configR = Object.assign({}, config);
+      var configG = Object.assign({}, config);
+      var configB = Object.assign({}, config);
+      var configA = Object.assign({}, config);
+      for (var _key in config) {
+        var _config$_key = config[_key],
+          r = _config$_key.r,
+          g = _config$_key.g,
+          b = _config$_key.b,
+          a = _config$_key.a;
+        if (r !== undefined && g !== undefined && b !== undefined && a !== undefined) {
+          configR[_key] = r;
+          configG[_key] = g;
+          configB[_key] = b;
+          configA[_key] = a;
+        }
+      }
+      var aR = anim(value.r, configR);
+      var aG = anim(value.g, configG);
+      var aB = anim(value.b, configB);
+      var aA = anim(value.a, configA);
+      return parallel([aR, aG, aB, aA], {
+        stopTogether: false
+      });
+    }
+    return null;
+  };
+  var _spring = function spring(value, config) {
+    var _start = function start(animatedValue, configuration, callback) {
+      callback = _combineCallbacks(callback, configuration);
+      var singleValue = animatedValue;
+      var singleConfig = configuration;
+      singleValue.stopTracking();
+      if (configuration.toValue instanceof _AnimatedNode.default) {
+        singleValue.track(new _AnimatedTracking.default(singleValue, configuration.toValue, _SpringAnimation.default, singleConfig, callback));
+      } else {
+        singleValue.animate(new _SpringAnimation.default(singleConfig), callback);
+      }
+    };
+    return maybeVectorAnim(value, config, _spring) || {
+      start: function start(callback) {
+        _start(value, config, callback);
+      },
+      stop: function stop() {
+        value.stopAnimation();
+      },
+      reset: function reset() {
+        value.resetAnimation();
+      },
+      _startNativeLoop: function _startNativeLoop(iterations) {
+        var singleConfig = Object.assign({}, config, {
+          iterations: iterations
+        });
+        _start(value, singleConfig);
+      },
+      _isUsingNativeDriver: function _isUsingNativeDriver() {
+        return config.useNativeDriver || false;
+      }
+    };
+  };
+  var _timing = function timing(value, config) {
+    var _start2 = function start(animatedValue, configuration, callback) {
+      callback = _combineCallbacks(callback, configuration);
+      var singleValue = animatedValue;
+      var singleConfig = configuration;
+      singleValue.stopTracking();
+      if (configuration.toValue instanceof _AnimatedNode.default) {
+        singleValue.track(new _AnimatedTracking.default(singleValue, configuration.toValue, _TimingAnimation.default, singleConfig, callback));
+      } else {
+        singleValue.animate(new _TimingAnimation.default(singleConfig), callback);
+      }
+    };
+    return maybeVectorAnim(value, config, _timing) || {
+      start: function start(callback, isLooping) {
+        _start2(value, Object.assign({}, config, {
+          isLooping: isLooping
+        }), callback);
+      },
+      stop: function stop() {
+        value.stopAnimation();
+      },
+      reset: function reset() {
+        value.resetAnimation();
+      },
+      _startNativeLoop: function _startNativeLoop(iterations) {
+        var singleConfig = Object.assign({}, config, {
+          iterations: iterations
+        });
+        _start2(value, singleConfig);
+      },
+      _isUsingNativeDriver: function _isUsingNativeDriver() {
+        return config.useNativeDriver || false;
+      }
+    };
+  };
+  var _decay = function decay(value, config) {
+    var _start3 = function start(animatedValue, configuration, callback) {
+      callback = _combineCallbacks(callback, configuration);
+      var singleValue = animatedValue;
+      var singleConfig = configuration;
+      singleValue.stopTracking();
+      singleValue.animate(new _DecayAnimation.default(singleConfig), callback);
+    };
+    return maybeVectorAnim(value, config, _decay) || {
+      start: function start(callback) {
+        _start3(value, config, callback);
+      },
+      stop: function stop() {
+        value.stopAnimation();
+      },
+      reset: function reset() {
+        value.resetAnimation();
+      },
+      _startNativeLoop: function _startNativeLoop(iterations) {
+        var singleConfig = Object.assign({}, config, {
+          iterations: iterations
+        });
+        _start3(value, singleConfig);
+      },
+      _isUsingNativeDriver: function _isUsingNativeDriver() {
+        return config.useNativeDriver || false;
+      }
+    };
+  };
+  var sequence = function sequence(animations) {
+    var current = 0;
+    return {
+      start: function start(callback, isLooping) {
+        var _onComplete = function onComplete(result) {
+          if (!result.finished) {
+            callback && callback(result);
+            return;
+          }
+          current++;
+          if (current === animations.length) {
+            current = 0;
+            callback && callback(result);
+            return;
+          }
+          animations[current].start(_onComplete, isLooping);
+        };
+        if (animations.length === 0) {
+          callback && callback({
+            finished: true
+          });
+        } else {
+          animations[current].start(_onComplete, isLooping);
+        }
+      },
+      stop: function stop() {
+        if (current < animations.length) {
+          animations[current].stop();
+        }
+      },
+      reset: function reset() {
+        animations.forEach(function (animation, idx) {
+          if (idx <= current) {
+            animation.reset();
+          }
+        });
+        current = 0;
+      },
+      _startNativeLoop: function _startNativeLoop() {
+        throw new Error('Loops run using the native driver cannot contain Animated.sequence animations');
+      },
+      _isUsingNativeDriver: function _isUsingNativeDriver() {
+        return false;
+      }
+    };
+  };
+  var parallel = function parallel(animations, config) {
+    var doneCount = 0;
+    var hasEnded = {};
+    var stopTogether = !(config && config.stopTogether === false);
+    var result = {
+      start: function start(callback, isLooping) {
+        if (doneCount === animations.length) {
+          callback && callback({
+            finished: true
+          });
+          return;
+        }
+        animations.forEach(function (animation, idx) {
+          var cb = function cb(endResult) {
+            hasEnded[idx] = true;
+            doneCount++;
+            if (doneCount === animations.length) {
+              doneCount = 0;
+              callback && callback(endResult);
+              return;
+            }
+            if (!endResult.finished && stopTogether) {
+              result.stop();
+            }
+          };
+          if (!animation) {
+            cb({
+              finished: true
+            });
+          } else {
+            animation.start(cb, isLooping);
+          }
+        });
+      },
+      stop: function stop() {
+        animations.forEach(function (animation, idx) {
+          !hasEnded[idx] && animation.stop();
+          hasEnded[idx] = true;
+        });
+      },
+      reset: function reset() {
+        animations.forEach(function (animation, idx) {
+          animation.reset();
+          hasEnded[idx] = false;
+          doneCount = 0;
+        });
+      },
+      _startNativeLoop: function _startNativeLoop() {
+        throw new Error('Loops run using the native driver cannot contain Animated.parallel animations');
+      },
+      _isUsingNativeDriver: function _isUsingNativeDriver() {
+        return false;
+      }
+    };
+    return result;
+  };
+  var delay = function delay(time) {
+    return _timing(new _AnimatedValue.default(0), {
+      toValue: 0,
+      delay: time,
+      duration: 0,
+      useNativeDriver: false
+    });
+  };
+  var stagger = function stagger(time, animations) {
+    return parallel(animations.map(function (animation, i) {
+      return sequence([delay(time * i), animation]);
+    }));
+  };
+  var loop = function loop(animation) {
+    var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      _ref$iterations = _ref.iterations,
+      iterations = _ref$iterations === void 0 ? -1 : _ref$iterations,
+      _ref$resetBeforeItera = _ref.resetBeforeIteration,
+      resetBeforeIteration = _ref$resetBeforeItera === void 0 ? true : _ref$resetBeforeItera;
+    var isFinished = false;
+    var iterationsSoFar = 0;
+    return {
+      start: function start(callback) {
+        var _restart = function restart() {
+          var result = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+            finished: true
+          };
+          if (isFinished || iterationsSoFar === iterations || result.finished === false) {
+            callback && callback(result);
+          } else {
+            iterationsSoFar++;
+            resetBeforeIteration && animation.reset();
+            animation.start(_restart, iterations === -1);
+          }
+        };
+        if (!animation || iterations === 0) {
+          callback && callback({
+            finished: true
+          });
+        } else {
+          if (animation._isUsingNativeDriver()) {
+            animation._startNativeLoop(iterations);
+          } else {
+            _restart();
+          }
+        }
+      },
+      stop: function stop() {
+        isFinished = true;
+        animation.stop();
+      },
+      reset: function reset() {
+        iterationsSoFar = 0;
+        isFinished = false;
+        animation.reset();
+      },
+      _startNativeLoop: function _startNativeLoop() {
+        throw new Error('Loops run using the native driver cannot contain Animated.loop animations');
+      },
+      _isUsingNativeDriver: function _isUsingNativeDriver() {
+        return animation._isUsingNativeDriver();
+      }
+    };
+  };
+  function forkEvent(event, listener) {
+    if (!event) {
+      return listener;
+    } else if (event instanceof _$$_REQUIRE(_dependencyMap[17], "./AnimatedEvent").AnimatedEvent) {
+      event.__addListener(listener);
+      return event;
+    } else {
+      return function () {
+        typeof event === 'function' && event.apply(void 0, arguments);
+        listener.apply(void 0, arguments);
+      };
+    }
+  }
+  function unforkEvent(event, listener) {
+    if (event && event instanceof _$$_REQUIRE(_dependencyMap[17], "./AnimatedEvent").AnimatedEvent) {
+      event.__removeListener(listener);
+    }
+  }
+  var event = function event(argMapping, config) {
+    var animatedEvent = new (_$$_REQUIRE(_dependencyMap[17], "./AnimatedEvent").AnimatedEvent)(argMapping, config);
+    if (animatedEvent.__isNative) {
+      return animatedEvent;
+    } else {
+      return animatedEvent.__getHandler();
+    }
+  };
+  var _default = exports.default = {
+    Value: _AnimatedValue.default,
+    ValueXY: _AnimatedValueXY.default,
+    Color: _AnimatedColor.default,
+    Interpolation: _AnimatedInterpolation.default,
+    Node: _AnimatedNode.default,
+    decay: _decay,
+    timing: _timing,
+    spring: _spring,
+    add: add,
+    subtract: subtract,
+    divide: divide,
+    multiply: multiply,
+    modulo: modulo,
+    diffClamp: diffClamp,
+    delay: delay,
+    sequence: sequence,
+    parallel: parallel,
+    stagger: stagger,
+    loop: loop,
+    event: event,
+    createAnimatedComponent: _createAnimatedComponent.default,
+    attachNativeEvent: _$$_REQUIRE(_dependencyMap[17], "./AnimatedEvent").attachNativeEvent,
+    forkEvent: forkEvent,
+    unforkEvent: unforkEvent,
+    Event: _$$_REQUIRE(_dependencyMap[17], "./AnimatedEvent").AnimatedEvent
+  };
+},388,[1,389,414,417,418,422,415,423,424,410,425,426,398,427,428,406,413,405],"../../node_modules/react-native/Libraries/Animated/AnimatedImplementation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _Animation2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./Animation"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  var DecayAnimation = exports.default = /*#__PURE__*/function (_Animation) {
+    function DecayAnimation(config) {
+      var _config$deceleration;
+      var _this;
+      (0, _classCallCheck2.default)(this, DecayAnimation);
+      _this = _callSuper(this, DecayAnimation, [config]);
+      _this._deceleration = (_config$deceleration = config.deceleration) != null ? _config$deceleration : 0.998;
+      _this._velocity = config.velocity;
+      _this._platformConfig = config.platformConfig;
+      return _this;
+    }
+    (0, _inherits2.default)(DecayAnimation, _Animation);
+    return (0, _createClass2.default)(DecayAnimation, [{
+      key: "__getNativeAnimationConfig",
+      value: function __getNativeAnimationConfig() {
+        return {
+          type: 'decay',
+          deceleration: this._deceleration,
+          velocity: this._velocity,
+          iterations: this.__iterations,
+          platformConfig: this._platformConfig,
+          debugID: this.__getDebugID()
+        };
+      }
+    }, {
+      key: "start",
+      value: function start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {
+        var _this2 = this;
+        _superPropGet(DecayAnimation, "start", this, 3)([fromValue, onUpdate, onEnd, previousAnimation, animatedValue]);
+        this._lastValue = fromValue;
+        this._fromValue = fromValue;
+        this._onUpdate = onUpdate;
+        this._startTime = Date.now();
+        var useNativeDriver = this.__startAnimationIfNative(animatedValue);
+        if (!useNativeDriver) {
+          this._animationFrame = requestAnimationFrame(function () {
+            return _this2.onUpdate();
+          });
+        }
+      }
+    }, {
+      key: "onUpdate",
+      value: function onUpdate() {
+        var now = Date.now();
+        var value = this._fromValue + this._velocity / (1 - this._deceleration) * (1 - Math.exp(-(1 - this._deceleration) * (now - this._startTime)));
+        this._onUpdate(value);
+        if (Math.abs(this._lastValue - value) < 0.1) {
+          this.__notifyAnimationEnd({
+            finished: true
+          });
+          return;
+        }
+        this._lastValue = value;
+        if (this.__active) {
+          this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this));
+        }
+      }
+    }, {
+      key: "stop",
+      value: function stop() {
+        _superPropGet(DecayAnimation, "stop", this, 3)([]);
+        if (this._animationFrame != null) {
+          global.cancelAnimationFrame(this._animationFrame);
+        }
+        this.__notifyAnimationEnd({
+          finished: false
+        });
+      }
+    }]);
+  }(_Animation2.default);
+},389,[1,11,12,18,20,21,23,390],"../../node_modules/react-native/Libraries/Animated/animations/DecayAnimation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _toConsumableArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/toConsumableArray"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+  var _classPrivateFieldLooseBase2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classPrivateFieldLooseBase"));
+  var _classPrivateFieldLooseKey2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/classPrivateFieldLooseKey"));
+  var _NativeAnimatedHelper = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../../../src/private/animated/NativeAnimatedHelper"));
+  var _AnimatedProps = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../nodes/AnimatedProps"));
+  var startNativeAnimationNextId = 1;
+  var _nativeID = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("nativeID");
+  var _onEnd = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("onEnd");
+  var _useNativeDriver = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("useNativeDriver");
+  var Animation = exports.default = /*#__PURE__*/function () {
+    function Animation(config) {
+      var _config$isInteraction, _config$iterations;
+      (0, _classCallCheck2.default)(this, Animation);
+      Object.defineProperty(this, _nativeID, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(this, _onEnd, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(this, _useNativeDriver, {
+        writable: true,
+        value: void 0
+      });
+      (0, _classPrivateFieldLooseBase2.default)(this, _useNativeDriver)[_useNativeDriver] = _NativeAnimatedHelper.default.shouldUseNativeDriver(config);
+      this.__active = false;
+      this.__isInteraction = (_config$isInteraction = config.isInteraction) != null ? _config$isInteraction : !(0, _classPrivateFieldLooseBase2.default)(this, _useNativeDriver)[_useNativeDriver];
+      this.__isLooping = config.isLooping;
+      this.__iterations = (_config$iterations = config.iterations) != null ? _config$iterations : 1;
+      if (__DEV__) {
+        this.__debugID = config.debugID;
+      }
+    }
+    return (0, _createClass2.default)(Animation, [{
+      key: "start",
+      value: function start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {
+        if (!(0, _classPrivateFieldLooseBase2.default)(this, _useNativeDriver)[_useNativeDriver] && animatedValue.__isNative === true) {
+          throw new Error('Attempting to run JS driven animation on animated node ' + 'that has been moved to "native" earlier by starting an ' + 'animation with `useNativeDriver: true`');
+        }
+        (0, _classPrivateFieldLooseBase2.default)(this, _onEnd)[_onEnd] = onEnd;
+        this.__active = true;
+      }
+    }, {
+      key: "stop",
+      value: function stop() {
+        if ((0, _classPrivateFieldLooseBase2.default)(this, _nativeID)[_nativeID] != null) {
+          var nativeID = (0, _classPrivateFieldLooseBase2.default)(this, _nativeID)[_nativeID];
+          var identifier = `${nativeID}:stopAnimation`;
+          try {
+            _NativeAnimatedHelper.default.API.setWaitingForIdentifier(identifier);
+            _NativeAnimatedHelper.default.API.stopAnimation(nativeID);
+          } finally {
+            _NativeAnimatedHelper.default.API.unsetWaitingForIdentifier(identifier);
+          }
+        }
+        this.__active = false;
+      }
+    }, {
+      key: "__getNativeAnimationConfig",
+      value: function __getNativeAnimationConfig() {
+        throw new Error('This animation type cannot be offloaded to native');
+      }
+    }, {
+      key: "__findAnimatedPropsNodes",
+      value: function __findAnimatedPropsNodes(node) {
+        var result = [];
+        if (node instanceof _AnimatedProps.default) {
+          result.push(node);
+          return result;
+        }
+        for (var child of node.__getChildren()) {
+          result.push.apply(result, (0, _toConsumableArray2.default)(this.__findAnimatedPropsNodes(child)));
+        }
+        return result;
+      }
+    }, {
+      key: "__startAnimationIfNative",
+      value: function __startAnimationIfNative(animatedValue) {
+        var _this = this;
+        if (!(0, _classPrivateFieldLooseBase2.default)(this, _useNativeDriver)[_useNativeDriver]) {
+          return false;
+        }
+        var startNativeAnimationWaitId = `${startNativeAnimationNextId}:startAnimation`;
+        startNativeAnimationNextId += 1;
+        _NativeAnimatedHelper.default.API.setWaitingForIdentifier(startNativeAnimationWaitId);
+        try {
+          var config = this.__getNativeAnimationConfig();
+          animatedValue.__makeNative(config.platformConfig);
+          (0, _classPrivateFieldLooseBase2.default)(this, _nativeID)[_nativeID] = _NativeAnimatedHelper.default.generateNewAnimationId();
+          _NativeAnimatedHelper.default.API.startAnimatingNode((0, _classPrivateFieldLooseBase2.default)(this, _nativeID)[_nativeID], animatedValue.__getNativeTag(), config, function (result) {
+            _this.__notifyAnimationEnd(result);
+            var value = result.value,
+              offset = result.offset;
+            if (value != null) {
+              animatedValue.__onAnimatedValueUpdateReceived(value, offset);
+              if (_this.__isLooping === true) {
+                return;
+              }
+              _this.__findAnimatedPropsNodes(animatedValue).forEach(function (node) {
+                return node.update();
+              });
+            }
+          });
+          return true;
+        } catch (e) {
+          throw e;
+        } finally {
+          _NativeAnimatedHelper.default.API.unsetWaitingForIdentifier(startNativeAnimationWaitId);
+        }
+      }
+    }, {
+      key: "__notifyAnimationEnd",
+      value: function __notifyAnimationEnd(result) {
+        var callback = (0, _classPrivateFieldLooseBase2.default)(this, _onEnd)[_onEnd];
+        if (callback != null) {
+          (0, _classPrivateFieldLooseBase2.default)(this, _onEnd)[_onEnd] = null;
+          callback(result);
+        }
+      }
+    }, {
+      key: "__getDebugID",
+      value: function __getDebugID() {
+        if (__DEV__) {
+          return this.__debugID;
+        }
+        return undefined;
+      }
+    }]);
+  }();
+},390,[1,42,11,12,26,27,391,397],"../../node_modules/react-native/Libraries/Animated/animations/Animation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _NativeAnimatedModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../../Libraries/Animated/NativeAnimatedModule"));
+  var _NativeAnimatedTurboModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../../Libraries/Animated/NativeAnimatedTurboModule"));
+  var _NativeEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../../Libraries/EventEmitter/NativeEventEmitter"));
+  var _RCTDeviceEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../../../Libraries/EventEmitter/RCTDeviceEventEmitter"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../../../Libraries/Utilities/Platform"));
+  var ReactNativeFeatureFlags = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[6], "../featureflags/ReactNativeFeatureFlags"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "invariant"));
+  var _nullthrows = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "nullthrows"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var NativeAnimatedModule = _NativeAnimatedModule.default != null ? _NativeAnimatedModule.default : _NativeAnimatedTurboModule.default;
+  var __nativeAnimatedNodeTagCount = 1;
+  var __nativeAnimationIdCount = 1;
+  var nativeEventEmitter;
+  var waitingForQueuedOperations = new Set();
+  var queueOperations = false;
+  var queue = [];
+  var singleOpQueue = [];
+  var isSingleOpBatching = _Platform.default.OS === 'android' && (NativeAnimatedModule == null ? void 0 : NativeAnimatedModule.queueAndExecuteBatchedOperations) != null && ReactNativeFeatureFlags.animatedShouldUseSingleOp();
+  var flushQueueImmediate = null;
+  var eventListenerGetValueCallbacks = {};
+  var eventListenerAnimationFinishedCallbacks = {};
+  var globalEventEmitterGetValueListener = null;
+  var globalEventEmitterAnimationFinishedListener = null;
+  var shouldSignalBatch = ReactNativeFeatureFlags.animatedShouldSignalBatch() || ReactNativeFeatureFlags.cxxNativeAnimatedEnabled();
+  function createNativeOperations() {
+    var methodNames = ['createAnimatedNode', 'updateAnimatedNodeConfig', 'getValue', 'startListeningToAnimatedNodeValue', 'stopListeningToAnimatedNodeValue', 'connectAnimatedNodes', 'disconnectAnimatedNodes', 'startAnimatingNode', 'stopAnimation', 'setAnimatedNodeValue', 'setAnimatedNodeOffset', 'flattenAnimatedNodeOffset', 'extractAnimatedNodeOffset', 'connectAnimatedNodeToView', 'disconnectAnimatedNodeFromView', 'restoreDefaultValues', 'dropAnimatedNode', 'addAnimatedEventToView', 'removeAnimatedEventFromView', 'addListener', 'removeListener'];
+    var nativeOperations = {};
+    if (isSingleOpBatching) {
+      var _loop = function _loop() {
+        var methodName = methodNames[ii];
+        var operationID = ii + 1;
+        nativeOperations[methodName] = function () {
+          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = arguments[_key];
+          }
+          singleOpQueue.push.apply(singleOpQueue, [operationID].concat(args));
+        };
+      };
+      for (var ii = 0, length = methodNames.length; ii < length; ii++) {
+        _loop();
+      }
+    } else {
+      var _loop2 = function _loop2() {
+        var methodName = methodNames[_ii];
+        nativeOperations[methodName] = function () {
+          for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+            args[_key2] = arguments[_key2];
+          }
+          var method = (0, _nullthrows.default)(NativeAnimatedModule)[methodName];
+          if (queueOperations || queue.length !== 0) {
+            queue.push(function () {
+              return method.apply(void 0, args);
+            });
+          } else if (shouldSignalBatch) {
+            queue.push(function () {
+              return method.apply(void 0, args);
+            });
+            clearImmediate(flushQueueImmediate);
+            flushQueueImmediate = setImmediate(API.flushQueue);
+          } else {
+            method.apply(void 0, args);
+          }
+        };
+      };
+      for (var _ii = 0, _length = methodNames.length; _ii < _length; _ii++) {
+        _loop2();
+      }
+    }
+    return nativeOperations;
+  }
+  var NativeOperations = createNativeOperations();
+  var API = {
+    getValue: isSingleOpBatching ? function (tag, saveValueCallback) {
+      if (saveValueCallback) {
+        eventListenerGetValueCallbacks[tag] = saveValueCallback;
+      }
+      NativeOperations.getValue(tag);
+    } : function (tag, saveValueCallback) {
+      NativeOperations.getValue(tag, saveValueCallback);
+    },
+    setWaitingForIdentifier: function setWaitingForIdentifier(id) {
+      if (shouldSignalBatch) {
+        return;
+      }
+      waitingForQueuedOperations.add(id);
+      queueOperations = true;
+      if (ReactNativeFeatureFlags.animatedShouldDebounceQueueFlush() && flushQueueImmediate) {
+        clearImmediate(flushQueueImmediate);
+      }
+    },
+    unsetWaitingForIdentifier: function unsetWaitingForIdentifier(id) {
+      if (shouldSignalBatch) {
+        return;
+      }
+      waitingForQueuedOperations.delete(id);
+      if (waitingForQueuedOperations.size === 0) {
+        queueOperations = false;
+        API.disableQueue();
+      }
+    },
+    disableQueue: function disableQueue() {
+      (0, _invariant.default)(NativeAnimatedModule, 'Native animated module is not available');
+      if (ReactNativeFeatureFlags.animatedShouldDebounceQueueFlush()) {
+        var prevImmediate = flushQueueImmediate;
+        clearImmediate(prevImmediate);
+        flushQueueImmediate = setImmediate(API.flushQueue);
+      } else {
+        API.flushQueue();
+      }
+    },
+    flushQueue: isSingleOpBatching ? function () {
+      (0, _invariant.default)(NativeAnimatedModule, 'Native animated module is not available');
+      flushQueueImmediate = null;
+      if (singleOpQueue.length === 0) {
+        return;
+      }
+      ensureGlobalEventEmitterListeners();
+      NativeAnimatedModule == null || NativeAnimatedModule.queueAndExecuteBatchedOperations == null || NativeAnimatedModule.queueAndExecuteBatchedOperations(singleOpQueue);
+      singleOpQueue.length = 0;
+    } : function () {
+      (0, _invariant.default)(NativeAnimatedModule, 'Native animated module is not available');
+      flushQueueImmediate = null;
+      if (queue.length === 0) {
+        return;
+      }
+      if (_Platform.default.OS === 'android' || shouldSignalBatch) {
+        NativeAnimatedModule == null || NativeAnimatedModule.startOperationBatch == null || NativeAnimatedModule.startOperationBatch();
+      }
+      for (var q = 0, l = queue.length; q < l; q++) {
+        queue[q]();
+      }
+      queue.length = 0;
+      if (_Platform.default.OS === 'android' || shouldSignalBatch) {
+        NativeAnimatedModule == null || NativeAnimatedModule.finishOperationBatch == null || NativeAnimatedModule.finishOperationBatch();
+      }
+    },
+    createAnimatedNode: function createAnimatedNode(tag, config) {
+      NativeOperations.createAnimatedNode(tag, config);
+    },
+    updateAnimatedNodeConfig: function updateAnimatedNodeConfig(tag, config) {
+      NativeOperations.updateAnimatedNodeConfig == null || NativeOperations.updateAnimatedNodeConfig(tag, config);
+    },
+    startListeningToAnimatedNodeValue: function startListeningToAnimatedNodeValue(tag) {
+      NativeOperations.startListeningToAnimatedNodeValue(tag);
+    },
+    stopListeningToAnimatedNodeValue: function stopListeningToAnimatedNodeValue(tag) {
+      NativeOperations.stopListeningToAnimatedNodeValue(tag);
+    },
+    connectAnimatedNodes: function connectAnimatedNodes(parentTag, childTag) {
+      NativeOperations.connectAnimatedNodes(parentTag, childTag);
+    },
+    disconnectAnimatedNodes: function disconnectAnimatedNodes(parentTag, childTag) {
+      NativeOperations.disconnectAnimatedNodes(parentTag, childTag);
+    },
+    startAnimatingNode: isSingleOpBatching ? function (animationId, nodeTag, config, endCallback) {
+      if (endCallback) {
+        eventListenerAnimationFinishedCallbacks[animationId] = endCallback;
+      }
+      NativeOperations.startAnimatingNode(animationId, nodeTag, config);
+    } : function (animationId, nodeTag, config, endCallback) {
+      NativeOperations.startAnimatingNode(animationId, nodeTag, config, endCallback);
+    },
+    stopAnimation: function stopAnimation(animationId) {
+      NativeOperations.stopAnimation(animationId);
+    },
+    setAnimatedNodeValue: function setAnimatedNodeValue(nodeTag, value) {
+      NativeOperations.setAnimatedNodeValue(nodeTag, value);
+    },
+    setAnimatedNodeOffset: function setAnimatedNodeOffset(nodeTag, offset) {
+      NativeOperations.setAnimatedNodeOffset(nodeTag, offset);
+    },
+    flattenAnimatedNodeOffset: function flattenAnimatedNodeOffset(nodeTag) {
+      NativeOperations.flattenAnimatedNodeOffset(nodeTag);
+    },
+    extractAnimatedNodeOffset: function extractAnimatedNodeOffset(nodeTag) {
+      NativeOperations.extractAnimatedNodeOffset(nodeTag);
+    },
+    connectAnimatedNodeToView: function connectAnimatedNodeToView(nodeTag, viewTag) {
+      NativeOperations.connectAnimatedNodeToView(nodeTag, viewTag);
+    },
+    disconnectAnimatedNodeFromView: function disconnectAnimatedNodeFromView(nodeTag, viewTag) {
+      NativeOperations.disconnectAnimatedNodeFromView(nodeTag, viewTag);
+    },
+    restoreDefaultValues: function restoreDefaultValues(nodeTag) {
+      NativeOperations.restoreDefaultValues == null || NativeOperations.restoreDefaultValues(nodeTag);
+    },
+    dropAnimatedNode: function dropAnimatedNode(tag) {
+      NativeOperations.dropAnimatedNode(tag);
+    },
+    addAnimatedEventToView: function addAnimatedEventToView(viewTag, eventName, eventMapping) {
+      NativeOperations.addAnimatedEventToView(viewTag, eventName, eventMapping);
+    },
+    removeAnimatedEventFromView: function removeAnimatedEventFromView(viewTag, eventName, animatedNodeTag) {
+      NativeOperations.removeAnimatedEventFromView(viewTag, eventName, animatedNodeTag);
+    }
+  };
+  function ensureGlobalEventEmitterListeners() {
+    if (globalEventEmitterGetValueListener && globalEventEmitterAnimationFinishedListener) {
+      return;
+    }
+    globalEventEmitterGetValueListener = _RCTDeviceEventEmitter.default.addListener('onNativeAnimatedModuleGetValue', function (params) {
+      var tag = params.tag;
+      var callback = eventListenerGetValueCallbacks[tag];
+      if (!callback) {
+        return;
+      }
+      callback(params.value);
+      delete eventListenerGetValueCallbacks[tag];
+    });
+    globalEventEmitterAnimationFinishedListener = _RCTDeviceEventEmitter.default.addListener('onNativeAnimatedModuleAnimationFinished', function (params) {
+      var animations = Array.isArray(params) ? params : [params];
+      for (var animation of animations) {
+        var animationId = animation.animationId;
+        var callback = eventListenerAnimationFinishedCallbacks[animationId];
+        if (callback) {
+          callback(animation);
+          delete eventListenerAnimationFinishedCallbacks[animationId];
+        }
+      }
+    });
+  }
+  function generateNewNodeTag() {
+    return __nativeAnimatedNodeTagCount++;
+  }
+  function generateNewAnimationId() {
+    return __nativeAnimationIdCount++;
+  }
+  function assertNativeAnimatedModule() {
+    (0, _invariant.default)(NativeAnimatedModule, 'Native animated module is not available');
+  }
+  var _warnedMissingNativeAnimated = false;
+  function shouldUseNativeDriver(config) {
+    if (config.useNativeDriver == null) {
+      console.warn('Animated: `useNativeDriver` was not specified. This is a required ' + 'option and must be explicitly set to `true` or `false`');
+    }
+    if (config.useNativeDriver === true && !NativeAnimatedModule) {
+      if (process.env.NODE_ENV !== 'test') {
+        if (!_warnedMissingNativeAnimated) {
+          console.warn('Animated: `useNativeDriver` is not supported because the native ' + 'animated module is missing. Falling back to JS-based animation. To ' + 'resolve this, add `RCTAnimation` module to this app, or remove ' + '`useNativeDriver`. ' + 'Make sure to run `bundle exec pod install` first. Read more about autolinking: https://github.com/react-native-community/cli/blob/master/docs/autolinking.md');
+          _warnedMissingNativeAnimated = true;
+        }
+      }
+      return false;
+    }
+    return config.useNativeDriver || false;
+  }
+  function transformDataType(value) {
+    if (typeof value !== 'string') {
+      return value;
+    }
+    if (value.endsWith('deg')) {
+      var degrees = parseFloat(value) || 0;
+      return degrees * Math.PI / 180.0;
+    } else if (value.endsWith('rad')) {
+      return parseFloat(value) || 0;
+    } else {
+      return value;
+    }
+  }
+  var _default = exports.default = {
+    API: API,
+    generateNewNodeTag: generateNewNodeTag,
+    generateNewAnimationId: generateNewAnimationId,
+    assertNativeAnimatedModule: assertNativeAnimatedModule,
+    shouldUseNativeDriver: shouldUseNativeDriver,
+    transformDataType: transformDataType,
+    get nativeEventEmitter() {
+      if (!nativeEventEmitter) {
+        nativeEventEmitter = new _NativeEventEmitter.default(_Platform.default.OS !== 'ios' ? null : NativeAnimatedModule);
+      }
+      return nativeEventEmitter;
+    }
+  };
+},391,[1,392,395,221,17,68,52,32,80],"../../node_modules/react-native/src/private/animated/NativeAnimatedHelper.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeAnimatedModule = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativeAnimatedModule"));
+  Object.keys(_NativeAnimatedModule).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeAnimatedModule[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeAnimatedModule[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeAnimatedModule.default;
+},392,[393],"../../node_modules/react-native/Libraries/Animated/NativeAnimatedModule.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _shouldUseTurboAnimatedModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../../../Libraries/Animated/shouldUseTurboAnimatedModule"));
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[2], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var NativeModule = !(0, _shouldUseTurboAnimatedModule.default)() ? TurboModuleRegistry.get('NativeAnimatedModule') : null;
+  var _default = exports.default = NativeModule;
+},393,[1,394,31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeAnimatedModule.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../Utilities/Platform"));
+  function shouldUseTurboAnimatedModule() {
+    return _Platform.default.OS === 'ios' && global.RN$Bridgeless === true;
+  }
+  var _default = exports.default = shouldUseTurboAnimatedModule;
+},394,[1,68],"../../node_modules/react-native/Libraries/Animated/shouldUseTurboAnimatedModule.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeAnimatedTurboModule = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativeAnimatedTurboModule"));
+  Object.keys(_NativeAnimatedTurboModule).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeAnimatedTurboModule[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeAnimatedTurboModule[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeAnimatedTurboModule.default;
+},395,[396],"../../node_modules/react-native/Libraries/Animated/NativeAnimatedTurboModule.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _shouldUseTurboAnimatedModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../../../Libraries/Animated/shouldUseTurboAnimatedModule"));
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[2], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var NativeModule = (0, _shouldUseTurboAnimatedModule.default)() ? TurboModuleRegistry.get('NativeAnimatedTurboModule') : null;
+  var _default = exports.default = NativeModule;
+},396,[1,394,31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeAnimatedTurboModule.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));
+  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/get"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits"));
+  var _classPrivateFieldLooseBase2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/classPrivateFieldLooseBase"));
+  var _classPrivateFieldLooseKey2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "@babel/runtime/helpers/classPrivateFieldLooseKey"));
+  var _NativeAnimatedHelper = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "../../../src/private/animated/NativeAnimatedHelper"));
+  var _AnimatedNode2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "./AnimatedNode"));
+  var _AnimatedObject = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "./AnimatedObject"));
+  var _AnimatedStyle = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[13], "./AnimatedStyle"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[14], "invariant"));
+  var _Object$hasOwn;
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  function createAnimatedProps(inputProps, allowlist) {
+    var nodeKeys = [];
+    var nodes = [];
+    var props = {};
+    var keys = Object.keys(inputProps);
+    for (var ii = 0, length = keys.length; ii < length; ii++) {
+      var _key = keys[ii];
+      var value = inputProps[_key];
+      if (allowlist == null || hasOwn(allowlist, _key)) {
+        var node = void 0;
+        if (_key === 'style') {
+          node = _AnimatedStyle.default.from(value, allowlist == null ? void 0 : allowlist.style);
+        } else if (value instanceof _AnimatedNode2.default) {
+          node = value;
+        } else {
+          node = _AnimatedObject.default.from(value);
+        }
+        if (node == null) {
+          props[_key] = value;
+        } else {
+          nodeKeys.push(_key);
+          nodes.push(node);
+          props[_key] = node;
+        }
+      } else {
+        if (__DEV__) {
+          if (_AnimatedObject.default.from(inputProps[_key]) != null) {
+            console.error(`AnimatedProps: ${_key} is not allowlisted for animation, but it ` + 'contains AnimatedNode values; props allowing animation: ', allowlist);
+          }
+        }
+        props[_key] = value;
+      }
+    }
+    return [nodeKeys, nodes, props];
+  }
+  var _callback = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("callback");
+  var _nodeKeys = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("nodeKeys");
+  var _nodes = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("nodes");
+  var _props = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("props");
+  var _target = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("target");
+  var _connectAnimatedView = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("connectAnimatedView");
+  var _disconnectAnimatedView = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("disconnectAnimatedView");
+  var AnimatedProps = exports.default = /*#__PURE__*/function (_AnimatedNode) {
+    function AnimatedProps(inputProps, callback, allowlist, config) {
+      var _this;
+      (0, _classCallCheck2.default)(this, AnimatedProps);
+      _this = _callSuper(this, AnimatedProps, [config]);
+      Object.defineProperty(_this, _disconnectAnimatedView, {
+        value: _disconnectAnimatedView2
+      });
+      Object.defineProperty(_this, _connectAnimatedView, {
+        value: _connectAnimatedView2
+      });
+      Object.defineProperty(_this, _callback, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(_this, _nodeKeys, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(_this, _nodes, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(_this, _props, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(_this, _target, {
+        writable: true,
+        value: null
+      });
+      var _createAnimatedProps = createAnimatedProps(inputProps, allowlist),
+        _createAnimatedProps2 = (0, _slicedToArray2.default)(_createAnimatedProps, 3),
+        nodeKeys = _createAnimatedProps2[0],
+        nodes = _createAnimatedProps2[1],
+        props = _createAnimatedProps2[2];
+      (0, _classPrivateFieldLooseBase2.default)(_this, _nodeKeys)[_nodeKeys] = nodeKeys;
+      (0, _classPrivateFieldLooseBase2.default)(_this, _nodes)[_nodes] = nodes;
+      (0, _classPrivateFieldLooseBase2.default)(_this, _props)[_props] = props;
+      (0, _classPrivateFieldLooseBase2.default)(_this, _callback)[_callback] = callback;
+      return _this;
+    }
+    (0, _inherits2.default)(AnimatedProps, _AnimatedNode);
+    return (0, _createClass2.default)(AnimatedProps, [{
+      key: "__getValue",
+      value: function __getValue() {
+        var props = {};
+        var keys = Object.keys((0, _classPrivateFieldLooseBase2.default)(this, _props)[_props]);
+        for (var ii = 0, length = keys.length; ii < length; ii++) {
+          var _key2 = keys[ii];
+          var value = (0, _classPrivateFieldLooseBase2.default)(this, _props)[_props][_key2];
+          if (value instanceof _AnimatedNode2.default) {
+            props[_key2] = value.__getValue();
+          } else if (value instanceof _$$_REQUIRE(_dependencyMap[15], "../AnimatedEvent").AnimatedEvent) {
+            props[_key2] = value.__getHandler();
+          } else {
+            props[_key2] = value;
+          }
+        }
+        return props;
+      }
+    }, {
+      key: "__getValueWithStaticProps",
+      value: function __getValueWithStaticProps(staticProps) {
+        var props = Object.assign({}, staticProps);
+        var keys = Object.keys(staticProps);
+        for (var ii = 0, length = keys.length; ii < length; ii++) {
+          var _key3 = keys[ii];
+          var maybeNode = (0, _classPrivateFieldLooseBase2.default)(this, _props)[_props][_key3];
+          if (_key3 === 'style' && maybeNode instanceof _AnimatedStyle.default) {
+            props[_key3] = maybeNode.__getValueWithStaticStyle(staticProps.style);
+          } else if (maybeNode instanceof _AnimatedNode2.default) {
+            props[_key3] = maybeNode.__getValue();
+          } else if (maybeNode instanceof _$$_REQUIRE(_dependencyMap[15], "../AnimatedEvent").AnimatedEvent) {
+            props[_key3] = maybeNode.__getHandler();
+          }
+        }
+        return props;
+      }
+    }, {
+      key: "__getNativeAnimatedEventTuples",
+      value: function __getNativeAnimatedEventTuples() {
+        var tuples = [];
+        var keys = Object.keys((0, _classPrivateFieldLooseBase2.default)(this, _props)[_props]);
+        for (var ii = 0, length = keys.length; ii < length; ii++) {
+          var _key4 = keys[ii];
+          var value = (0, _classPrivateFieldLooseBase2.default)(this, _props)[_props][_key4];
+          if (value instanceof _$$_REQUIRE(_dependencyMap[15], "../AnimatedEvent").AnimatedEvent && value.__isNative) {
+            tuples.push([_key4, value]);
+          }
+        }
+        return tuples;
+      }
+    }, {
+      key: "__getAnimatedValue",
+      value: function __getAnimatedValue() {
+        var props = {};
+        var nodeKeys = (0, _classPrivateFieldLooseBase2.default)(this, _nodeKeys)[_nodeKeys];
+        var nodes = (0, _classPrivateFieldLooseBase2.default)(this, _nodes)[_nodes];
+        for (var ii = 0, length = nodes.length; ii < length; ii++) {
+          var _key5 = nodeKeys[ii];
+          var node = nodes[ii];
+          props[_key5] = node.__getAnimatedValue();
+        }
+        return props;
+      }
+    }, {
+      key: "__attach",
+      value: function __attach() {
+        var nodes = (0, _classPrivateFieldLooseBase2.default)(this, _nodes)[_nodes];
+        for (var ii = 0, length = nodes.length; ii < length; ii++) {
+          var node = nodes[ii];
+          node.__addChild(this);
+        }
+        _superPropGet(AnimatedProps, "__attach", this, 3)([]);
+      }
+    }, {
+      key: "__detach",
+      value: function __detach() {
+        if (this.__isNative && (0, _classPrivateFieldLooseBase2.default)(this, _target)[_target] != null) {
+          (0, _classPrivateFieldLooseBase2.default)(this, _disconnectAnimatedView)[_disconnectAnimatedView]((0, _classPrivateFieldLooseBase2.default)(this, _target)[_target]);
+        }
+        (0, _classPrivateFieldLooseBase2.default)(this, _target)[_target] = null;
+        var nodes = (0, _classPrivateFieldLooseBase2.default)(this, _nodes)[_nodes];
+        for (var ii = 0, length = nodes.length; ii < length; ii++) {
+          var node = nodes[ii];
+          node.__removeChild(this);
+        }
+        _superPropGet(AnimatedProps, "__detach", this, 3)([]);
+      }
+    }, {
+      key: "update",
+      value: function update() {
+        (0, _classPrivateFieldLooseBase2.default)(this, _callback)[_callback]();
+      }
+    }, {
+      key: "__makeNative",
+      value: function __makeNative(platformConfig) {
+        var nodes = (0, _classPrivateFieldLooseBase2.default)(this, _nodes)[_nodes];
+        for (var ii = 0, length = nodes.length; ii < length; ii++) {
+          var node = nodes[ii];
+          node.__makeNative(platformConfig);
+        }
+        if (!this.__isNative) {
+          this.__isNative = true;
+          _superPropGet(AnimatedProps, "__setPlatformConfig", this, 3)([platformConfig]);
+          if ((0, _classPrivateFieldLooseBase2.default)(this, _target)[_target] != null) {
+            (0, _classPrivateFieldLooseBase2.default)(this, _connectAnimatedView)[_connectAnimatedView]((0, _classPrivateFieldLooseBase2.default)(this, _target)[_target]);
+          }
+        }
+      }
+    }, {
+      key: "setNativeView",
+      value: function setNativeView(instance) {
+        var _classPrivateFieldLoo;
+        if (((_classPrivateFieldLoo = (0, _classPrivateFieldLooseBase2.default)(this, _target)[_target]) == null ? void 0 : _classPrivateFieldLoo.instance) === instance) {
+          return;
+        }
+        (0, _classPrivateFieldLooseBase2.default)(this, _target)[_target] = {
+          instance: instance,
+          connectedViewTag: null
+        };
+        if (this.__isNative) {
+          (0, _classPrivateFieldLooseBase2.default)(this, _connectAnimatedView)[_connectAnimatedView]((0, _classPrivateFieldLooseBase2.default)(this, _target)[_target]);
+        }
+      }
+    }, {
+      key: "__restoreDefaultValues",
+      value: function __restoreDefaultValues() {
+        if (this.__isNative) {
+          _NativeAnimatedHelper.default.API.restoreDefaultValues(this.__getNativeTag());
+        }
+      }
+    }, {
+      key: "__getNativeConfig",
+      value: function __getNativeConfig() {
+        var platformConfig = this.__getPlatformConfig();
+        var propsConfig = {};
+        var nodeKeys = (0, _classPrivateFieldLooseBase2.default)(this, _nodeKeys)[_nodeKeys];
+        var nodes = (0, _classPrivateFieldLooseBase2.default)(this, _nodes)[_nodes];
+        for (var ii = 0, length = nodes.length; ii < length; ii++) {
+          var _key6 = nodeKeys[ii];
+          var node = nodes[ii];
+          node.__makeNative(platformConfig);
+          propsConfig[_key6] = node.__getNativeTag();
+        }
+        return {
+          type: 'props',
+          props: propsConfig,
+          debugID: this.__getDebugID()
+        };
+      }
+    }]);
+  }(_AnimatedNode2.default);
+  function _connectAnimatedView2(target) {
+    (0, _invariant.default)(this.__isNative, 'Expected node to be marked as "native"');
+    var viewTag = (0, _$$_REQUIRE(_dependencyMap[16], "../../ReactNative/RendererProxy").findNodeHandle)(target.instance);
+    if (viewTag == null) {
+      if (process.env.NODE_ENV === 'test') {
+        viewTag = -1;
+      } else {
+        throw new Error('Unable to locate attached view in the native tree');
+      }
+    }
+    _NativeAnimatedHelper.default.API.connectAnimatedNodeToView(this.__getNativeTag(), viewTag);
+    target.connectedViewTag = viewTag;
+  }
+  function _disconnectAnimatedView2(target) {
+    (0, _invariant.default)(this.__isNative, 'Expected node to be marked as "native"');
+    var viewTag = target.connectedViewTag;
+    if (viewTag == null) {
+      return;
+    }
+    _NativeAnimatedHelper.default.API.disconnectAnimatedNodeFromView(this.__getNativeTag(), viewTag);
+    target.connectedViewTag = null;
+  }
+  var _hasOwnProp = Object.prototype.hasOwnProperty;
+  var hasOwn = (_Object$hasOwn = Object.hasOwn) != null ? _Object$hasOwn : function (obj, prop) {
+    return _hasOwnProp.call(obj, prop);
+  };
+},397,[1,34,11,12,18,20,21,23,26,27,391,398,399,401,32,405,106],"../../node_modules/react-native/Libraries/Animated/nodes/AnimatedProps.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _classPrivateFieldLooseBase2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classPrivateFieldLooseBase"));
+  var _classPrivateFieldLooseKey2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classPrivateFieldLooseKey"));
+  var _NativeAnimatedHelper = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../../../src/private/animated/NativeAnimatedHelper"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "invariant"));
+  var _uniqueId = 1;
+  var _assertNativeAnimatedModule2 = function _assertNativeAnimatedModule() {
+    _NativeAnimatedHelper.default.assertNativeAnimatedModule();
+    _assertNativeAnimatedModule2 = null;
+  };
+  var _listeners = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("listeners");
+  var AnimatedNode = exports.default = /*#__PURE__*/function () {
+    function AnimatedNode(config) {
+      (0, _classCallCheck2.default)(this, AnimatedNode);
+      Object.defineProperty(this, _listeners, {
+        writable: true,
+        value: void 0
+      });
+      this._platformConfig = undefined;
+      this.__isNative = false;
+      this.__nativeTag = undefined;
+      this.__debugID = undefined;
+      (0, _classPrivateFieldLooseBase2.default)(this, _listeners)[_listeners] = new Map();
+      if (__DEV__) {
+        this.__debugID = config == null ? void 0 : config.debugID;
+      }
+    }
+    return (0, _createClass2.default)(AnimatedNode, [{
+      key: "__attach",
+      value: function __attach() {}
+    }, {
+      key: "__detach",
+      value: function __detach() {
+        this.removeAllListeners();
+        if (this.__isNative && this.__nativeTag != null) {
+          _NativeAnimatedHelper.default.API.dropAnimatedNode(this.__nativeTag);
+          this.__nativeTag = undefined;
+        }
+      }
+    }, {
+      key: "__getValue",
+      value: function __getValue() {}
+    }, {
+      key: "__getAnimatedValue",
+      value: function __getAnimatedValue() {
+        return this.__getValue();
+      }
+    }, {
+      key: "__addChild",
+      value: function __addChild(child) {}
+    }, {
+      key: "__removeChild",
+      value: function __removeChild(child) {}
+    }, {
+      key: "__getChildren",
+      value: function __getChildren() {
+        return [];
+      }
+    }, {
+      key: "__makeNative",
+      value: function __makeNative(platformConfig) {
+        (0, _invariant.default)(this.__isNative, 'This node cannot be made a "native" animated node');
+        this._platformConfig = platformConfig;
+      }
+    }, {
+      key: "addListener",
+      value: function addListener(callback) {
+        var id = String(_uniqueId++);
+        (0, _classPrivateFieldLooseBase2.default)(this, _listeners)[_listeners].set(id, callback);
+        return id;
+      }
+    }, {
+      key: "removeListener",
+      value: function removeListener(id) {
+        (0, _classPrivateFieldLooseBase2.default)(this, _listeners)[_listeners].delete(id);
+      }
+    }, {
+      key: "removeAllListeners",
+      value: function removeAllListeners() {
+        (0, _classPrivateFieldLooseBase2.default)(this, _listeners)[_listeners].clear();
+      }
+    }, {
+      key: "hasListeners",
+      value: function hasListeners() {
+        return (0, _classPrivateFieldLooseBase2.default)(this, _listeners)[_listeners].size > 0;
+      }
+    }, {
+      key: "__onAnimatedValueUpdateReceived",
+      value: function __onAnimatedValueUpdateReceived(value, offset) {
+        this.__callListeners(value + offset);
+      }
+    }, {
+      key: "__callListeners",
+      value: function __callListeners(value) {
+        var event = {
+          value: value
+        };
+        (0, _classPrivateFieldLooseBase2.default)(this, _listeners)[_listeners].forEach(function (listener) {
+          listener(event);
+        });
+      }
+    }, {
+      key: "__getNativeTag",
+      value: function __getNativeTag() {
+        var nativeTag = this.__nativeTag;
+        if (nativeTag == null) {
+          _assertNativeAnimatedModule2 == null || _assertNativeAnimatedModule2();
+          (0, _invariant.default)(this.__isNative, 'Attempt to get native tag from node not marked as "native"');
+          nativeTag = _NativeAnimatedHelper.default.generateNewNodeTag();
+          this.__nativeTag = nativeTag;
+          var config = this.__getNativeConfig();
+          if (this._platformConfig) {
+            config.platformConfig = this._platformConfig;
+          }
+          _NativeAnimatedHelper.default.API.createAnimatedNode(nativeTag, config);
+        }
+        return nativeTag;
+      }
+    }, {
+      key: "__getNativeConfig",
+      value: function __getNativeConfig() {
+        throw new Error('This JS animated node type cannot be used as native animated node');
+      }
+    }, {
+      key: "__getPlatformConfig",
+      value: function __getPlatformConfig() {
+        return this._platformConfig;
+      }
+    }, {
+      key: "__setPlatformConfig",
+      value: function __setPlatformConfig(platformConfig) {
+        this._platformConfig = platformConfig;
+      }
+    }, {
+      key: "toJSON",
+      value: function toJSON() {
+        return this.__getValue();
+      }
+    }, {
+      key: "__getDebugID",
+      value: function __getDebugID() {
+        if (__DEV__) {
+          return this.__debugID;
+        }
+        return undefined;
+      }
+    }]);
+  }();
+},398,[1,11,12,26,27,391,32],"../../node_modules/react-native/Libraries/Animated/nodes/AnimatedNode.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  exports.isPlainObject = isPlainObject;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _classPrivateFieldLooseBase2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/classPrivateFieldLooseBase"));
+  var _classPrivateFieldLooseKey2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/classPrivateFieldLooseKey"));
+  var _AnimatedNode = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./AnimatedNode"));
+  var _AnimatedWithChildren2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./AnimatedWithChildren"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[11], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  var MAX_DEPTH = 5;
+  function isPlainObject(value) {
+    return value !== null && typeof value === 'object' && Object.getPrototypeOf(value).isPrototypeOf(Object) && !React.isValidElement(value);
+  }
+  function flatAnimatedNodes(value) {
+    var nodes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    var depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    if (depth >= MAX_DEPTH) {
+      return nodes;
+    }
+    if (value instanceof _AnimatedNode.default) {
+      nodes.push(value);
+    } else if (Array.isArray(value)) {
+      for (var ii = 0, length = value.length; ii < length; ii++) {
+        var element = value[ii];
+        flatAnimatedNodes(element, nodes, depth + 1);
+      }
+    } else if (isPlainObject(value)) {
+      var keys = Object.keys(value);
+      for (var _ii = 0, _length = keys.length; _ii < _length; _ii++) {
+        var key = keys[_ii];
+        flatAnimatedNodes(value[key], nodes, depth + 1);
+      }
+    }
+    return nodes;
+  }
+  function mapAnimatedNodes(value, fn) {
+    var depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    if (depth >= MAX_DEPTH) {
+      return value;
+    }
+    if (value instanceof _AnimatedNode.default) {
+      return fn(value);
+    } else if (Array.isArray(value)) {
+      return value.map(function (element) {
+        return mapAnimatedNodes(element, fn, depth + 1);
+      });
+    } else if (isPlainObject(value)) {
+      var result = {};
+      var keys = Object.keys(value);
+      for (var ii = 0, length = keys.length; ii < length; ii++) {
+        var key = keys[ii];
+        result[key] = mapAnimatedNodes(value[key], fn, depth + 1);
+      }
+      return result;
+    } else {
+      return value;
+    }
+  }
+  var _nodes = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("nodes");
+  var AnimatedObject = exports.default = /*#__PURE__*/function (_AnimatedWithChildren) {
+    function AnimatedObject(nodes, value, config) {
+      var _this;
+      (0, _classCallCheck2.default)(this, AnimatedObject);
+      _this = _callSuper(this, AnimatedObject, [config]);
+      Object.defineProperty(_this, _nodes, {
+        writable: true,
+        value: void 0
+      });
+      (0, _classPrivateFieldLooseBase2.default)(_this, _nodes)[_nodes] = nodes;
+      _this._value = value;
+      return _this;
+    }
+    (0, _inherits2.default)(AnimatedObject, _AnimatedWithChildren);
+    return (0, _createClass2.default)(AnimatedObject, [{
+      key: "__getValue",
+      value: function __getValue() {
+        return mapAnimatedNodes(this._value, function (node) {
+          return node.__getValue();
+        });
+      }
+    }, {
+      key: "__getValueWithStaticObject",
+      value: function __getValueWithStaticObject(staticObject) {
+        var nodes = (0, _classPrivateFieldLooseBase2.default)(this, _nodes)[_nodes];
+        var index = 0;
+        return mapAnimatedNodes(staticObject, function () {
+          return nodes[index++].__getValue();
+        });
+      }
+    }, {
+      key: "__getAnimatedValue",
+      value: function __getAnimatedValue() {
+        return mapAnimatedNodes(this._value, function (node) {
+          return node.__getAnimatedValue();
+        });
+      }
+    }, {
+      key: "__attach",
+      value: function __attach() {
+        var nodes = (0, _classPrivateFieldLooseBase2.default)(this, _nodes)[_nodes];
+        for (var ii = 0, length = nodes.length; ii < length; ii++) {
+          var node = nodes[ii];
+          node.__addChild(this);
+        }
+        _superPropGet(AnimatedObject, "__attach", this, 3)([]);
+      }
+    }, {
+      key: "__detach",
+      value: function __detach() {
+        var nodes = (0, _classPrivateFieldLooseBase2.default)(this, _nodes)[_nodes];
+        for (var ii = 0, length = nodes.length; ii < length; ii++) {
+          var node = nodes[ii];
+          node.__removeChild(this);
+        }
+        _superPropGet(AnimatedObject, "__detach", this, 3)([]);
+      }
+    }, {
+      key: "__makeNative",
+      value: function __makeNative(platformConfig) {
+        var nodes = (0, _classPrivateFieldLooseBase2.default)(this, _nodes)[_nodes];
+        for (var ii = 0, length = nodes.length; ii < length; ii++) {
+          var node = nodes[ii];
+          node.__makeNative(platformConfig);
+        }
+        _superPropGet(AnimatedObject, "__makeNative", this, 3)([platformConfig]);
+      }
+    }, {
+      key: "__getNativeConfig",
+      value: function __getNativeConfig() {
+        return {
+          type: 'object',
+          value: mapAnimatedNodes(this._value, function (node) {
+            return {
+              nodeTag: node.__getNativeTag()
+            };
+          }),
+          debugID: this.__getDebugID()
+        };
+      }
+    }], [{
+      key: "from",
+      value: function from(value) {
+        var nodes = flatAnimatedNodes(value);
+        if (nodes.length === 0) {
+          return null;
+        }
+        return new AnimatedObject(nodes, value);
+      }
+    }]);
+  }(_AnimatedWithChildren2.default);
+},399,[1,11,12,18,20,21,23,26,27,398,400,73],"../../node_modules/react-native/Libraries/Animated/nodes/AnimatedObject.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _NativeAnimatedHelper2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../../../src/private/animated/NativeAnimatedHelper"));
+  var _AnimatedNode2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./AnimatedNode"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  var _NativeAnimatedHelper = _NativeAnimatedHelper2.default.API,
+    connectAnimatedNodes = _NativeAnimatedHelper.connectAnimatedNodes,
+    disconnectAnimatedNodes = _NativeAnimatedHelper.disconnectAnimatedNodes;
+  var AnimatedWithChildren = exports.default = /*#__PURE__*/function (_AnimatedNode) {
+    function AnimatedWithChildren() {
+      var _this;
+      (0, _classCallCheck2.default)(this, AnimatedWithChildren);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _callSuper(this, AnimatedWithChildren, [].concat(args));
+      _this._children = [];
+      return _this;
+    }
+    (0, _inherits2.default)(AnimatedWithChildren, _AnimatedNode);
+    return (0, _createClass2.default)(AnimatedWithChildren, [{
+      key: "__makeNative",
+      value: function __makeNative(platformConfig) {
+        if (!this.__isNative) {
+          this.__isNative = true;
+          var children = this._children;
+          var length = children.length;
+          if (length > 0) {
+            for (var ii = 0; ii < length; ii++) {
+              var child = children[ii];
+              child.__makeNative(platformConfig);
+              connectAnimatedNodes(this.__getNativeTag(), child.__getNativeTag());
+            }
+          }
+        }
+        _superPropGet(AnimatedWithChildren, "__makeNative", this, 3)([platformConfig]);
+      }
+    }, {
+      key: "__addChild",
+      value: function __addChild(child) {
+        if (this._children.length === 0) {
+          this.__attach();
+        }
+        this._children.push(child);
+        if (this.__isNative) {
+          child.__makeNative(this.__getPlatformConfig());
+          connectAnimatedNodes(this.__getNativeTag(), child.__getNativeTag());
+        }
+      }
+    }, {
+      key: "__removeChild",
+      value: function __removeChild(child) {
+        var index = this._children.indexOf(child);
+        if (index === -1) {
+          console.warn("Trying to remove a child that doesn't exist");
+          return;
+        }
+        if (this.__isNative && child.__isNative) {
+          disconnectAnimatedNodes(this.__getNativeTag(), child.__getNativeTag());
+        }
+        this._children.splice(index, 1);
+        if (this._children.length === 0) {
+          this.__detach();
+        }
+      }
+    }, {
+      key: "__getChildren",
+      value: function __getChildren() {
+        return this._children;
+      }
+    }, {
+      key: "__callListeners",
+      value: function __callListeners(value) {
+        _superPropGet(AnimatedWithChildren, "__callListeners", this, 3)([value]);
+        if (!this.__isNative) {
+          var children = this._children;
+          for (var ii = 0, length = children.length; ii < length; ii++) {
+            var child = children[ii];
+            if (child.__getValue) {
+              child.__callListeners(child.__getValue());
+            }
+          }
+        }
+      }
+    }]);
+  }(_AnimatedNode2.default);
+},400,[1,11,12,18,20,21,23,391,398],"../../node_modules/react-native/Libraries/Animated/nodes/AnimatedWithChildren.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));
+  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/get"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits"));
+  var _classPrivateFieldLooseBase2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/classPrivateFieldLooseBase"));
+  var _classPrivateFieldLooseKey2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "@babel/runtime/helpers/classPrivateFieldLooseKey"));
+  var ReactNativeFeatureFlags = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[10], "../../../src/private/featureflags/ReactNativeFeatureFlags"));
+  var _flattenStyle = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "../../StyleSheet/flattenStyle"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "../../Utilities/Platform"));
+  var _AnimatedNode = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[13], "./AnimatedNode"));
+  var _AnimatedObject = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[14], "./AnimatedObject"));
+  var _AnimatedTransform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[15], "./AnimatedTransform"));
+  var _AnimatedWithChildren2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[16], "./AnimatedWithChildren"));
+  var _Object$hasOwn;
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  function createAnimatedStyle(inputStyle, allowlist, keepUnanimatedValues) {
+    var nodeKeys = [];
+    var nodes = [];
+    var style = {};
+    var keys = Object.keys(inputStyle);
+    for (var ii = 0, length = keys.length; ii < length; ii++) {
+      var key = keys[ii];
+      var value = inputStyle[key];
+      if (allowlist == null || hasOwn(allowlist, key)) {
+        var node = void 0;
+        if (value != null && key === 'transform') {
+          node = ReactNativeFeatureFlags.shouldUseAnimatedObjectForTransform() ? _AnimatedObject.default.from(value) : _AnimatedTransform.default.from(value);
+        } else if (value instanceof _AnimatedNode.default) {
+          node = value;
+        } else {
+          node = _AnimatedObject.default.from(value);
+        }
+        if (node == null) {
+          if (keepUnanimatedValues) {
+            style[key] = value;
+          }
+        } else {
+          nodeKeys.push(key);
+          nodes.push(node);
+          style[key] = node;
+        }
+      } else {
+        if (__DEV__) {
+          if (_AnimatedObject.default.from(inputStyle[key]) != null) {
+            console.error(`AnimatedStyle: ${key} is not allowlisted for animation, but it ` + 'contains AnimatedNode values; styles allowing animation: ', allowlist);
+          }
+        }
+        if (keepUnanimatedValues) {
+          style[key] = value;
+        }
+      }
+    }
+    return [nodeKeys, nodes, style];
+  }
+  var _inputStyle = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("inputStyle");
+  var _nodeKeys = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("nodeKeys");
+  var _nodes = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("nodes");
+  var _style = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("style");
+  var AnimatedStyle = exports.default = /*#__PURE__*/function (_AnimatedWithChildren) {
+    function AnimatedStyle(nodeKeys, nodes, style, inputStyle, config) {
+      var _this;
+      (0, _classCallCheck2.default)(this, AnimatedStyle);
+      _this = _callSuper(this, AnimatedStyle, [config]);
+      Object.defineProperty(_this, _inputStyle, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(_this, _nodeKeys, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(_this, _nodes, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(_this, _style, {
+        writable: true,
+        value: void 0
+      });
+      (0, _classPrivateFieldLooseBase2.default)(_this, _nodeKeys)[_nodeKeys] = nodeKeys;
+      (0, _classPrivateFieldLooseBase2.default)(_this, _nodes)[_nodes] = nodes;
+      (0, _classPrivateFieldLooseBase2.default)(_this, _style)[_style] = style;
+      (0, _classPrivateFieldLooseBase2.default)(_this, _inputStyle)[_inputStyle] = inputStyle;
+      return _this;
+    }
+    (0, _inherits2.default)(AnimatedStyle, _AnimatedWithChildren);
+    return (0, _createClass2.default)(AnimatedStyle, [{
+      key: "__getValue",
+      value: function __getValue() {
+        var style = {};
+        var keys = Object.keys((0, _classPrivateFieldLooseBase2.default)(this, _style)[_style]);
+        for (var ii = 0, length = keys.length; ii < length; ii++) {
+          var key = keys[ii];
+          var value = (0, _classPrivateFieldLooseBase2.default)(this, _style)[_style][key];
+          if (value instanceof _AnimatedNode.default) {
+            style[key] = value.__getValue();
+          } else {
+            style[key] = value;
+          }
+        }
+        return _Platform.default.OS === 'web' ? [(0, _classPrivateFieldLooseBase2.default)(this, _inputStyle)[_inputStyle], style] : style;
+      }
+    }, {
+      key: "__getValueWithStaticStyle",
+      value: function __getValueWithStaticStyle(staticStyle) {
+        var flatStaticStyle = (0, _flattenStyle.default)(staticStyle);
+        var style = flatStaticStyle == null ? {} : flatStaticStyle === staticStyle ? Object.assign({}, flatStaticStyle) : flatStaticStyle;
+        var keys = Object.keys(style);
+        for (var ii = 0, length = keys.length; ii < length; ii++) {
+          var key = keys[ii];
+          var maybeNode = (0, _classPrivateFieldLooseBase2.default)(this, _style)[_style][key];
+          if (key === 'transform' && maybeNode instanceof _AnimatedTransform.default) {
+            style[key] = maybeNode.__getValueWithStaticTransforms(Array.isArray(style[key]) ? style[key] : []);
+          } else if (maybeNode instanceof _AnimatedObject.default) {
+            style[key] = maybeNode.__getValueWithStaticObject(style[key]);
+          } else if (maybeNode instanceof _AnimatedNode.default) {
+            style[key] = maybeNode.__getValue();
+          }
+        }
+        return _Platform.default.OS === 'web' ? [(0, _classPrivateFieldLooseBase2.default)(this, _inputStyle)[_inputStyle], style] : style;
+      }
+    }, {
+      key: "__getAnimatedValue",
+      value: function __getAnimatedValue() {
+        var style = {};
+        var nodeKeys = (0, _classPrivateFieldLooseBase2.default)(this, _nodeKeys)[_nodeKeys];
+        var nodes = (0, _classPrivateFieldLooseBase2.default)(this, _nodes)[_nodes];
+        for (var ii = 0, length = nodes.length; ii < length; ii++) {
+          var key = nodeKeys[ii];
+          var node = nodes[ii];
+          style[key] = node.__getAnimatedValue();
+        }
+        return style;
+      }
+    }, {
+      key: "__attach",
+      value: function __attach() {
+        var nodes = (0, _classPrivateFieldLooseBase2.default)(this, _nodes)[_nodes];
+        for (var ii = 0, length = nodes.length; ii < length; ii++) {
+          var node = nodes[ii];
+          node.__addChild(this);
+        }
+        _superPropGet(AnimatedStyle, "__attach", this, 3)([]);
+      }
+    }, {
+      key: "__detach",
+      value: function __detach() {
+        var nodes = (0, _classPrivateFieldLooseBase2.default)(this, _nodes)[_nodes];
+        for (var ii = 0, length = nodes.length; ii < length; ii++) {
+          var node = nodes[ii];
+          node.__removeChild(this);
+        }
+        _superPropGet(AnimatedStyle, "__detach", this, 3)([]);
+      }
+    }, {
+      key: "__makeNative",
+      value: function __makeNative(platformConfig) {
+        var nodes = (0, _classPrivateFieldLooseBase2.default)(this, _nodes)[_nodes];
+        for (var ii = 0, length = nodes.length; ii < length; ii++) {
+          var node = nodes[ii];
+          node.__makeNative(platformConfig);
+        }
+        _superPropGet(AnimatedStyle, "__makeNative", this, 3)([platformConfig]);
+      }
+    }, {
+      key: "__getNativeConfig",
+      value: function __getNativeConfig() {
+        var platformConfig = this.__getPlatformConfig();
+        var styleConfig = {};
+        var nodeKeys = (0, _classPrivateFieldLooseBase2.default)(this, _nodeKeys)[_nodeKeys];
+        var nodes = (0, _classPrivateFieldLooseBase2.default)(this, _nodes)[_nodes];
+        for (var ii = 0, length = nodes.length; ii < length; ii++) {
+          var key = nodeKeys[ii];
+          var node = nodes[ii];
+          node.__makeNative(platformConfig);
+          styleConfig[key] = node.__getNativeTag();
+        }
+        if (__DEV__) {
+          (0, _$$_REQUIRE(_dependencyMap[17], "../../../src/private/animated/NativeAnimatedValidation").validateStyles)(styleConfig);
+        }
+        return {
+          type: 'style',
+          style: styleConfig,
+          debugID: this.__getDebugID()
+        };
+      }
+    }], [{
+      key: "from",
+      value: function from(inputStyle, allowlist) {
+        var flatStyle = (0, _flattenStyle.default)(inputStyle);
+        if (flatStyle == null) {
+          return null;
+        }
+        var _createAnimatedStyle = createAnimatedStyle(flatStyle, allowlist, _Platform.default.OS !== 'web'),
+          _createAnimatedStyle2 = (0, _slicedToArray2.default)(_createAnimatedStyle, 3),
+          nodeKeys = _createAnimatedStyle2[0],
+          nodes = _createAnimatedStyle2[1],
+          style = _createAnimatedStyle2[2];
+        if (nodes.length === 0) {
+          return null;
+        }
+        return new AnimatedStyle(nodeKeys, nodes, style, inputStyle);
+      }
+    }]);
+  }(_AnimatedWithChildren2.default);
+  var _hasOwnProp = Object.prototype.hasOwnProperty;
+  var hasOwn = (_Object$hasOwn = Object.hasOwn) != null ? _Object$hasOwn : function (obj, prop) {
+    return _hasOwnProp.call(obj, prop);
+  };
+},401,[1,34,11,12,18,20,21,23,26,27,52,9,68,398,399,402,400,403],"../../node_modules/react-native/Libraries/Animated/nodes/AnimatedStyle.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _classPrivateFieldLooseBase2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/classPrivateFieldLooseBase"));
+  var _classPrivateFieldLooseKey2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/classPrivateFieldLooseKey"));
+  var _NativeAnimatedHelper = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "../../../src/private/animated/NativeAnimatedHelper"));
+  var _AnimatedNode = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./AnimatedNode"));
+  var _AnimatedWithChildren2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "./AnimatedWithChildren"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  function flatAnimatedNodes(transforms) {
+    var nodes = [];
+    for (var ii = 0, length = transforms.length; ii < length; ii++) {
+      var transform = transforms[ii];
+      for (var key in transform) {
+        var value = transform[key];
+        if (value instanceof _AnimatedNode.default) {
+          nodes.push(value);
+        }
+      }
+    }
+    return nodes;
+  }
+  var _nodes = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("nodes");
+  var AnimatedTransform = exports.default = /*#__PURE__*/function (_AnimatedWithChildren) {
+    function AnimatedTransform(nodes, transforms, config) {
+      var _this;
+      (0, _classCallCheck2.default)(this, AnimatedTransform);
+      _this = _callSuper(this, AnimatedTransform, [config]);
+      Object.defineProperty(_this, _nodes, {
+        writable: true,
+        value: void 0
+      });
+      (0, _classPrivateFieldLooseBase2.default)(_this, _nodes)[_nodes] = nodes;
+      _this._transforms = transforms;
+      return _this;
+    }
+    (0, _inherits2.default)(AnimatedTransform, _AnimatedWithChildren);
+    return (0, _createClass2.default)(AnimatedTransform, [{
+      key: "__makeNative",
+      value: function __makeNative(platformConfig) {
+        var nodes = (0, _classPrivateFieldLooseBase2.default)(this, _nodes)[_nodes];
+        for (var ii = 0, length = nodes.length; ii < length; ii++) {
+          var node = nodes[ii];
+          node.__makeNative(platformConfig);
+        }
+        _superPropGet(AnimatedTransform, "__makeNative", this, 3)([platformConfig]);
+      }
+    }, {
+      key: "__getValue",
+      value: function __getValue() {
+        return mapTransforms(this._transforms, function (animatedNode) {
+          return animatedNode.__getValue();
+        });
+      }
+    }, {
+      key: "__getValueWithStaticTransforms",
+      value: function __getValueWithStaticTransforms(staticTransforms) {
+        var values = [];
+        mapTransforms(this._transforms, function (node) {
+          values.push(node.__getValue());
+        });
+        return mapTransforms(staticTransforms, function () {
+          return values.shift();
+        });
+      }
+    }, {
+      key: "__getAnimatedValue",
+      value: function __getAnimatedValue() {
+        return mapTransforms(this._transforms, function (animatedNode) {
+          return animatedNode.__getAnimatedValue();
+        });
+      }
+    }, {
+      key: "__attach",
+      value: function __attach() {
+        var nodes = (0, _classPrivateFieldLooseBase2.default)(this, _nodes)[_nodes];
+        for (var ii = 0, length = nodes.length; ii < length; ii++) {
+          var node = nodes[ii];
+          node.__addChild(this);
+        }
+        _superPropGet(AnimatedTransform, "__attach", this, 3)([]);
+      }
+    }, {
+      key: "__detach",
+      value: function __detach() {
+        var nodes = (0, _classPrivateFieldLooseBase2.default)(this, _nodes)[_nodes];
+        for (var ii = 0, length = nodes.length; ii < length; ii++) {
+          var node = nodes[ii];
+          node.__removeChild(this);
+        }
+        _superPropGet(AnimatedTransform, "__detach", this, 3)([]);
+      }
+    }, {
+      key: "__getNativeConfig",
+      value: function __getNativeConfig() {
+        var transformsConfig = [];
+        var transforms = this._transforms;
+        for (var ii = 0, length = transforms.length; ii < length; ii++) {
+          var transform = transforms[ii];
+          for (var key in transform) {
+            var value = transform[key];
+            if (value instanceof _AnimatedNode.default) {
+              transformsConfig.push({
+                type: 'animated',
+                property: key,
+                nodeTag: value.__getNativeTag()
+              });
+            } else {
+              transformsConfig.push({
+                type: 'static',
+                property: key,
+                value: _NativeAnimatedHelper.default.transformDataType(value)
+              });
+            }
+          }
+        }
+        if (__DEV__) {
+          (0, _$$_REQUIRE(_dependencyMap[12], "../../../src/private/animated/NativeAnimatedValidation").validateTransform)(transformsConfig);
+        }
+        return {
+          type: 'transform',
+          transforms: transformsConfig,
+          debugID: this.__getDebugID()
+        };
+      }
+    }], [{
+      key: "from",
+      value: function from(transforms) {
+        var nodes = flatAnimatedNodes(Array.isArray(transforms) ? transforms : []);
+        if (nodes.length === 0) {
+          return null;
+        }
+        return new AnimatedTransform(nodes, transforms);
+      }
+    }]);
+  }(_AnimatedWithChildren2.default);
+  function mapTransforms(transforms, mapFunction) {
+    return transforms.map(function (transform) {
+      var result = {};
+      for (var key in transform) {
+        var value = transform[key];
+        if (value instanceof _AnimatedNode.default) {
+          result[key] = mapFunction(value);
+        } else if (Array.isArray(value)) {
+          result[key] = value.map(function (element) {
+            return element instanceof _AnimatedNode.default ? mapFunction(element) : element;
+          });
+        } else if (typeof value === 'object') {
+          var object = {};
+          for (var propertyName in value) {
+            var propertyValue = value[propertyName];
+            object[propertyName] = propertyValue instanceof _AnimatedNode.default ? mapFunction(propertyValue) : propertyValue;
+          }
+          result[key] = object;
+        } else {
+          result[key] = value;
+        }
+      }
+      return result;
+    });
+  }
+},402,[1,11,12,18,20,21,23,26,27,391,398,400,403],"../../node_modules/react-native/Libraries/Animated/nodes/AnimatedTransform.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.validateInterpolation = validateInterpolation;
+  exports.validateStyles = validateStyles;
+  exports.validateTransform = validateTransform;
+  function validateInterpolation(config) {
+    for (var _key in config) {
+      if (_key !== 'debugID' && !(0, _$$_REQUIRE(_dependencyMap[0], "../../../Libraries/Animated/NativeAnimatedAllowlist").isSupportedInterpolationParam)(_key)) {
+        console.error(`Interpolation property '${_key}' is not supported by native animated module`);
+      }
+    }
+  }
+  function validateStyles(styles) {
+    for (var _key2 in styles) {
+      if (!(0, _$$_REQUIRE(_dependencyMap[0], "../../../Libraries/Animated/NativeAnimatedAllowlist").isSupportedStyleProp)(_key2)) {
+        console.error(`Style property '${_key2}' is not supported by native animated module`);
+      }
+    }
+  }
+  function validateTransform(configs) {
+    configs.forEach(function (config) {
+      if (!(0, _$$_REQUIRE(_dependencyMap[0], "../../../Libraries/Animated/NativeAnimatedAllowlist").isSupportedTransformProp)(config.property)) {
+        console.error(`Property '${config.property}' is not supported by native animated module`);
+      }
+    });
+  }
+},403,[404],"../../node_modules/react-native/src/private/animated/NativeAnimatedValidation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.allowInterpolationParam = allowInterpolationParam;
+  exports.allowStyleProp = allowStyleProp;
+  exports.allowTransformProp = allowTransformProp;
+  exports.default = void 0;
+  exports.isSupportedColorStyleProp = isSupportedColorStyleProp;
+  exports.isSupportedInterpolationParam = isSupportedInterpolationParam;
+  exports.isSupportedStyleProp = isSupportedStyleProp;
+  exports.isSupportedTransformProp = isSupportedTransformProp;
+  var ReactNativeFeatureFlags = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/featureflags/ReactNativeFeatureFlags"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var SUPPORTED_COLOR_STYLES = {
+    backgroundColor: true,
+    borderBottomColor: true,
+    borderColor: true,
+    borderEndColor: true,
+    borderLeftColor: true,
+    borderRightColor: true,
+    borderStartColor: true,
+    borderTopColor: true,
+    color: true,
+    tintColor: true
+  };
+  var SUPPORTED_STYLES = Object.assign({}, SUPPORTED_COLOR_STYLES, {
+    borderBottomEndRadius: true,
+    borderBottomLeftRadius: true,
+    borderBottomRightRadius: true,
+    borderBottomStartRadius: true,
+    borderEndEndRadius: true,
+    borderEndStartRadius: true,
+    borderRadius: true,
+    borderTopEndRadius: true,
+    borderTopLeftRadius: true,
+    borderTopRightRadius: true,
+    borderTopStartRadius: true,
+    borderStartEndRadius: true,
+    borderStartStartRadius: true,
+    elevation: true,
+    opacity: true,
+    transform: true,
+    zIndex: true,
+    shadowOpacity: true,
+    shadowRadius: true,
+    scaleX: true,
+    scaleY: true,
+    translateX: true,
+    translateY: true
+  });
+  var SUPPORTED_TRANSFORMS = Object.assign({
+    translateX: true,
+    translateY: true,
+    scale: true,
+    scaleX: true,
+    scaleY: true,
+    rotate: true,
+    rotateX: true,
+    rotateY: true,
+    rotateZ: true,
+    perspective: true,
+    skewX: true,
+    skewY: true
+  }, ReactNativeFeatureFlags.shouldUseAnimatedObjectForTransform() ? {
+    matrix: true
+  } : {});
+  var SUPPORTED_INTERPOLATION_PARAMS = {
+    inputRange: true,
+    outputRange: true,
+    extrapolate: true,
+    extrapolateRight: true,
+    extrapolateLeft: true
+  };
+  var _default = exports.default = {
+    style: SUPPORTED_STYLES
+  };
+  function allowInterpolationParam(param) {
+    SUPPORTED_INTERPOLATION_PARAMS[param] = true;
+  }
+  function allowStyleProp(prop) {
+    SUPPORTED_STYLES[prop] = true;
+  }
+  function allowTransformProp(prop) {
+    SUPPORTED_TRANSFORMS[prop] = true;
+  }
+  function isSupportedColorStyleProp(prop) {
+    return SUPPORTED_COLOR_STYLES.hasOwnProperty(prop);
+  }
+  function isSupportedInterpolationParam(param) {
+    return SUPPORTED_INTERPOLATION_PARAMS.hasOwnProperty(param);
+  }
+  function isSupportedStyleProp(prop) {
+    return SUPPORTED_STYLES.hasOwnProperty(prop);
+  }
+  function isSupportedTransformProp(prop) {
+    return SUPPORTED_TRANSFORMS.hasOwnProperty(prop);
+  }
+},404,[52],"../../node_modules/react-native/Libraries/Animated/NativeAnimatedAllowlist.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.AnimatedEvent = void 0;
+  exports.attachNativeEvent = attachNativeEvent;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _NativeAnimatedHelper = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../src/private/animated/NativeAnimatedHelper"));
+  var _AnimatedValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./nodes/AnimatedValue"));
+  var _AnimatedValueXY = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./nodes/AnimatedValueXY"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "invariant"));
+  function attachNativeEvent(viewRef, eventName, argMapping, platformConfig) {
+    var eventMappings = [];
+    var _traverse = function traverse(value, path) {
+      if (value instanceof _AnimatedValue.default) {
+        value.__makeNative(platformConfig);
+        eventMappings.push({
+          nativeEventPath: path,
+          animatedValueTag: value.__getNativeTag()
+        });
+      } else if (value instanceof _AnimatedValueXY.default) {
+        _traverse(value.x, path.concat('x'));
+        _traverse(value.y, path.concat('y'));
+      } else if (typeof value === 'object') {
+        for (var _key in value) {
+          _traverse(value[_key], path.concat(_key));
+        }
+      }
+    };
+    (0, _invariant.default)(argMapping[0] && argMapping[0].nativeEvent, 'Native driven events only support animated values contained inside `nativeEvent`.');
+    _traverse(argMapping[0].nativeEvent, []);
+    var viewTag = (0, _$$_REQUIRE(_dependencyMap[7], "../ReactNative/RendererProxy").findNodeHandle)(viewRef);
+    if (viewTag != null) {
+      eventMappings.forEach(function (mapping) {
+        _NativeAnimatedHelper.default.API.addAnimatedEventToView(viewTag, eventName, mapping);
+      });
+    }
+    return {
+      detach: function detach() {
+        if (viewTag != null) {
+          eventMappings.forEach(function (mapping) {
+            _NativeAnimatedHelper.default.API.removeAnimatedEventFromView(viewTag, eventName, mapping.animatedValueTag);
+          });
+        }
+      }
+    };
+  }
+  function validateMapping(argMapping, args) {
+    var _validate = function validate(recMapping, recEvt, key) {
+      if (recMapping instanceof _AnimatedValue.default) {
+        (0, _invariant.default)(typeof recEvt === 'number', 'Bad mapping of event key ' + key + ', should be number but got ' + typeof recEvt);
+        return;
+      }
+      if (recMapping instanceof _AnimatedValueXY.default) {
+        (0, _invariant.default)(typeof recEvt.x === 'number' && typeof recEvt.y === 'number', 'Bad mapping of event key ' + key + ', should be XY but got ' + recEvt);
+        return;
+      }
+      if (typeof recEvt === 'number') {
+        (0, _invariant.default)(recMapping instanceof _AnimatedValue.default, 'Bad mapping of type ' + typeof recMapping + ' for key ' + key + ', event value must map to AnimatedValue');
+        return;
+      }
+      (0, _invariant.default)(typeof recMapping === 'object', 'Bad mapping of type ' + typeof recMapping + ' for key ' + key);
+      (0, _invariant.default)(typeof recEvt === 'object', 'Bad event of type ' + typeof recEvt + ' for key ' + key);
+      for (var mappingKey in recMapping) {
+        _validate(recMapping[mappingKey], recEvt[mappingKey], mappingKey);
+      }
+    };
+    (0, _invariant.default)(args.length >= argMapping.length, 'Event has less arguments than mapping');
+    argMapping.forEach(function (mapping, idx) {
+      _validate(mapping, args[idx], 'arg' + idx);
+    });
+  }
+  var AnimatedEvent = exports.AnimatedEvent = /*#__PURE__*/function () {
+    function AnimatedEvent(argMapping, config) {
+      var _this = this;
+      (0, _classCallCheck2.default)(this, AnimatedEvent);
+      this._listeners = [];
+      this._callListeners = function () {
+        for (var _len = arguments.length, args = new Array(_len), _key2 = 0; _key2 < _len; _key2++) {
+          args[_key2] = arguments[_key2];
+        }
+        _this._listeners.forEach(function (listener) {
+          return listener.apply(void 0, args);
+        });
+      };
+      this._argMapping = argMapping;
+      if (config == null) {
+        console.warn('Animated.event now requires a second argument for options');
+        config = {
+          useNativeDriver: false
+        };
+      }
+      if (config.listener) {
+        this.__addListener(config.listener);
+      }
+      this._attachedEvent = null;
+      this.__isNative = _NativeAnimatedHelper.default.shouldUseNativeDriver(config);
+      this.__platformConfig = config.platformConfig;
+    }
+    return (0, _createClass2.default)(AnimatedEvent, [{
+      key: "__addListener",
+      value: function __addListener(callback) {
+        this._listeners.push(callback);
+      }
+    }, {
+      key: "__removeListener",
+      value: function __removeListener(callback) {
+        this._listeners = this._listeners.filter(function (listener) {
+          return listener !== callback;
+        });
+      }
+    }, {
+      key: "__attach",
+      value: function __attach(viewRef, eventName) {
+        (0, _invariant.default)(this.__isNative, 'Only native driven events need to be attached.');
+        this._attachedEvent = attachNativeEvent(viewRef, eventName, this._argMapping, this.__platformConfig);
+      }
+    }, {
+      key: "__detach",
+      value: function __detach(viewTag, eventName) {
+        (0, _invariant.default)(this.__isNative, 'Only native driven events need to be detached.');
+        this._attachedEvent && this._attachedEvent.detach();
+      }
+    }, {
+      key: "__getHandler",
+      value: function __getHandler() {
+        var _this2 = this;
+        if (this.__isNative) {
+          if (__DEV__) {
+            var _validatedMapping = false;
+            return function () {
+              for (var _len2 = arguments.length, args = new Array(_len2), _key3 = 0; _key3 < _len2; _key3++) {
+                args[_key3] = arguments[_key3];
+              }
+              if (!_validatedMapping) {
+                validateMapping(_this2._argMapping, args);
+                _validatedMapping = true;
+              }
+              _this2._callListeners.apply(_this2, args);
+            };
+          } else {
+            return this._callListeners;
+          }
+        }
+        var validatedMapping = false;
+        return function () {
+          for (var _len3 = arguments.length, args = new Array(_len3), _key4 = 0; _key4 < _len3; _key4++) {
+            args[_key4] = arguments[_key4];
+          }
+          if (__DEV__ && !validatedMapping) {
+            validateMapping(_this2._argMapping, args);
+            validatedMapping = true;
+          }
+          var _traverse2 = function traverse(recMapping, recEvt) {
+            if (recMapping instanceof _AnimatedValue.default) {
+              if (typeof recEvt === 'number') {
+                recMapping.setValue(recEvt);
+              }
+            } else if (recMapping instanceof _AnimatedValueXY.default) {
+              if (typeof recEvt === 'object') {
+                _traverse2(recMapping.x, recEvt.x);
+                _traverse2(recMapping.y, recEvt.y);
+              }
+            } else if (typeof recMapping === 'object') {
+              for (var mappingKey in recMapping) {
+                _traverse2(recMapping[mappingKey], recEvt[mappingKey]);
+              }
+            }
+          };
+          _this2._argMapping.forEach(function (mapping, idx) {
+            _traverse2(mapping, args[idx]);
+          });
+          _this2._callListeners.apply(_this2, args);
+        };
+      }
+    }]);
+  }();
+},405,[1,11,12,391,406,413,32,106],"../../node_modules/react-native/Libraries/Animated/AnimatedEvent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  exports.flushValue = flushValue;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _classPrivateFieldLooseBase2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/classPrivateFieldLooseBase"));
+  var _classPrivateFieldLooseKey2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/classPrivateFieldLooseKey"));
+  var _NativeAnimatedHelper = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "../../../src/private/animated/NativeAnimatedHelper"));
+  var _InteractionManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "../../Interaction/InteractionManager"));
+  var _AnimatedInterpolation = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "./AnimatedInterpolation"));
+  var _AnimatedWithChildren2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "./AnimatedWithChildren"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  var NativeAnimatedAPI = _NativeAnimatedHelper.default.API;
+  function flushValue(rootNode) {
+    var leaves = new Set();
+    function findAnimatedStyles(node) {
+      if (typeof node.update === 'function') {
+        leaves.add(node);
+      } else {
+        node.__getChildren().forEach(findAnimatedStyles);
+      }
+    }
+    findAnimatedStyles(rootNode);
+    leaves.forEach(function (leaf) {
+      return leaf.update();
+    });
+  }
+  function _executeAsAnimatedBatch(id, operation) {
+    NativeAnimatedAPI.setWaitingForIdentifier(id);
+    operation();
+    NativeAnimatedAPI.unsetWaitingForIdentifier(id);
+  }
+  var _listenerCount = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("listenerCount");
+  var _updateSubscription = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("updateSubscription");
+  var _ensureUpdateSubscriptionExists = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("ensureUpdateSubscriptionExists");
+  var AnimatedValue = exports.default = /*#__PURE__*/function (_AnimatedWithChildren) {
+    function AnimatedValue(value, config) {
+      var _this;
+      (0, _classCallCheck2.default)(this, AnimatedValue);
+      _this = _callSuper(this, AnimatedValue, [config]);
+      Object.defineProperty(_this, _ensureUpdateSubscriptionExists, {
+        value: _ensureUpdateSubscriptionExists2
+      });
+      Object.defineProperty(_this, _listenerCount, {
+        writable: true,
+        value: void 0
+      });
+      Object.defineProperty(_this, _updateSubscription, {
+        writable: true,
+        value: void 0
+      });
+      if (typeof value !== 'number') {
+        throw new Error('AnimatedValue: Attempting to set value to undefined');
+      }
+      (0, _classPrivateFieldLooseBase2.default)(_this, _listenerCount)[_listenerCount] = 0;
+      (0, _classPrivateFieldLooseBase2.default)(_this, _updateSubscription)[_updateSubscription] = null;
+      _this._startingValue = _this._value = value;
+      _this._offset = 0;
+      _this._animation = null;
+      if (config && config.useNativeDriver) {
+        _this.__makeNative();
+      }
+      return _this;
+    }
+    (0, _inherits2.default)(AnimatedValue, _AnimatedWithChildren);
+    return (0, _createClass2.default)(AnimatedValue, [{
+      key: "__detach",
+      value: function __detach() {
+        var _this2 = this;
+        if (this.__isNative) {
+          NativeAnimatedAPI.getValue(this.__getNativeTag(), function (value) {
+            _this2._value = value - _this2._offset;
+          });
+        }
+        this.stopAnimation();
+        _superPropGet(AnimatedValue, "__detach", this, 3)([]);
+      }
+    }, {
+      key: "__getValue",
+      value: function __getValue() {
+        return this._value + this._offset;
+      }
+    }, {
+      key: "__makeNative",
+      value: function __makeNative(platformConfig) {
+        _superPropGet(AnimatedValue, "__makeNative", this, 3)([platformConfig]);
+        if ((0, _classPrivateFieldLooseBase2.default)(this, _listenerCount)[_listenerCount] > 0) {
+          (0, _classPrivateFieldLooseBase2.default)(this, _ensureUpdateSubscriptionExists)[_ensureUpdateSubscriptionExists]();
+        }
+      }
+    }, {
+      key: "addListener",
+      value: function addListener(callback) {
+        var id = _superPropGet(AnimatedValue, "addListener", this, 3)([callback]);
+        (0, _classPrivateFieldLooseBase2.default)(this, _listenerCount)[_listenerCount]++;
+        if (this.__isNative) {
+          (0, _classPrivateFieldLooseBase2.default)(this, _ensureUpdateSubscriptionExists)[_ensureUpdateSubscriptionExists]();
+        }
+        return id;
+      }
+    }, {
+      key: "removeListener",
+      value: function removeListener(id) {
+        _superPropGet(AnimatedValue, "removeListener", this, 3)([id]);
+        (0, _classPrivateFieldLooseBase2.default)(this, _listenerCount)[_listenerCount]--;
+        if (this.__isNative && (0, _classPrivateFieldLooseBase2.default)(this, _listenerCount)[_listenerCount] === 0) {
+          var _classPrivateFieldLoo;
+          (_classPrivateFieldLoo = (0, _classPrivateFieldLooseBase2.default)(this, _updateSubscription)[_updateSubscription]) == null || _classPrivateFieldLoo.remove();
+        }
+      }
+    }, {
+      key: "removeAllListeners",
+      value: function removeAllListeners() {
+        _superPropGet(AnimatedValue, "removeAllListeners", this, 3)([]);
+        (0, _classPrivateFieldLooseBase2.default)(this, _listenerCount)[_listenerCount] = 0;
+        if (this.__isNative) {
+          var _classPrivateFieldLoo2;
+          (_classPrivateFieldLoo2 = (0, _classPrivateFieldLooseBase2.default)(this, _updateSubscription)[_updateSubscription]) == null || _classPrivateFieldLoo2.remove();
+        }
+      }
+    }, {
+      key: "setValue",
+      value: function setValue(value) {
+        var _this3 = this;
+        if (this._animation) {
+          this._animation.stop();
+          this._animation = null;
+        }
+        this._updateValue(value, !this.__isNative);
+        if (this.__isNative) {
+          _executeAsAnimatedBatch(this.__getNativeTag().toString(), function () {
+            return NativeAnimatedAPI.setAnimatedNodeValue(_this3.__getNativeTag(), value);
+          });
+        }
+      }
+    }, {
+      key: "setOffset",
+      value: function setOffset(offset) {
+        this._offset = offset;
+        if (this.__isNative) {
+          NativeAnimatedAPI.setAnimatedNodeOffset(this.__getNativeTag(), offset);
+        }
+      }
+    }, {
+      key: "flattenOffset",
+      value: function flattenOffset() {
+        this._value += this._offset;
+        this._offset = 0;
+        if (this.__isNative) {
+          NativeAnimatedAPI.flattenAnimatedNodeOffset(this.__getNativeTag());
+        }
+      }
+    }, {
+      key: "extractOffset",
+      value: function extractOffset() {
+        var _this4 = this;
+        this._offset += this._value;
+        this._value = 0;
+        if (this.__isNative) {
+          _executeAsAnimatedBatch(this.__getNativeTag().toString(), function () {
+            return NativeAnimatedAPI.extractAnimatedNodeOffset(_this4.__getNativeTag());
+          });
+        }
+      }
+    }, {
+      key: "stopAnimation",
+      value: function stopAnimation(callback) {
+        this.stopTracking();
+        this._animation && this._animation.stop();
+        this._animation = null;
+        if (callback) {
+          if (this.__isNative) {
+            NativeAnimatedAPI.getValue(this.__getNativeTag(), callback);
+          } else {
+            callback(this.__getValue());
+          }
+        }
+      }
+    }, {
+      key: "resetAnimation",
+      value: function resetAnimation(callback) {
+        this.stopAnimation(callback);
+        this._value = this._startingValue;
+        if (this.__isNative) {
+          NativeAnimatedAPI.setAnimatedNodeValue(this.__getNativeTag(), this._startingValue);
+        }
+      }
+    }, {
+      key: "__onAnimatedValueUpdateReceived",
+      value: function __onAnimatedValueUpdateReceived(value, offset) {
+        this._updateValue(value, false);
+        if (offset != null) {
+          this._offset = offset;
+        }
+      }
+    }, {
+      key: "interpolate",
+      value: function interpolate(config) {
+        return new _AnimatedInterpolation.default(this, config);
+      }
+    }, {
+      key: "animate",
+      value: function animate(animation, callback) {
+        var _this5 = this;
+        var handle = null;
+        if (animation.__isInteraction) {
+          handle = _InteractionManager.default.createInteractionHandle();
+        }
+        var previousAnimation = this._animation;
+        this._animation && this._animation.stop();
+        this._animation = animation;
+        animation.start(this._value, function (value) {
+          _this5._updateValue(value, true);
+        }, function (result) {
+          _this5._animation = null;
+          if (handle !== null) {
+            _InteractionManager.default.clearInteractionHandle(handle);
+          }
+          callback && callback(result);
+        }, previousAnimation, this);
+      }
+    }, {
+      key: "stopTracking",
+      value: function stopTracking() {
+        this._tracking && this._tracking.__detach();
+        this._tracking = null;
+      }
+    }, {
+      key: "track",
+      value: function track(tracking) {
+        this.stopTracking();
+        this._tracking = tracking;
+        this._tracking && this._tracking.update();
+      }
+    }, {
+      key: "_updateValue",
+      value: function _updateValue(value, flush) {
+        if (value === undefined) {
+          throw new Error('AnimatedValue: Attempting to set value to undefined');
+        }
+        this._value = value;
+        if (flush) {
+          flushValue(this);
+        }
+        this.__callListeners(this.__getValue());
+      }
+    }, {
+      key: "__getNativeConfig",
+      value: function __getNativeConfig() {
+        return {
+          type: 'value',
+          value: this._value,
+          offset: this._offset,
+          debugID: this.__getDebugID()
+        };
+      }
+    }]);
+  }(_AnimatedWithChildren2.default);
+  function _ensureUpdateSubscriptionExists2() {
+    var _this6 = this;
+    if ((0, _classPrivateFieldLooseBase2.default)(this, _updateSubscription)[_updateSubscription] != null) {
+      return;
+    }
+    var nativeTag = this.__getNativeTag();
+    NativeAnimatedAPI.startListeningToAnimatedNodeValue(nativeTag);
+    var subscription = _NativeAnimatedHelper.default.nativeEventEmitter.addListener('onAnimatedValueUpdate', function (data) {
+      if (data.tag === nativeTag) {
+        _this6.__onAnimatedValueUpdateReceived(data.value, data.offset);
+      }
+    });
+    (0, _classPrivateFieldLooseBase2.default)(this, _updateSubscription)[_updateSubscription] = {
+      remove: function remove() {
+        if ((0, _classPrivateFieldLooseBase2.default)(_this6, _updateSubscription)[_updateSubscription] == null) {
+          return;
+        }
+        (0, _classPrivateFieldLooseBase2.default)(_this6, _updateSubscription)[_updateSubscription] = null;
+        subscription.remove();
+        NativeAnimatedAPI.stopListeningToAnimatedNodeValue(nativeTag);
+      }
+    };
+  }
+},406,[1,11,12,18,20,21,23,26,27,391,407,410,400],"../../node_modules/react-native/Libraries/Animated/nodes/AnimatedValue.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var ReactNativeFeatureFlags = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../src/private/featureflags/ReactNativeFeatureFlags"));
+  var _EventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../vendor/emitter/EventEmitter"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _emitter = new _EventEmitter.default();
+  var DEBUG_DELAY = 0;
+  var DEBUG = false;
+  var InteractionManagerImpl = {
+    Events: {
+      interactionStart: 'interactionStart',
+      interactionComplete: 'interactionComplete'
+    },
+    runAfterInteractions: function runAfterInteractions(task) {
+      var tasks = [];
+      var promise = new Promise(function (resolve) {
+        _scheduleUpdate();
+        if (task) {
+          tasks.push(task);
+        }
+        tasks.push({
+          run: resolve,
+          name: 'resolve ' + (task && task.name || '?')
+        });
+        _taskQueue.enqueueTasks(tasks);
+      });
+      return {
+        then: promise.then.bind(promise),
+        cancel: function cancel() {
+          _taskQueue.cancelTasks(tasks);
+        }
+      };
+    },
+    createInteractionHandle: function createInteractionHandle() {
+      DEBUG && _$$_REQUIRE(_dependencyMap[3], "../Utilities/infoLog").default('InteractionManager: create interaction handle');
+      _scheduleUpdate();
+      var handle = ++_inc;
+      _addInteractionSet.add(handle);
+      return handle;
+    },
+    clearInteractionHandle: function clearInteractionHandle(handle) {
+      DEBUG && _$$_REQUIRE(_dependencyMap[3], "../Utilities/infoLog").default('InteractionManager: clear interaction handle');
+      _$$_REQUIRE(_dependencyMap[4], "invariant")(!!handle, 'InteractionManager: Must provide a handle to clear.');
+      _scheduleUpdate();
+      _addInteractionSet.delete(handle);
+      _deleteInteractionSet.add(handle);
+    },
+    addListener: _emitter.addListener.bind(_emitter),
+    setDeadline: function setDeadline(deadline) {
+      _deadline = deadline;
+    }
+  };
+  var _interactionSet = new Set();
+  var _addInteractionSet = new Set();
+  var _deleteInteractionSet = new Set();
+  var _taskQueue = new (_$$_REQUIRE(_dependencyMap[5], "./TaskQueue").default)({
+    onMoreTasks: _scheduleUpdate
+  });
+  var _nextUpdateHandle = 0;
+  var _inc = 0;
+  var _deadline = -1;
+  function _scheduleUpdate() {
+    if (!_nextUpdateHandle) {
+      if (_deadline > 0) {
+        _nextUpdateHandle = setTimeout(_processUpdate, 0 + DEBUG_DELAY);
+      } else {
+        _nextUpdateHandle = setImmediate(_processUpdate);
+      }
+    }
+  }
+  function _processUpdate() {
+    _nextUpdateHandle = 0;
+    var interactionCount = _interactionSet.size;
+    _addInteractionSet.forEach(function (handle) {
+      return _interactionSet.add(handle);
+    });
+    _deleteInteractionSet.forEach(function (handle) {
+      return _interactionSet.delete(handle);
+    });
+    var nextInteractionCount = _interactionSet.size;
+    if (interactionCount !== 0 && nextInteractionCount === 0) {
+      _emitter.emit(InteractionManager.Events.interactionComplete);
+    } else if (interactionCount === 0 && nextInteractionCount !== 0) {
+      _emitter.emit(InteractionManager.Events.interactionStart);
+    }
+    if (nextInteractionCount === 0) {
+      while (_taskQueue.hasTasksToProcess()) {
+        _taskQueue.processNext();
+        if (_deadline > 0 && _$$_REQUIRE(_dependencyMap[6], "../BatchedBridge/BatchedBridge").default.getEventLoopRunningTime() >= _deadline) {
+          _scheduleUpdate();
+          break;
+        }
+      }
+    }
+    _addInteractionSet.clear();
+    _deleteInteractionSet.clear();
+  }
+  var InteractionManager = ReactNativeFeatureFlags.disableInteractionManager() ? _$$_REQUIRE(_dependencyMap[7], "./InteractionManagerStub").default : InteractionManagerImpl;
+  var _default = exports.default = InteractionManager;
+},407,[1,52,25,252,32,408,40,409],"../../node_modules/react-native/Libraries/Interaction/InteractionManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var DEBUG = false;
+  var TaskQueue = /*#__PURE__*/function () {
+    function TaskQueue(_ref) {
+      var onMoreTasks = _ref.onMoreTasks;
+      (0, _classCallCheck2.default)(this, TaskQueue);
+      this._onMoreTasks = onMoreTasks;
+      this._queueStack = [{
+        tasks: [],
+        popable: false
+      }];
+    }
+    return (0, _createClass2.default)(TaskQueue, [{
+      key: "enqueue",
+      value: function enqueue(task) {
+        this._getCurrentQueue().push(task);
+      }
+    }, {
+      key: "enqueueTasks",
+      value: function enqueueTasks(tasks) {
+        var _this = this;
+        tasks.forEach(function (task) {
+          return _this.enqueue(task);
+        });
+      }
+    }, {
+      key: "cancelTasks",
+      value: function cancelTasks(tasksToCancel) {
+        this._queueStack = this._queueStack.map(function (queue) {
+          return Object.assign({}, queue, {
+            tasks: queue.tasks.filter(function (task) {
+              return tasksToCancel.indexOf(task) === -1;
+            })
+          });
+        }).filter(function (queue, idx) {
+          return queue.tasks.length > 0 || idx === 0;
+        });
+      }
+    }, {
+      key: "hasTasksToProcess",
+      value: function hasTasksToProcess() {
+        return this._getCurrentQueue().length > 0;
+      }
+    }, {
+      key: "processNext",
+      value: function processNext() {
+        var queue = this._getCurrentQueue();
+        if (queue.length) {
+          var task = queue.shift();
+          try {
+            if (typeof task === 'object' && task.gen) {
+              DEBUG && _$$_REQUIRE(_dependencyMap[3], "../Utilities/infoLog").default('TaskQueue: genPromise for task ' + task.name);
+              this._genPromise(task);
+            } else if (typeof task === 'object' && task.run) {
+              DEBUG && _$$_REQUIRE(_dependencyMap[3], "../Utilities/infoLog").default('TaskQueue: run task ' + task.name);
+              task.run();
+            } else {
+              _$$_REQUIRE(_dependencyMap[4], "invariant")(typeof task === 'function', 'Expected Function, SimpleTask, or PromiseTask, but got:\n' + JSON.stringify(task, null, 2));
+              DEBUG && _$$_REQUIRE(_dependencyMap[3], "../Utilities/infoLog").default('TaskQueue: run anonymous task');
+              task();
+            }
+          } catch (e) {
+            e.message = 'TaskQueue: Error with task ' + (task.name || '') + ': ' + e.message;
+            throw e;
+          }
+        }
+      }
+    }, {
+      key: "_getCurrentQueue",
+      value: function _getCurrentQueue() {
+        var stackIdx = this._queueStack.length - 1;
+        var queue = this._queueStack[stackIdx];
+        if (queue.popable && queue.tasks.length === 0 && this._queueStack.length > 1) {
+          this._queueStack.pop();
+          DEBUG && _$$_REQUIRE(_dependencyMap[3], "../Utilities/infoLog").default('TaskQueue: popped queue: ', {
+            stackIdx: stackIdx,
+            queueStackSize: this._queueStack.length
+          });
+          return this._getCurrentQueue();
+        } else {
+          return queue.tasks;
+        }
+      }
+    }, {
+      key: "_genPromise",
+      value: function _genPromise(task) {
+        var _this2 = this;
+        this._queueStack.push({
+          tasks: [],
+          popable: false
+        });
+        var stackIdx = this._queueStack.length - 1;
+        var stackItem = this._queueStack[stackIdx];
+        DEBUG && _$$_REQUIRE(_dependencyMap[3], "../Utilities/infoLog").default('TaskQueue: push new queue: ', {
+          stackIdx: stackIdx
+        });
+        DEBUG && _$$_REQUIRE(_dependencyMap[3], "../Utilities/infoLog").default('TaskQueue: exec gen task ' + task.name);
+        task.gen().then(function () {
+          DEBUG && _$$_REQUIRE(_dependencyMap[3], "../Utilities/infoLog").default('TaskQueue: onThen for gen task ' + task.name, {
+            stackIdx: stackIdx,
+            queueStackSize: _this2._queueStack.length
+          });
+          stackItem.popable = true;
+          _this2.hasTasksToProcess() && _this2._onMoreTasks();
+        }).catch(function (ex) {
+          setTimeout(function () {
+            ex.message = `TaskQueue: Error resolving Promise in task ${task.name}: ${ex.message}`;
+            throw ex;
+          }, 0);
+        });
+      }
+    }]);
+  }();
+  var _default = exports.default = TaskQueue;
+},408,[1,11,12,252,32],"../../node_modules/react-native/Libraries/Interaction/TaskQueue.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  function reject(error) {
+    setTimeout(function () {
+      throw error;
+    }, 0);
+  }
+  var InteractionManagerStub = {
+    Events: {
+      interactionStart: 'interactionStart',
+      interactionComplete: 'interactionComplete'
+    },
+    runAfterInteractions: function runAfterInteractions(task) {
+      var immediateID;
+      var promise = new Promise(function (resolve) {
+        immediateID = setImmediate(function () {
+          if (typeof task === 'object' && task !== null) {
+            if (typeof task.gen === 'function') {
+              task.gen().then(resolve, reject);
+            } else if (typeof task.run === 'function') {
+              try {
+                task.run();
+                resolve();
+              } catch (error) {
+                reject(error);
+              }
+            } else {
+              reject(new TypeError(`Task "${task.name}" missing gen or run.`));
+            }
+          } else if (typeof task === 'function') {
+            try {
+              task();
+              resolve();
+            } catch (error) {
+              reject(error);
+            }
+          } else {
+            reject(new TypeError('Invalid task of type: ' + typeof task));
+          }
+        });
+      });
+      return {
+        then: promise.then.bind(promise),
+        cancel: function cancel() {
+          clearImmediate(immediateID);
+        }
+      };
+    },
+    createInteractionHandle: function createInteractionHandle() {
+      return -1;
+    },
+    clearInteractionHandle: function clearInteractionHandle(handle) {
+      _$$_REQUIRE(_dependencyMap[0], "invariant")(!!handle, 'InteractionManager: Must provide a handle to clear.');
+    },
+    addListener: function addListener() {
+      return {
+        remove: function remove() {}
+      };
+    },
+    setDeadline: function setDeadline(deadline) {}
+  };
+  var _default = exports.default = InteractionManagerStub;
+},409,[32],"../../node_modules/react-native/Libraries/Interaction/InteractionManagerStub.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _NativeAnimatedHelper = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../../../src/private/animated/NativeAnimatedHelper"));
+  var _normalizeColor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../../StyleSheet/normalizeColor"));
+  var _processColor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "../../StyleSheet/processColor"));
+  var _Easing = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "../Easing"));
+  var _AnimatedWithChildren2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "./AnimatedWithChildren"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "invariant"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  function createNumericInterpolation(config) {
+    var outputRange = config.outputRange;
+    var inputRange = config.inputRange;
+    var easing = config.easing || _Easing.default.linear;
+    var extrapolateLeft = 'extend';
+    if (config.extrapolateLeft !== undefined) {
+      extrapolateLeft = config.extrapolateLeft;
+    } else if (config.extrapolate !== undefined) {
+      extrapolateLeft = config.extrapolate;
+    }
+    var extrapolateRight = 'extend';
+    if (config.extrapolateRight !== undefined) {
+      extrapolateRight = config.extrapolateRight;
+    } else if (config.extrapolate !== undefined) {
+      extrapolateRight = config.extrapolate;
+    }
+    return function (input) {
+      (0, _invariant.default)(typeof input === 'number', 'Cannot interpolation an input which is not a number');
+      var range = findRange(input, inputRange);
+      return interpolate(input, inputRange[range], inputRange[range + 1], outputRange[range], outputRange[range + 1], easing, extrapolateLeft, extrapolateRight);
+    };
+  }
+  function interpolate(input, inputMin, inputMax, outputMin, outputMax, easing, extrapolateLeft, extrapolateRight) {
+    var result = input;
+    if (result < inputMin) {
+      if (extrapolateLeft === 'identity') {
+        return result;
+      } else if (extrapolateLeft === 'clamp') {
+        result = inputMin;
+      } else if (extrapolateLeft === 'extend') {}
+    }
+    if (result > inputMax) {
+      if (extrapolateRight === 'identity') {
+        return result;
+      } else if (extrapolateRight === 'clamp') {
+        result = inputMax;
+      } else if (extrapolateRight === 'extend') {}
+    }
+    if (outputMin === outputMax) {
+      return outputMin;
+    }
+    if (inputMin === inputMax) {
+      if (input <= inputMin) {
+        return outputMin;
+      }
+      return outputMax;
+    }
+    if (inputMin === -Infinity) {
+      result = -result;
+    } else if (inputMax === Infinity) {
+      result = result - inputMin;
+    } else {
+      result = (result - inputMin) / (inputMax - inputMin);
+    }
+    result = easing(result);
+    if (outputMin === -Infinity) {
+      result = -result;
+    } else if (outputMax === Infinity) {
+      result = result + outputMin;
+    } else {
+      result = result * (outputMax - outputMin) + outputMin;
+    }
+    return result;
+  }
+  var numericComponentRegex = /[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/g;
+  function mapStringToNumericComponents(input) {
+    var normalizedColor = (0, _normalizeColor.default)(input);
+    (0, _invariant.default)(normalizedColor == null || typeof normalizedColor !== 'object', 'PlatformColors are not supported');
+    if (typeof normalizedColor === 'number') {
+      normalizedColor = normalizedColor || 0;
+      var r = (normalizedColor & 0xff000000) >>> 24;
+      var g = (normalizedColor & 0x00ff0000) >>> 16;
+      var b = (normalizedColor & 0x0000ff00) >>> 8;
+      var a = (normalizedColor & 0x000000ff) / 255;
+      return {
+        isColor: true,
+        components: [r, g, b, a]
+      };
+    } else {
+      var components = [];
+      var lastMatchEnd = 0;
+      var match;
+      while ((match = numericComponentRegex.exec(input)) != null) {
+        if (match.index > lastMatchEnd) {
+          components.push(input.substring(lastMatchEnd, match.index));
+        }
+        components.push(parseFloat(match[0]));
+        lastMatchEnd = match.index + match[0].length;
+      }
+      (0, _invariant.default)(components.length > 0, 'outputRange must contain color or value with numeric component');
+      if (lastMatchEnd < input.length) {
+        components.push(input.substring(lastMatchEnd, input.length));
+      }
+      return {
+        isColor: false,
+        components: components
+      };
+    }
+  }
+  function createStringInterpolation(config) {
+    (0, _invariant.default)(config.outputRange.length >= 2, 'Bad output range');
+    var outputRange = config.outputRange.map(mapStringToNumericComponents);
+    var isColor = outputRange[0].isColor;
+    if (__DEV__) {
+      (0, _invariant.default)(outputRange.every(function (output) {
+        return output.isColor === isColor;
+      }), 'All elements of output range should either be a color or a string with numeric components');
+      var firstOutput = outputRange[0].components;
+      (0, _invariant.default)(outputRange.every(function (output) {
+        return output.components.length === firstOutput.length;
+      }), 'All elements of output range should have the same number of components');
+      (0, _invariant.default)(outputRange.every(function (output) {
+        return output.components.every(function (component, i) {
+          return typeof component === 'number' || component === firstOutput[i];
+        });
+      }), 'All elements of output range should have the same non-numeric components');
+    }
+    var numericComponents = outputRange.map(function (output) {
+      return isColor ? output.components : output.components.filter(function (c) {
+        return typeof c === 'number';
+      });
+    });
+    var interpolations = numericComponents[0].map(function (_, i) {
+      return createNumericInterpolation(Object.assign({}, config, {
+        outputRange: numericComponents.map(function (components) {
+          return components[i];
+        })
+      }));
+    });
+    if (!isColor) {
+      return function (input) {
+        var values = interpolations.map(function (interpolation) {
+          return interpolation(input);
+        });
+        var i = 0;
+        return outputRange[0].components.map(function (c) {
+          return typeof c === 'number' ? values[i++] : c;
+        }).join('');
+      };
+    } else {
+      return function (input) {
+        var result = interpolations.map(function (interpolation, i) {
+          var value = interpolation(input);
+          return i < 3 ? Math.round(value) : Math.round(value * 1000) / 1000;
+        });
+        return `rgba(${result[0]}, ${result[1]}, ${result[2]}, ${result[3]})`;
+      };
+    }
+  }
+  function findRange(input, inputRange) {
+    var i;
+    for (i = 1; i < inputRange.length - 1; ++i) {
+      if (inputRange[i] >= input) {
+        break;
+      }
+    }
+    return i - 1;
+  }
+  function checkValidRanges(inputRange, outputRange) {
+    checkInfiniteRange('outputRange', outputRange);
+    checkInfiniteRange('inputRange', inputRange);
+    checkValidInputRange(inputRange);
+    (0, _invariant.default)(inputRange.length === outputRange.length, 'inputRange (' + inputRange.length + ') and outputRange (' + outputRange.length + ') must have the same length');
+  }
+  function checkValidInputRange(arr) {
+    (0, _invariant.default)(arr.length >= 2, 'inputRange must have at least 2 elements');
+    var message = 'inputRange must be monotonically non-decreasing ' + String(arr);
+    for (var i = 1; i < arr.length; ++i) {
+      (0, _invariant.default)(arr[i] >= arr[i - 1], message);
+    }
+  }
+  function checkInfiniteRange(name, arr) {
+    (0, _invariant.default)(arr.length >= 2, name + ' must have at least 2 elements');
+    (0, _invariant.default)(arr.length !== 2 || arr[0] !== -Infinity || arr[1] !== Infinity, name + 'cannot be ]-infinity;+infinity[ ' + arr);
+  }
+  var AnimatedInterpolation = exports.default = /*#__PURE__*/function (_AnimatedWithChildren) {
+    function AnimatedInterpolation(parent, config) {
+      var _this;
+      (0, _classCallCheck2.default)(this, AnimatedInterpolation);
+      _this = _callSuper(this, AnimatedInterpolation, [config]);
+      _this._parent = parent;
+      _this._config = config;
+      if (__DEV__) {
+        checkValidRanges(config.inputRange, config.outputRange);
+        _this._getInterpolation();
+      }
+      return _this;
+    }
+    (0, _inherits2.default)(AnimatedInterpolation, _AnimatedWithChildren);
+    return (0, _createClass2.default)(AnimatedInterpolation, [{
+      key: "_getInterpolation",
+      value: function _getInterpolation() {
+        if (!this._interpolation) {
+          var config = this._config;
+          if (config.outputRange && typeof config.outputRange[0] === 'string') {
+            this._interpolation = createStringInterpolation(config);
+          } else {
+            this._interpolation = createNumericInterpolation(config);
+          }
+        }
+        return this._interpolation;
+      }
+    }, {
+      key: "__makeNative",
+      value: function __makeNative(platformConfig) {
+        this._parent.__makeNative(platformConfig);
+        _superPropGet(AnimatedInterpolation, "__makeNative", this, 3)([platformConfig]);
+      }
+    }, {
+      key: "__getValue",
+      value: function __getValue() {
+        var parentValue = this._parent.__getValue();
+        (0, _invariant.default)(typeof parentValue === 'number', 'Cannot interpolate an input which is not a number.');
+        return this._getInterpolation()(parentValue);
+      }
+    }, {
+      key: "interpolate",
+      value: function interpolate(config) {
+        return new AnimatedInterpolation(this, config);
+      }
+    }, {
+      key: "__attach",
+      value: function __attach() {
+        this._parent.__addChild(this);
+        _superPropGet(AnimatedInterpolation, "__attach", this, 3)([]);
+      }
+    }, {
+      key: "__detach",
+      value: function __detach() {
+        this._parent.__removeChild(this);
+        _superPropGet(AnimatedInterpolation, "__detach", this, 3)([]);
+      }
+    }, {
+      key: "__getNativeConfig",
+      value: function __getNativeConfig() {
+        if (__DEV__) {
+          (0, _$$_REQUIRE(_dependencyMap[13], "../../../src/private/animated/NativeAnimatedValidation").validateInterpolation)(this._config);
+        }
+        var outputRange = this._config.outputRange;
+        var outputType = null;
+        if (typeof outputRange[0] === 'string') {
+          outputRange = outputRange.map(function (value) {
+            var processedColor = (0, _processColor.default)(value);
+            if (typeof processedColor === 'number') {
+              outputType = 'color';
+              return processedColor;
+            } else {
+              return _NativeAnimatedHelper.default.transformDataType(value);
+            }
+          });
+        }
+        return {
+          inputRange: this._config.inputRange,
+          outputRange: outputRange,
+          outputType: outputType,
+          extrapolateLeft: this._config.extrapolateLeft || this._config.extrapolate || 'extend',
+          extrapolateRight: this._config.extrapolateRight || this._config.extrapolate || 'extend',
+          type: 'interpolation',
+          debugID: this.__getDebugID()
+        };
+      }
+    }]);
+  }(_AnimatedWithChildren2.default);
+},410,[1,11,12,18,20,21,23,391,58,57,411,400,32,403],"../../node_modules/react-native/Libraries/Animated/nodes/AnimatedInterpolation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _ease;
+  var EasingStatic = {
+    step0: function step0(n) {
+      return n > 0 ? 1 : 0;
+    },
+    step1: function step1(n) {
+      return n >= 1 ? 1 : 0;
+    },
+    linear: function linear(t) {
+      return t;
+    },
+    ease: function ease(t) {
+      if (!_ease) {
+        _ease = EasingStatic.bezier(0.42, 0, 1, 1);
+      }
+      return _ease(t);
+    },
+    quad: function quad(t) {
+      return t * t;
+    },
+    cubic: function cubic(t) {
+      return t * t * t;
+    },
+    poly: function poly(n) {
+      return function (t) {
+        return Math.pow(t, n);
+      };
+    },
+    sin: function sin(t) {
+      return 1 - Math.cos(t * Math.PI / 2);
+    },
+    circle: function circle(t) {
+      return 1 - Math.sqrt(1 - t * t);
+    },
+    exp: function exp(t) {
+      return Math.pow(2, 10 * (t - 1));
+    },
+    elastic: function elastic() {
+      var bounciness = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+      var p = bounciness * Math.PI;
+      return function (t) {
+        return 1 - Math.pow(Math.cos(t * Math.PI / 2), 3) * Math.cos(t * p);
+      };
+    },
+    back: function back() {
+      var s = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1.70158;
+      return function (t) {
+        return t * t * ((s + 1) * t - s);
+      };
+    },
+    bounce: function bounce(t) {
+      if (t < 1 / 2.75) {
+        return 7.5625 * t * t;
+      }
+      if (t < 2 / 2.75) {
+        var _t = t - 1.5 / 2.75;
+        return 7.5625 * _t * _t + 0.75;
+      }
+      if (t < 2.5 / 2.75) {
+        var _t2 = t - 2.25 / 2.75;
+        return 7.5625 * _t2 * _t2 + 0.9375;
+      }
+      var t2 = t - 2.625 / 2.75;
+      return 7.5625 * t2 * t2 + 0.984375;
+    },
+    bezier: function bezier(x1, y1, x2, y2) {
+      var _bezier = _$$_REQUIRE(_dependencyMap[0], "./bezier").default;
+      return _bezier(x1, y1, x2, y2);
+    },
+    in: function _in(easing) {
+      return easing;
+    },
+    out: function out(easing) {
+      return function (t) {
+        return 1 - easing(1 - t);
+      };
+    },
+    inOut: function inOut(easing) {
+      return function (t) {
+        if (t < 0.5) {
+          return easing(t * 2) / 2;
+        }
+        return 1 - easing((1 - t) * 2) / 2;
+      };
+    }
+  };
+  var _default = exports.default = EasingStatic;
+},411,[412],"../../node_modules/react-native/Libraries/Animated/Easing.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = bezier;
+  var NEWTON_ITERATIONS = 4;
+  var NEWTON_MIN_SLOPE = 0.001;
+  var SUBDIVISION_PRECISION = 0.0000001;
+  var SUBDIVISION_MAX_ITERATIONS = 10;
+  var kSplineTableSize = 11;
+  var kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);
+  var float32ArraySupported = typeof Float32Array === 'function';
+  function A(aA1, aA2) {
+    return 1.0 - 3.0 * aA2 + 3.0 * aA1;
+  }
+  function B(aA1, aA2) {
+    return 3.0 * aA2 - 6.0 * aA1;
+  }
+  function C(aA1) {
+    return 3.0 * aA1;
+  }
+  function calcBezier(aT, aA1, aA2) {
+    return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT;
+  }
+  function getSlope(aT, aA1, aA2) {
+    return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1);
+  }
+  function binarySubdivide(aX, _aA, _aB, mX1, mX2) {
+    var currentX,
+      currentT,
+      i = 0,
+      aA = _aA,
+      aB = _aB;
+    do {
+      currentT = aA + (aB - aA) / 2.0;
+      currentX = calcBezier(currentT, mX1, mX2) - aX;
+      if (currentX > 0.0) {
+        aB = currentT;
+      } else {
+        aA = currentT;
+      }
+    } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);
+    return currentT;
+  }
+  function newtonRaphsonIterate(aX, _aGuessT, mX1, mX2) {
+    var aGuessT = _aGuessT;
+    for (var i = 0; i < NEWTON_ITERATIONS; ++i) {
+      var currentSlope = getSlope(aGuessT, mX1, mX2);
+      if (currentSlope === 0.0) {
+        return aGuessT;
+      }
+      var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
+      aGuessT -= currentX / currentSlope;
+    }
+    return aGuessT;
+  }
+  function bezier(mX1, mY1, mX2, mY2) {
+    if (!(mX1 >= 0 && mX1 <= 1 && mX2 >= 0 && mX2 <= 1)) {
+      throw new Error('bezier x values must be in [0, 1] range');
+    }
+    var sampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);
+    if (mX1 !== mY1 || mX2 !== mY2) {
+      for (var i = 0; i < kSplineTableSize; ++i) {
+        sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
+      }
+    }
+    function getTForX(aX) {
+      var intervalStart = 0.0;
+      var currentSample = 1;
+      var lastSample = kSplineTableSize - 1;
+      for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {
+        intervalStart += kSampleStepSize;
+      }
+      --currentSample;
+      var dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);
+      var guessForT = intervalStart + dist * kSampleStepSize;
+      var initialSlope = getSlope(guessForT, mX1, mX2);
+      if (initialSlope >= NEWTON_MIN_SLOPE) {
+        return newtonRaphsonIterate(aX, guessForT, mX1, mX2);
+      } else if (initialSlope === 0.0) {
+        return guessForT;
+      } else {
+        return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);
+      }
+    }
+    return function BezierEasing(x) {
+      if (mX1 === mY1 && mX2 === mY2) {
+        return x;
+      }
+      if (x === 0) {
+        return 0;
+      }
+      if (x === 1) {
+        return 1;
+      }
+      return calcBezier(getTForX(x), mY1, mY2);
+    };
+  }
+},412,[],"../../node_modules/react-native/Libraries/Animated/bezier.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _AnimatedValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./AnimatedValue"));
+  var _AnimatedWithChildren2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./AnimatedWithChildren"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "invariant"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  var _uniqueId = 1;
+  var AnimatedValueXY = exports.default = /*#__PURE__*/function (_AnimatedWithChildren) {
+    function AnimatedValueXY(valueIn, config) {
+      var _this;
+      (0, _classCallCheck2.default)(this, AnimatedValueXY);
+      _this = _callSuper(this, AnimatedValueXY, [config]);
+      var value = valueIn || {
+        x: 0,
+        y: 0
+      };
+      if (typeof value.x === 'number' && typeof value.y === 'number') {
+        _this.x = new _AnimatedValue.default(value.x);
+        _this.y = new _AnimatedValue.default(value.y);
+      } else {
+        (0, _invariant.default)(value.x instanceof _AnimatedValue.default && value.y instanceof _AnimatedValue.default, 'AnimatedValueXY must be initialized with an object of numbers or ' + 'AnimatedValues.');
+        _this.x = value.x;
+        _this.y = value.y;
+      }
+      _this._listeners = {};
+      if (config && config.useNativeDriver) {
+        _this.__makeNative();
+      }
+      return _this;
+    }
+    (0, _inherits2.default)(AnimatedValueXY, _AnimatedWithChildren);
+    return (0, _createClass2.default)(AnimatedValueXY, [{
+      key: "setValue",
+      value: function setValue(value) {
+        this.x.setValue(value.x);
+        this.y.setValue(value.y);
+      }
+    }, {
+      key: "setOffset",
+      value: function setOffset(offset) {
+        this.x.setOffset(offset.x);
+        this.y.setOffset(offset.y);
+      }
+    }, {
+      key: "flattenOffset",
+      value: function flattenOffset() {
+        this.x.flattenOffset();
+        this.y.flattenOffset();
+      }
+    }, {
+      key: "extractOffset",
+      value: function extractOffset() {
+        this.x.extractOffset();
+        this.y.extractOffset();
+      }
+    }, {
+      key: "__getValue",
+      value: function __getValue() {
+        return {
+          x: this.x.__getValue(),
+          y: this.y.__getValue()
+        };
+      }
+    }, {
+      key: "resetAnimation",
+      value: function resetAnimation(callback) {
+        this.x.resetAnimation();
+        this.y.resetAnimation();
+        callback && callback(this.__getValue());
+      }
+    }, {
+      key: "stopAnimation",
+      value: function stopAnimation(callback) {
+        this.x.stopAnimation();
+        this.y.stopAnimation();
+        callback && callback(this.__getValue());
+      }
+    }, {
+      key: "addListener",
+      value: function addListener(callback) {
+        var _this2 = this;
+        var id = String(_uniqueId++);
+        var jointCallback = function jointCallback(_ref) {
+          var number = _ref.value;
+          callback(_this2.__getValue());
+        };
+        this._listeners[id] = {
+          x: this.x.addListener(jointCallback),
+          y: this.y.addListener(jointCallback)
+        };
+        return id;
+      }
+    }, {
+      key: "removeListener",
+      value: function removeListener(id) {
+        this.x.removeListener(this._listeners[id].x);
+        this.y.removeListener(this._listeners[id].y);
+        delete this._listeners[id];
+      }
+    }, {
+      key: "removeAllListeners",
+      value: function removeAllListeners() {
+        this.x.removeAllListeners();
+        this.y.removeAllListeners();
+        this._listeners = {};
+      }
+    }, {
+      key: "getLayout",
+      value: function getLayout() {
+        return {
+          left: this.x,
+          top: this.y
+        };
+      }
+    }, {
+      key: "getTranslateTransform",
+      value: function getTranslateTransform() {
+        return [{
+          translateX: this.x
+        }, {
+          translateY: this.y
+        }];
+      }
+    }, {
+      key: "__attach",
+      value: function __attach() {
+        this.x.__addChild(this);
+        this.y.__addChild(this);
+        _superPropGet(AnimatedValueXY, "__attach", this, 3)([]);
+      }
+    }, {
+      key: "__detach",
+      value: function __detach() {
+        this.x.__removeChild(this);
+        this.y.__removeChild(this);
+        _superPropGet(AnimatedValueXY, "__detach", this, 3)([]);
+      }
+    }, {
+      key: "__makeNative",
+      value: function __makeNative(platformConfig) {
+        this.x.__makeNative(platformConfig);
+        this.y.__makeNative(platformConfig);
+        _superPropGet(AnimatedValueXY, "__makeNative", this, 3)([platformConfig]);
+      }
+    }]);
+  }(_AnimatedWithChildren2.default);
+},413,[1,11,12,18,20,21,23,406,400,32],"../../node_modules/react-native/Libraries/Animated/nodes/AnimatedValueXY.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _readOnlyError2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/readOnlyError"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));
+  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/get"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits"));
+  var _AnimatedColor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../nodes/AnimatedColor"));
+  var SpringConfig = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[9], "../SpringConfig"));
+  var _Animation2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./Animation"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "invariant"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  var SpringAnimation = exports.default = /*#__PURE__*/function (_Animation) {
+    function SpringAnimation(config) {
+      var _config$overshootClam, _config$restDisplacem, _config$restSpeedThre, _config$velocity, _config$velocity2, _config$delay;
+      var _this;
+      (0, _classCallCheck2.default)(this, SpringAnimation);
+      _this = _callSuper(this, SpringAnimation, [config]);
+      _this._overshootClamping = (_config$overshootClam = config.overshootClamping) != null ? _config$overshootClam : false;
+      _this._restDisplacementThreshold = (_config$restDisplacem = config.restDisplacementThreshold) != null ? _config$restDisplacem : 0.001;
+      _this._restSpeedThreshold = (_config$restSpeedThre = config.restSpeedThreshold) != null ? _config$restSpeedThre : 0.001;
+      _this._initialVelocity = (_config$velocity = config.velocity) != null ? _config$velocity : 0;
+      _this._lastVelocity = (_config$velocity2 = config.velocity) != null ? _config$velocity2 : 0;
+      _this._toValue = config.toValue;
+      _this._delay = (_config$delay = config.delay) != null ? _config$delay : 0;
+      _this._platformConfig = config.platformConfig;
+      if (config.stiffness !== undefined || config.damping !== undefined || config.mass !== undefined) {
+        var _config$stiffness, _config$damping, _config$mass;
+        (0, _invariant.default)(config.bounciness === undefined && config.speed === undefined && config.tension === undefined && config.friction === undefined, 'You can define one of bounciness/speed, tension/friction, or stiffness/damping/mass, but not more than one');
+        _this._stiffness = (_config$stiffness = config.stiffness) != null ? _config$stiffness : 100;
+        _this._damping = (_config$damping = config.damping) != null ? _config$damping : 10;
+        _this._mass = (_config$mass = config.mass) != null ? _config$mass : 1;
+      } else if (config.bounciness !== undefined || config.speed !== undefined) {
+        var _config$bounciness, _config$speed;
+        (0, _invariant.default)(config.tension === undefined && config.friction === undefined && config.stiffness === undefined && config.damping === undefined && config.mass === undefined, 'You can define one of bounciness/speed, tension/friction, or stiffness/damping/mass, but not more than one');
+        var springConfig = SpringConfig.fromBouncinessAndSpeed((_config$bounciness = config.bounciness) != null ? _config$bounciness : 8, (_config$speed = config.speed) != null ? _config$speed : 12);
+        _this._stiffness = springConfig.stiffness;
+        _this._damping = springConfig.damping;
+        _this._mass = 1;
+      } else {
+        var _config$tension, _config$friction;
+        var _springConfig = SpringConfig.fromOrigamiTensionAndFriction((_config$tension = config.tension) != null ? _config$tension : 40, (_config$friction = config.friction) != null ? _config$friction : 7);
+        _this._stiffness = _springConfig.stiffness;
+        _this._damping = _springConfig.damping;
+        _this._mass = 1;
+      }
+      (0, _invariant.default)(_this._stiffness > 0, 'Stiffness value must be greater than 0');
+      (0, _invariant.default)(_this._damping > 0, 'Damping value must be greater than 0');
+      (0, _invariant.default)(_this._mass > 0, 'Mass value must be greater than 0');
+      return _this;
+    }
+    (0, _inherits2.default)(SpringAnimation, _Animation);
+    return (0, _createClass2.default)(SpringAnimation, [{
+      key: "__getNativeAnimationConfig",
+      value: function __getNativeAnimationConfig() {
+        var _this$_initialVelocit;
+        return {
+          type: 'spring',
+          overshootClamping: this._overshootClamping,
+          restDisplacementThreshold: this._restDisplacementThreshold,
+          restSpeedThreshold: this._restSpeedThreshold,
+          stiffness: this._stiffness,
+          damping: this._damping,
+          mass: this._mass,
+          initialVelocity: (_this$_initialVelocit = this._initialVelocity) != null ? _this$_initialVelocit : this._lastVelocity,
+          toValue: this._toValue,
+          iterations: this.__iterations,
+          platformConfig: this._platformConfig,
+          debugID: this.__getDebugID()
+        };
+      }
+    }, {
+      key: "start",
+      value: function start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {
+        var _this2 = this;
+        _superPropGet(SpringAnimation, "start", this, 3)([fromValue, onUpdate, onEnd, previousAnimation, animatedValue]);
+        this._startPosition = fromValue;
+        this._lastPosition = this._startPosition;
+        this._onUpdate = onUpdate;
+        this._lastTime = Date.now();
+        this._frameTime = 0.0;
+        if (previousAnimation instanceof SpringAnimation) {
+          var internalState = previousAnimation.getInternalState();
+          this._lastPosition = internalState.lastPosition;
+          this._lastVelocity = internalState.lastVelocity;
+          this._initialVelocity = this._lastVelocity;
+          this._lastTime = internalState.lastTime;
+        }
+        var start = function start() {
+          var useNativeDriver = _this2.__startAnimationIfNative(animatedValue);
+          if (!useNativeDriver) {
+            _this2.onUpdate();
+          }
+        };
+        if (this._delay) {
+          this._timeout = setTimeout(start, this._delay);
+        } else {
+          start();
+        }
+      }
+    }, {
+      key: "getInternalState",
+      value: function getInternalState() {
+        return {
+          lastPosition: this._lastPosition,
+          lastVelocity: this._lastVelocity,
+          lastTime: this._lastTime
+        };
+      }
+    }, {
+      key: "onUpdate",
+      value: function onUpdate() {
+        var MAX_STEPS = 64;
+        var now = Date.now();
+        if (now > this._lastTime + MAX_STEPS) {
+          now = this._lastTime + MAX_STEPS;
+        }
+        var deltaTime = (now - this._lastTime) / 1000;
+        this._frameTime += deltaTime;
+        var c = this._damping;
+        var m = this._mass;
+        var k = this._stiffness;
+        var v0 = -this._initialVelocity;
+        var zeta = c / (2 * Math.sqrt(k * m));
+        var omega0 = Math.sqrt(k / m);
+        var omega1 = omega0 * Math.sqrt(1.0 - zeta * zeta);
+        var x0 = this._toValue - this._startPosition;
+        var position = 0.0;
+        var velocity = 0.0;
+        var t = this._frameTime;
+        if (zeta < 1) {
+          var envelope = Math.exp(-zeta * omega0 * t);
+          position = this._toValue - envelope * ((v0 + zeta * omega0 * x0) / omega1 * Math.sin(omega1 * t) + x0 * Math.cos(omega1 * t));
+          velocity = zeta * omega0 * envelope * (Math.sin(omega1 * t) * (v0 + zeta * omega0 * x0) / omega1 + x0 * Math.cos(omega1 * t)) - envelope * (Math.cos(omega1 * t) * (v0 + zeta * omega0 * x0) - omega1 * x0 * Math.sin(omega1 * t));
+        } else {
+          var _envelope = Math.exp(-omega0 * t);
+          position = this._toValue - _envelope * (x0 + (v0 + omega0 * x0) * t);
+          velocity = _envelope * (v0 * (t * omega0 - 1) + t * x0 * (omega0 * omega0));
+        }
+        this._lastTime = now;
+        this._lastPosition = position;
+        this._lastVelocity = velocity;
+        this._onUpdate(position);
+        if (!this.__active) {
+          return;
+        }
+        var isOvershooting = false;
+        if (this._overshootClamping && this._stiffness !== 0) {
+          if (this._startPosition < this._toValue) {
+            isOvershooting = position > this._toValue;
+          } else {
+            isOvershooting = position < this._toValue;
+          }
+        }
+        var isVelocity = Math.abs(velocity) <= this._restSpeedThreshold;
+        var isDisplacement = true;
+        if (this._stiffness !== 0) {
+          isDisplacement = Math.abs(this._toValue - position) <= this._restDisplacementThreshold;
+        }
+        if (isOvershooting || isVelocity && isDisplacement) {
+          if (this._stiffness !== 0) {
+            this._lastPosition = this._toValue;
+            this._lastVelocity = 0;
+            this._onUpdate(this._toValue);
+          }
+          this.__notifyAnimationEnd({
+            finished: true
+          });
+          return;
+        }
+        this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this));
+      }
+    }, {
+      key: "stop",
+      value: function stop() {
+        _superPropGet(SpringAnimation, "stop", this, 3)([]);
+        clearTimeout(this._timeout);
+        if (this._animationFrame != null) {
+          global.cancelAnimationFrame(this._animationFrame);
+        }
+        this.__notifyAnimationEnd({
+          finished: false
+        });
+      }
+    }]);
+  }(_Animation2.default);
+},414,[1,141,11,12,18,20,21,23,415,416,390,32],"../../node_modules/react-native/Libraries/Animated/animations/SpringAnimation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _NativeAnimatedHelper = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../../../src/private/animated/NativeAnimatedHelper"));
+  var _normalizeColor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../../StyleSheet/normalizeColor"));
+  var _AnimatedValue = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[9], "./AnimatedValue"));
+  var _AnimatedWithChildren2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./AnimatedWithChildren"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  var NativeAnimatedAPI = _NativeAnimatedHelper.default.API;
+  var defaultColor = {
+    r: 0,
+    g: 0,
+    b: 0,
+    a: 1.0
+  };
+  function processColor(color) {
+    if (color === undefined || color === null) {
+      return null;
+    }
+    if (isRgbaValue(color)) {
+      return color;
+    }
+    var normalizedColor = (0, _normalizeColor.default)(color);
+    if (normalizedColor === undefined || normalizedColor === null) {
+      return null;
+    }
+    if (typeof normalizedColor === 'object') {
+      var processedColorObj = (0, _$$_REQUIRE(_dependencyMap[11], "../../StyleSheet/PlatformColorValueTypes").processColorObject)(normalizedColor);
+      if (processedColorObj != null) {
+        return processedColorObj;
+      }
+    } else if (typeof normalizedColor === 'number') {
+      var r = (normalizedColor & 0xff000000) >>> 24;
+      var g = (normalizedColor & 0x00ff0000) >>> 16;
+      var b = (normalizedColor & 0x0000ff00) >>> 8;
+      var a = (normalizedColor & 0x000000ff) / 255;
+      return {
+        r: r,
+        g: g,
+        b: b,
+        a: a
+      };
+    }
+    return null;
+  }
+  function isRgbaValue(value) {
+    return value && typeof value.r === 'number' && typeof value.g === 'number' && typeof value.b === 'number' && typeof value.a === 'number';
+  }
+  function isRgbaAnimatedValue(value) {
+    return value && value.r instanceof _AnimatedValue.default && value.g instanceof _AnimatedValue.default && value.b instanceof _AnimatedValue.default && value.a instanceof _AnimatedValue.default;
+  }
+  var AnimatedColor = exports.default = /*#__PURE__*/function (_AnimatedWithChildren) {
+    function AnimatedColor(valueIn, config) {
+      var _this;
+      (0, _classCallCheck2.default)(this, AnimatedColor);
+      _this = _callSuper(this, AnimatedColor, [config]);
+      _this._suspendCallbacks = 0;
+      var value = valueIn != null ? valueIn : defaultColor;
+      if (isRgbaAnimatedValue(value)) {
+        var rgbaAnimatedValue = value;
+        _this.r = rgbaAnimatedValue.r;
+        _this.g = rgbaAnimatedValue.g;
+        _this.b = rgbaAnimatedValue.b;
+        _this.a = rgbaAnimatedValue.a;
+      } else {
+        var _processColor;
+        var processedColor = (_processColor = processColor(value)) != null ? _processColor : defaultColor;
+        var initColor = defaultColor;
+        if (isRgbaValue(processedColor)) {
+          initColor = processedColor;
+        } else {
+          _this.nativeColor = processedColor;
+        }
+        _this.r = new _AnimatedValue.default(initColor.r);
+        _this.g = new _AnimatedValue.default(initColor.g);
+        _this.b = new _AnimatedValue.default(initColor.b);
+        _this.a = new _AnimatedValue.default(initColor.a);
+      }
+      if (config != null && config.useNativeDriver) {
+        _this.__makeNative();
+      }
+      return _this;
+    }
+    (0, _inherits2.default)(AnimatedColor, _AnimatedWithChildren);
+    return (0, _createClass2.default)(AnimatedColor, [{
+      key: "setValue",
+      value: function setValue(value) {
+        var _processColor2,
+          _this2 = this;
+        var shouldUpdateNodeConfig = false;
+        if (this.__isNative) {
+          var nativeTag = this.__getNativeTag();
+          NativeAnimatedAPI.setWaitingForIdentifier(nativeTag.toString());
+        }
+        var processedColor = (_processColor2 = processColor(value)) != null ? _processColor2 : defaultColor;
+        this._withSuspendedCallbacks(function () {
+          if (isRgbaValue(processedColor)) {
+            var rgbaValue = processedColor;
+            _this2.r.setValue(rgbaValue.r);
+            _this2.g.setValue(rgbaValue.g);
+            _this2.b.setValue(rgbaValue.b);
+            _this2.a.setValue(rgbaValue.a);
+            if (_this2.nativeColor != null) {
+              _this2.nativeColor = null;
+              shouldUpdateNodeConfig = true;
+            }
+          } else {
+            var nativeColor = processedColor;
+            if (_this2.nativeColor !== nativeColor) {
+              _this2.nativeColor = nativeColor;
+              shouldUpdateNodeConfig = true;
+            }
+          }
+        });
+        if (this.__isNative) {
+          var _nativeTag = this.__getNativeTag();
+          if (shouldUpdateNodeConfig) {
+            NativeAnimatedAPI.updateAnimatedNodeConfig(_nativeTag, this.__getNativeConfig());
+          }
+          NativeAnimatedAPI.unsetWaitingForIdentifier(_nativeTag.toString());
+        } else {
+          (0, _AnimatedValue.flushValue)(this);
+        }
+        this.__callListeners(this.__getValue());
+      }
+    }, {
+      key: "setOffset",
+      value: function setOffset(offset) {
+        this.r.setOffset(offset.r);
+        this.g.setOffset(offset.g);
+        this.b.setOffset(offset.b);
+        this.a.setOffset(offset.a);
+      }
+    }, {
+      key: "flattenOffset",
+      value: function flattenOffset() {
+        this.r.flattenOffset();
+        this.g.flattenOffset();
+        this.b.flattenOffset();
+        this.a.flattenOffset();
+      }
+    }, {
+      key: "extractOffset",
+      value: function extractOffset() {
+        this.r.extractOffset();
+        this.g.extractOffset();
+        this.b.extractOffset();
+        this.a.extractOffset();
+      }
+    }, {
+      key: "stopAnimation",
+      value: function stopAnimation(callback) {
+        this.r.stopAnimation();
+        this.g.stopAnimation();
+        this.b.stopAnimation();
+        this.a.stopAnimation();
+        callback && callback(this.__getValue());
+      }
+    }, {
+      key: "resetAnimation",
+      value: function resetAnimation(callback) {
+        this.r.resetAnimation();
+        this.g.resetAnimation();
+        this.b.resetAnimation();
+        this.a.resetAnimation();
+        callback && callback(this.__getValue());
+      }
+    }, {
+      key: "__getValue",
+      value: function __getValue() {
+        if (this.nativeColor != null) {
+          return this.nativeColor;
+        } else {
+          return `rgba(${this.r.__getValue()}, ${this.g.__getValue()}, ${this.b.__getValue()}, ${this.a.__getValue()})`;
+        }
+      }
+    }, {
+      key: "__attach",
+      value: function __attach() {
+        this.r.__addChild(this);
+        this.g.__addChild(this);
+        this.b.__addChild(this);
+        this.a.__addChild(this);
+        _superPropGet(AnimatedColor, "__attach", this, 3)([]);
+      }
+    }, {
+      key: "__detach",
+      value: function __detach() {
+        this.r.__removeChild(this);
+        this.g.__removeChild(this);
+        this.b.__removeChild(this);
+        this.a.__removeChild(this);
+        _superPropGet(AnimatedColor, "__detach", this, 3)([]);
+      }
+    }, {
+      key: "_withSuspendedCallbacks",
+      value: function _withSuspendedCallbacks(callback) {
+        this._suspendCallbacks++;
+        callback();
+        this._suspendCallbacks--;
+      }
+    }, {
+      key: "__callListeners",
+      value: function __callListeners(value) {
+        if (this._suspendCallbacks === 0) {
+          _superPropGet(AnimatedColor, "__callListeners", this, 3)([value]);
+        }
+      }
+    }, {
+      key: "__makeNative",
+      value: function __makeNative(platformConfig) {
+        this.r.__makeNative(platformConfig);
+        this.g.__makeNative(platformConfig);
+        this.b.__makeNative(platformConfig);
+        this.a.__makeNative(platformConfig);
+        _superPropGet(AnimatedColor, "__makeNative", this, 3)([platformConfig]);
+      }
+    }, {
+      key: "__getNativeConfig",
+      value: function __getNativeConfig() {
+        return {
+          type: 'color',
+          r: this.r.__getNativeTag(),
+          g: this.g.__getNativeTag(),
+          b: this.b.__getNativeTag(),
+          a: this.a.__getNativeTag(),
+          nativeColor: this.nativeColor,
+          debugID: this.__getDebugID()
+        };
+      }
+    }]);
+  }(_AnimatedWithChildren2.default);
+},415,[1,11,12,18,20,21,23,391,58,406,400,60],"../../node_modules/react-native/Libraries/Animated/nodes/AnimatedColor.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.fromBouncinessAndSpeed = fromBouncinessAndSpeed;
+  exports.fromOrigamiTensionAndFriction = fromOrigamiTensionAndFriction;
+  function stiffnessFromOrigamiValue(oValue) {
+    return (oValue - 30) * 3.62 + 194;
+  }
+  function dampingFromOrigamiValue(oValue) {
+    return (oValue - 8) * 3 + 25;
+  }
+  function fromOrigamiTensionAndFriction(tension, friction) {
+    return {
+      stiffness: stiffnessFromOrigamiValue(tension),
+      damping: dampingFromOrigamiValue(friction)
+    };
+  }
+  function fromBouncinessAndSpeed(bounciness, speed) {
+    function normalize(value, startValue, endValue) {
+      return (value - startValue) / (endValue - startValue);
+    }
+    function projectNormal(n, start, end) {
+      return start + n * (end - start);
+    }
+    function linearInterpolation(t, start, end) {
+      return t * end + (1 - t) * start;
+    }
+    function quadraticOutInterpolation(t, start, end) {
+      return linearInterpolation(2 * t - t * t, start, end);
+    }
+    function b3Friction1(x) {
+      return 0.0007 * Math.pow(x, 3) - 0.031 * Math.pow(x, 2) + 0.64 * x + 1.28;
+    }
+    function b3Friction2(x) {
+      return 0.000044 * Math.pow(x, 3) - 0.006 * Math.pow(x, 2) + 0.36 * x + 2;
+    }
+    function b3Friction3(x) {
+      return 0.00000045 * Math.pow(x, 3) - 0.000332 * Math.pow(x, 2) + 0.1078 * x + 5.84;
+    }
+    function b3Nobounce(tension) {
+      if (tension <= 18) {
+        return b3Friction1(tension);
+      } else if (tension > 18 && tension <= 44) {
+        return b3Friction2(tension);
+      } else {
+        return b3Friction3(tension);
+      }
+    }
+    var b = normalize(bounciness / 1.7, 0, 20);
+    b = projectNormal(b, 0, 0.8);
+    var s = normalize(speed / 1.7, 0, 20);
+    var bouncyTension = projectNormal(s, 0.5, 200);
+    var bouncyFriction = quadraticOutInterpolation(b, b3Nobounce(bouncyTension), 0.01);
+    return {
+      stiffness: stiffnessFromOrigamiValue(bouncyTension),
+      damping: dampingFromOrigamiValue(bouncyFriction)
+    };
+  }
+},416,[],"../../node_modules/react-native/Libraries/Animated/SpringConfig.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _readOnlyError2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/readOnlyError"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));
+  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/get"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits"));
+  var _AnimatedColor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../nodes/AnimatedColor"));
+  var _Animation2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./Animation"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  var _easeInOut;
+  function easeInOut() {
+    if (!_easeInOut) {
+      var Easing = _$$_REQUIRE(_dependencyMap[10], "../Easing").default;
+      _easeInOut = Easing.inOut(Easing.ease);
+    }
+    return _easeInOut;
+  }
+  var TimingAnimation = exports.default = /*#__PURE__*/function (_Animation) {
+    function TimingAnimation(config) {
+      var _config$easing, _config$duration, _config$delay;
+      var _this;
+      (0, _classCallCheck2.default)(this, TimingAnimation);
+      _this = _callSuper(this, TimingAnimation, [config]);
+      _this._toValue = config.toValue;
+      _this._easing = (_config$easing = config.easing) != null ? _config$easing : easeInOut();
+      _this._duration = (_config$duration = config.duration) != null ? _config$duration : 500;
+      _this._delay = (_config$delay = config.delay) != null ? _config$delay : 0;
+      _this._platformConfig = config.platformConfig;
+      return _this;
+    }
+    (0, _inherits2.default)(TimingAnimation, _Animation);
+    return (0, _createClass2.default)(TimingAnimation, [{
+      key: "__getNativeAnimationConfig",
+      value: function __getNativeAnimationConfig() {
+        var frameDuration = 1000.0 / 60.0;
+        var frames = [];
+        var numFrames = Math.round(this._duration / frameDuration);
+        for (var frame = 0; frame < numFrames; frame++) {
+          frames.push(this._easing(frame / numFrames));
+        }
+        frames.push(this._easing(1));
+        return {
+          type: 'frames',
+          frames: frames,
+          toValue: this._toValue,
+          iterations: this.__iterations,
+          platformConfig: this._platformConfig,
+          debugID: this.__getDebugID()
+        };
+      }
+    }, {
+      key: "start",
+      value: function start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {
+        var _this2 = this;
+        _superPropGet(TimingAnimation, "start", this, 3)([fromValue, onUpdate, onEnd, previousAnimation, animatedValue]);
+        this._fromValue = fromValue;
+        this._onUpdate = onUpdate;
+        var start = function start() {
+          _this2._startTime = Date.now();
+          var useNativeDriver = _this2.__startAnimationIfNative(animatedValue);
+          if (!useNativeDriver) {
+            if (_this2._duration === 0) {
+              _this2._onUpdate(_this2._toValue);
+              _this2.__notifyAnimationEnd({
+                finished: true
+              });
+            } else {
+              _this2._animationFrame = requestAnimationFrame(function () {
+                return _this2.onUpdate();
+              });
+            }
+          }
+        };
+        if (this._delay) {
+          this._timeout = setTimeout(start, this._delay);
+        } else {
+          start();
+        }
+      }
+    }, {
+      key: "onUpdate",
+      value: function onUpdate() {
+        var now = Date.now();
+        if (now >= this._startTime + this._duration) {
+          if (this._duration === 0) {
+            this._onUpdate(this._toValue);
+          } else {
+            this._onUpdate(this._fromValue + this._easing(1) * (this._toValue - this._fromValue));
+          }
+          this.__notifyAnimationEnd({
+            finished: true
+          });
+          return;
+        }
+        this._onUpdate(this._fromValue + this._easing((now - this._startTime) / this._duration) * (this._toValue - this._fromValue));
+        if (this.__active) {
+          this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this));
+        }
+      }
+    }, {
+      key: "stop",
+      value: function stop() {
+        _superPropGet(TimingAnimation, "stop", this, 3)([]);
+        clearTimeout(this._timeout);
+        if (this._animationFrame != null) {
+          global.cancelAnimationFrame(this._animationFrame);
+        }
+        this.__notifyAnimationEnd({
+          finished: false
+        });
+      }
+    }]);
+  }(_Animation2.default);
+},417,[1,141,11,12,18,20,21,23,415,390,411],"../../node_modules/react-native/Libraries/Animated/animations/TimingAnimation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = createAnimatedComponent;
+  exports.unstable_createAnimatedComponentWithAllowlist = unstable_createAnimatedComponentWithAllowlist;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _createAnimatedPropsHook = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../src/private/animated/createAnimatedPropsHook"));
+  var _composeStyles = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../src/private/styles/composeStyles"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../Components/View/View"));
+  var _useMergeRefs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../Utilities/useMergeRefs"));
+  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[6], "react"));
+  var React = _react;
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[7], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Animated/createAnimatedComponent.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function createAnimatedComponent(Component) {
+    return unstable_createAnimatedComponentWithAllowlist(Component, null);
+  }
+  function unstable_createAnimatedComponentWithAllowlist(Component, allowlist) {
+    var _this = this;
+    var useAnimatedProps = (0, _createAnimatedPropsHook.default)(allowlist);
+    var AnimatedComponent = React.forwardRef(function (props, forwardedRef) {
+      var _useAnimatedProps = useAnimatedProps(props),
+        _useAnimatedProps2 = (0, _slicedToArray2.default)(_useAnimatedProps, 2),
+        reducedProps = _useAnimatedProps2[0],
+        callbackRef = _useAnimatedProps2[1];
+      var ref = (0, _useMergeRefs.default)(callbackRef, forwardedRef);
+      var passthroughAnimatedPropExplicitValues = reducedProps.passthroughAnimatedPropExplicitValues,
+        style = reducedProps.style;
+      var passthroughStyle = passthroughAnimatedPropExplicitValues == null ? void 0 : passthroughAnimatedPropExplicitValues.style;
+      var mergedStyle = (0, _react.useMemo)(function () {
+        return (0, _composeStyles.default)(style, passthroughStyle);
+      }, [passthroughStyle, style]);
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(Component, Object.assign({}, reducedProps, passthroughAnimatedPropExplicitValues, {
+        style: mergedStyle,
+        ref: ref
+      }));
+    });
+    AnimatedComponent.displayName = `Animated(${Component.displayName || 'Anonymous'})`;
+    return AnimatedComponent;
+  }
+},418,[1,34,419,8,71,364,73,171],"../../node_modules/react-native/Libraries/Animated/createAnimatedComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = createAnimatedPropsHook;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _AnimatedNode = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../../Libraries/Animated/nodes/AnimatedNode"));
+  var _AnimatedProps = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../../Libraries/Animated/nodes/AnimatedProps"));
+  var _AnimatedValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../../../Libraries/Animated/nodes/AnimatedValue"));
+  var _useRefEffect = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../../../Libraries/Utilities/useRefEffect"));
+  var ReactNativeFeatureFlags = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[6], "../featureflags/ReactNativeFeatureFlags"));
+  var _NativeAnimatedHelper = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./NativeAnimatedHelper"));
+  var _react = _$$_REQUIRE(_dependencyMap[8], "react");
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function createAnimatedPropsHook(allowlist) {
+    var useAnimatedPropsMemo = (0, _$$_REQUIRE(_dependencyMap[9], "./createAnimatedPropsMemoHook").createAnimatedPropsMemoHook)(allowlist);
+    var useNativePropsInFabric = ReactNativeFeatureFlags.shouldUseSetNativePropsInFabric();
+    return function useAnimatedProps(props) {
+      var _useReducer = (0, _react.useReducer)(function (count) {
+          return count + 1;
+        }, 0),
+        _useReducer2 = (0, _slicedToArray2.default)(_useReducer, 2),
+        scheduleUpdate = _useReducer2[1];
+      var onUpdateRef = (0, _react.useRef)(null);
+      var timerRef = (0, _react.useRef)(null);
+      var node = useAnimatedPropsMemo(function () {
+        return new _AnimatedProps.default(props, function () {
+          return onUpdateRef.current == null ? void 0 : onUpdateRef.current();
+        }, allowlist);
+      }, props);
+      (0, _react.useEffect)(function () {
+        _NativeAnimatedHelper.default.API.flushQueue();
+        var drivenAnimationEndedListener = null;
+        if (node.__isNative) {
+          drivenAnimationEndedListener = _NativeAnimatedHelper.default.nativeEventEmitter.addListener('onUserDrivenAnimationEnded', function (data) {
+            node.update();
+          });
+        }
+        return function () {
+          var _drivenAnimationEnded;
+          (_drivenAnimationEnded = drivenAnimationEndedListener) == null || _drivenAnimationEnded.remove();
+        };
+      });
+      var useAnimatedPropsLifecycle = ReactNativeFeatureFlags.scheduleAnimatedCleanupInMicrotask() ? useAnimatedPropsLifecycleWithCleanupInMicrotask : useAnimatedPropsLifecycleWithPrevNodeRef;
+      useAnimatedPropsLifecycle(node);
+      var refEffect = (0, _react.useCallback)(function (instance) {
+        node.setNativeView(instance);
+        onUpdateRef.current = function () {
+          if (process.env.NODE_ENV === 'test') {
+            return scheduleUpdate();
+          }
+          var isFabricNode = isFabricInstance(instance);
+          if (node.__isNative) {
+            if (isFabricNode) {
+              scheduleUpdate();
+            }
+            return;
+          }
+          if (typeof instance !== 'object' || typeof (instance == null ? void 0 : instance.setNativeProps) !== 'function') {
+            return scheduleUpdate();
+          }
+          if (!isFabricNode) {
+            return instance.setNativeProps(node.__getAnimatedValue());
+          }
+          if (!useNativePropsInFabric) {
+            return scheduleUpdate();
+          }
+          instance.setNativeProps(node.__getAnimatedValue());
+          if (timerRef.current != null) {
+            clearTimeout(timerRef.current);
+          }
+          timerRef.current = setTimeout(function () {
+            timerRef.current = null;
+            scheduleUpdate();
+          }, 48);
+        };
+        var target = getEventTarget(instance);
+        var animatedValueListeners = [];
+        var eventTuples = node.__getNativeAnimatedEventTuples();
+        for (var _ref of eventTuples) {
+          var _ref2 = (0, _slicedToArray2.default)(_ref, 2);
+          var propName = _ref2[0];
+          var propValue = _ref2[1];
+          propValue.__attach(target, propName);
+          addListenersToPropsValue(propValue, animatedValueListeners);
+        }
+        return function () {
+          onUpdateRef.current = null;
+          for (var _ref3 of eventTuples) {
+            var _ref4 = (0, _slicedToArray2.default)(_ref3, 2);
+            var _propName = _ref4[0];
+            var _propValue = _ref4[1];
+            _propValue.__detach(target, _propName);
+          }
+          for (var _ref5 of animatedValueListeners) {
+            var _propValue2 = _ref5.propValue;
+            var listenerId = _ref5.listenerId;
+            _propValue2.removeListener(listenerId);
+          }
+        };
+      }, [node]);
+      var callbackRef = (0, _useRefEffect.default)(refEffect);
+      return [reduceAnimatedProps(node, props), callbackRef];
+    };
+  }
+  function reduceAnimatedProps(node, props) {
+    return Object.assign({}, node.__getValueWithStaticProps(props), {
+      collapsable: false
+    });
+  }
+  function addListenersToPropsValue(propValue, accumulator) {
+    if (propValue instanceof _AnimatedValue.default) {
+      var listenerId = propValue.addListener(function () {});
+      accumulator.push({
+        propValue: propValue,
+        listenerId: listenerId
+      });
+    } else if (Array.isArray(propValue)) {
+      for (var prop of propValue) {
+        addListenersToPropsValue(prop, accumulator);
+      }
+    } else if (propValue instanceof Object) {
+      addAnimatedValuesListenersToProps(propValue, accumulator);
+    }
+  }
+  function addAnimatedValuesListenersToProps(props, accumulator) {
+    for (var propName in props) {
+      var propValue = props[propName];
+      addListenersToPropsValue(propValue, accumulator);
+    }
+  }
+  function useAnimatedPropsLifecycleWithPrevNodeRef(node) {
+    var prevNodeRef = (0, _react.useRef)(null);
+    var isUnmountingRef = (0, _react.useRef)(false);
+    (0, _react.useInsertionEffect)(function () {
+      isUnmountingRef.current = false;
+      return function () {
+        isUnmountingRef.current = true;
+      };
+    }, []);
+    (0, _react.useInsertionEffect)(function () {
+      node.__attach();
+      if (prevNodeRef.current != null) {
+        var prevNode = prevNodeRef.current;
+        prevNode.__restoreDefaultValues();
+        prevNode.__detach();
+        prevNodeRef.current = null;
+      }
+      return function () {
+        if (isUnmountingRef.current) {
+          node.__detach();
+        } else {
+          prevNodeRef.current = node;
+        }
+      };
+    }, [node]);
+  }
+  function useAnimatedPropsLifecycleWithCleanupInMicrotask(node) {
+    var isMounted = (0, _react.useRef)(false);
+    (0, _react.useInsertionEffect)(function () {
+      isMounted.current = true;
+      node.__attach();
+      return function () {
+        isMounted.current = false;
+        queueMicrotask(function () {
+          if (isMounted.current) {
+            node.__restoreDefaultValues();
+          }
+          node.__detach();
+        });
+      };
+    }, [node]);
+  }
+  function getEventTarget(instance) {
+    return typeof instance === 'object' && typeof (instance == null ? void 0 : instance.getScrollableNode) === 'function' ? instance.getScrollableNode() : instance;
+  }
+  function isFabricInstance(instance) {
+    var _instance$getScrollRe;
+    return (0, _$$_REQUIRE(_dependencyMap[10], "../../../Libraries/ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstanceUtils").isPublicInstance)(instance) || (0, _$$_REQUIRE(_dependencyMap[10], "../../../Libraries/ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstanceUtils").isPublicInstance)(instance == null || instance.getNativeScrollRef == null ? void 0 : instance.getNativeScrollRef()) || (0, _$$_REQUIRE(_dependencyMap[10], "../../../Libraries/ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstanceUtils").isPublicInstance)(instance == null || instance.getScrollResponder == null || (_instance$getScrollRe = instance.getScrollResponder()) == null || _instance$getScrollRe.getNativeScrollRef == null ? void 0 : _instance$getScrollRe.getNativeScrollRef());
+  }
+},419,[1,34,398,397,406,365,52,391,73,420,421],"../../node_modules/react-native/src/private/animated/createAnimatedPropsHook.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.areCompositeKeysEqual = areCompositeKeysEqual;
+  exports.createAnimatedPropsMemoHook = createAnimatedPropsMemoHook;
+  exports.createCompositeKeyForProps = createCompositeKeyForProps;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _AnimatedNode = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../../Libraries/Animated/nodes/AnimatedNode"));
+  var _flattenStyle = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../../Libraries/StyleSheet/flattenStyle"));
+  var ReactNativeFeatureFlags = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[4], "../featureflags/ReactNativeFeatureFlags"));
+  var _nullthrows = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "nullthrows"));
+  var _react = _$$_REQUIRE(_dependencyMap[6], "react");
+  var _Object$hasOwn;
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function createAnimatedPropsMemoHook(allowlist) {
+    return function useAnimatedPropsMemo(create, props) {
+      var useAnimatedPropsImpl = ReactNativeFeatureFlags.avoidStateUpdateInAnimatedPropsMemo() ? useAnimatedPropsMemo_ref : useAnimatedPropsMemo_state;
+      return useAnimatedPropsImpl(create, props);
+    };
+    function useAnimatedPropsMemo_ref(create, props) {
+      var compositeKey = (0, _react.useMemo)(function () {
+        return createCompositeKeyForProps(props, allowlist);
+      }, [props]);
+      var prevRef = (0, _react.useRef)();
+      var prev = prevRef.current;
+      var next = prev != null && areCompositeKeysEqual(prev.compositeKey, compositeKey) ? prev : {
+        compositeKey: compositeKey,
+        node: create()
+      };
+      (0, _react.useInsertionEffect)(function () {
+        prevRef.current = next;
+      }, [next]);
+      return next.node;
+    }
+    function useAnimatedPropsMemo_state(create, props) {
+      var compositeKey = (0, _react.useMemo)(function () {
+        return createCompositeKeyForProps(props, allowlist);
+      }, [props]);
+      var _useState = (0, _react.useState)(function () {
+          return {
+            allowlist: allowlist,
+            compositeKey: compositeKey,
+            value: create()
+          };
+        }),
+        _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+        state = _useState2[0],
+        setState = _useState2[1];
+      if (state.allowlist !== allowlist || !areCompositeKeysEqual(state.compositeKey, compositeKey)) {
+        setState({
+          allowlist: allowlist,
+          compositeKey: compositeKey,
+          value: create()
+        });
+      }
+      return state.value;
+    }
+  }
+  function createCompositeKeyForProps(props, allowlist) {
+    var compositeKey = null;
+    var keys = Object.keys(props);
+    for (var ii = 0, length = keys.length; ii < length; ii++) {
+      var key = keys[ii];
+      var value = props[key];
+      if (allowlist == null || hasOwn(allowlist, key)) {
+        var compositeKeyComponent = void 0;
+        if (key === 'style') {
+          var flatStyle = (0, _flattenStyle.default)(value);
+          if (flatStyle != null) {
+            compositeKeyComponent = createCompositeKeyForObject(flatStyle, allowlist == null ? void 0 : allowlist.style);
+          }
+        } else if (value instanceof _AnimatedNode.default || value instanceof _$$_REQUIRE(_dependencyMap[7], "../../../Libraries/Animated/AnimatedEvent").AnimatedEvent) {
+          compositeKeyComponent = value;
+        } else if (Array.isArray(value)) {
+          compositeKeyComponent = allowlist == null ? value : createCompositeKeyForArray(value);
+        } else if ((0, _$$_REQUIRE(_dependencyMap[8], "../../../Libraries/Animated/nodes/AnimatedObject").isPlainObject)(value)) {
+          compositeKeyComponent = allowlist == null ? value : createCompositeKeyForObject(value);
+        }
+        if (compositeKeyComponent != null) {
+          if (compositeKey == null) {
+            compositeKey = {};
+          }
+          compositeKey[key] = compositeKeyComponent;
+        }
+      }
+    }
+    return compositeKey;
+  }
+  function createCompositeKeyForArray(array) {
+    var compositeKey = null;
+    for (var ii = 0, length = array.length; ii < length; ii++) {
+      var value = array[ii];
+      var compositeKeyComponent = void 0;
+      if (value instanceof _AnimatedNode.default) {
+        compositeKeyComponent = value;
+      } else if (Array.isArray(value)) {
+        compositeKeyComponent = createCompositeKeyForArray(value);
+      } else if ((0, _$$_REQUIRE(_dependencyMap[8], "../../../Libraries/Animated/nodes/AnimatedObject").isPlainObject)(value)) {
+        compositeKeyComponent = createCompositeKeyForObject(value);
+      }
+      if (compositeKeyComponent != null) {
+        if (compositeKey == null) {
+          compositeKey = new Array(array.length).fill(null);
+        }
+        compositeKey[ii] = compositeKeyComponent;
+      }
+    }
+    return compositeKey;
+  }
+  function createCompositeKeyForObject(object, allowlist) {
+    var compositeKey = null;
+    var keys = Object.keys(object);
+    for (var ii = 0, length = keys.length; ii < length; ii++) {
+      var key = keys[ii];
+      if (allowlist == null || hasOwn(allowlist, key)) {
+        var value = object[key];
+        var compositeKeyComponent = void 0;
+        if (value instanceof _AnimatedNode.default) {
+          compositeKeyComponent = value;
+        } else if (Array.isArray(value)) {
+          compositeKeyComponent = createCompositeKeyForArray(value);
+        } else if ((0, _$$_REQUIRE(_dependencyMap[8], "../../../Libraries/Animated/nodes/AnimatedObject").isPlainObject)(value)) {
+          compositeKeyComponent = createCompositeKeyForObject(value);
+        }
+        if (compositeKeyComponent != null) {
+          if (compositeKey == null) {
+            compositeKey = {};
+          }
+          compositeKey[key] = compositeKeyComponent;
+        }
+      }
+    }
+    return compositeKey;
+  }
+  function areCompositeKeysEqual(maybePrev, maybeNext, allowlist) {
+    if (maybePrev === maybeNext) {
+      return true;
+    }
+    if (maybePrev === null || maybeNext === null) {
+      return false;
+    }
+    var prev = maybePrev;
+    var next = maybeNext;
+    var keys = Object.keys(prev);
+    var length = keys.length;
+    if (length !== Object.keys(next).length) {
+      return false;
+    }
+    for (var ii = 0; ii < length; ii++) {
+      var key = keys[ii];
+      if (!hasOwn(next, key)) {
+        return false;
+      }
+      var prevComponent = prev[key];
+      var nextComponent = next[key];
+      if (key === 'style') {
+        if (!areCompositeKeyComponentsEqual(prevComponent, nextComponent)) {
+          return false;
+        }
+      } else if (prevComponent instanceof _AnimatedNode.default || prevComponent instanceof _$$_REQUIRE(_dependencyMap[7], "../../../Libraries/Animated/AnimatedEvent").AnimatedEvent) {
+        if (prevComponent !== nextComponent) {
+          return false;
+        }
+      } else {
+        if (allowlist == null) {
+          if (prevComponent !== nextComponent) {
+            return false;
+          }
+        } else {
+          if (!areCompositeKeyComponentsEqual(prevComponent, nextComponent)) {
+            return false;
+          }
+        }
+      }
+    }
+    return true;
+  }
+  function areCompositeKeyComponentsEqual(prev, next) {
+    if (prev === next) {
+      return true;
+    }
+    if (prev instanceof _AnimatedNode.default) {
+      return prev === next;
+    }
+    if (Array.isArray(prev)) {
+      if (!Array.isArray(next)) {
+        return false;
+      }
+      var length = prev.length;
+      if (length !== next.length) {
+        return false;
+      }
+      for (var ii = 0; ii < length; ii++) {
+        if (!areCompositeKeyComponentsEqual(prev[ii], next[ii])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if ((0, _$$_REQUIRE(_dependencyMap[8], "../../../Libraries/Animated/nodes/AnimatedObject").isPlainObject)(prev)) {
+      if (!(0, _$$_REQUIRE(_dependencyMap[8], "../../../Libraries/Animated/nodes/AnimatedObject").isPlainObject)(next)) {
+        return false;
+      }
+      var keys = Object.keys(prev);
+      var _length = keys.length;
+      if (_length !== Object.keys(next).length) {
+        return false;
+      }
+      for (var _ii = 0; _ii < _length; _ii++) {
+        var key = keys[_ii];
+        if (!hasOwn((0, _nullthrows.default)(next), key) || !areCompositeKeyComponentsEqual(prev[key], next[key])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    return false;
+  }
+  var _hasOwnProp = Object.prototype.hasOwnProperty;
+  var hasOwn = (_Object$hasOwn = Object.hasOwn) != null ? _Object$hasOwn : function (obj, prop) {
+    return _hasOwnProp.call(obj, prop);
+  };
+},420,[1,34,398,9,52,80,73,405,399],"../../node_modules/react-native/src/private/animated/createAnimatedPropsMemoHook.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.isPublicInstance = isPublicInstance;
+  function isPublicInstance(maybeInstance) {
+    return maybeInstance != null && (maybeInstance.__nativeTag != null || isLegacyFabricInstance(maybeInstance));
+  }
+  function isLegacyFabricInstance(maybeInstance) {
+    return maybeInstance != null && maybeInstance['_internalInstanceHandle'] != null && maybeInstance['_internalInstanceHandle'].stateNode != null && maybeInstance['_internalInstanceHandle'].stateNode.canonical != null;
+  }
+},421,[],"../../node_modules/react-native/Libraries/ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstanceUtils.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _AnimatedInterpolation = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./AnimatedInterpolation"));
+  var _AnimatedValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./AnimatedValue"));
+  var _AnimatedWithChildren2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./AnimatedWithChildren"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  var AnimatedAddition = exports.default = /*#__PURE__*/function (_AnimatedWithChildren) {
+    function AnimatedAddition(a, b, config) {
+      var _this;
+      (0, _classCallCheck2.default)(this, AnimatedAddition);
+      _this = _callSuper(this, AnimatedAddition, [config]);
+      _this._a = typeof a === 'number' ? new _AnimatedValue.default(a) : a;
+      _this._b = typeof b === 'number' ? new _AnimatedValue.default(b) : b;
+      return _this;
+    }
+    (0, _inherits2.default)(AnimatedAddition, _AnimatedWithChildren);
+    return (0, _createClass2.default)(AnimatedAddition, [{
+      key: "__makeNative",
+      value: function __makeNative(platformConfig) {
+        this._a.__makeNative(platformConfig);
+        this._b.__makeNative(platformConfig);
+        _superPropGet(AnimatedAddition, "__makeNative", this, 3)([platformConfig]);
+      }
+    }, {
+      key: "__getValue",
+      value: function __getValue() {
+        return this._a.__getValue() + this._b.__getValue();
+      }
+    }, {
+      key: "interpolate",
+      value: function interpolate(config) {
+        return new _AnimatedInterpolation.default(this, config);
+      }
+    }, {
+      key: "__attach",
+      value: function __attach() {
+        this._a.__addChild(this);
+        this._b.__addChild(this);
+        _superPropGet(AnimatedAddition, "__attach", this, 3)([]);
+      }
+    }, {
+      key: "__detach",
+      value: function __detach() {
+        this._a.__removeChild(this);
+        this._b.__removeChild(this);
+        _superPropGet(AnimatedAddition, "__detach", this, 3)([]);
+      }
+    }, {
+      key: "__getNativeConfig",
+      value: function __getNativeConfig() {
+        return {
+          type: 'addition',
+          input: [this._a.__getNativeTag(), this._b.__getNativeTag()],
+          debugID: this.__getDebugID()
+        };
+      }
+    }]);
+  }(_AnimatedWithChildren2.default);
+},422,[1,11,12,18,20,21,23,410,406,400],"../../node_modules/react-native/Libraries/Animated/nodes/AnimatedAddition.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _AnimatedInterpolation = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./AnimatedInterpolation"));
+  var _AnimatedWithChildren2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./AnimatedWithChildren"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  var AnimatedDiffClamp = exports.default = /*#__PURE__*/function (_AnimatedWithChildren) {
+    function AnimatedDiffClamp(a, min, max, config) {
+      var _this;
+      (0, _classCallCheck2.default)(this, AnimatedDiffClamp);
+      _this = _callSuper(this, AnimatedDiffClamp, [config]);
+      _this._a = a;
+      _this._min = min;
+      _this._max = max;
+      _this._value = _this._lastValue = _this._a.__getValue();
+      return _this;
+    }
+    (0, _inherits2.default)(AnimatedDiffClamp, _AnimatedWithChildren);
+    return (0, _createClass2.default)(AnimatedDiffClamp, [{
+      key: "__makeNative",
+      value: function __makeNative(platformConfig) {
+        this._a.__makeNative(platformConfig);
+        _superPropGet(AnimatedDiffClamp, "__makeNative", this, 3)([platformConfig]);
+      }
+    }, {
+      key: "interpolate",
+      value: function interpolate(config) {
+        return new _AnimatedInterpolation.default(this, config);
+      }
+    }, {
+      key: "__getValue",
+      value: function __getValue() {
+        var value = this._a.__getValue();
+        var diff = value - this._lastValue;
+        this._lastValue = value;
+        this._value = Math.min(Math.max(this._value + diff, this._min), this._max);
+        return this._value;
+      }
+    }, {
+      key: "__attach",
+      value: function __attach() {
+        this._a.__addChild(this);
+        _superPropGet(AnimatedDiffClamp, "__attach", this, 3)([]);
+      }
+    }, {
+      key: "__detach",
+      value: function __detach() {
+        this._a.__removeChild(this);
+        _superPropGet(AnimatedDiffClamp, "__detach", this, 3)([]);
+      }
+    }, {
+      key: "__getNativeConfig",
+      value: function __getNativeConfig() {
+        return {
+          type: 'diffclamp',
+          input: this._a.__getNativeTag(),
+          min: this._min,
+          max: this._max,
+          debugID: this.__getDebugID()
+        };
+      }
+    }]);
+  }(_AnimatedWithChildren2.default);
+},423,[1,11,12,18,20,21,23,410,400],"../../node_modules/react-native/Libraries/Animated/nodes/AnimatedDiffClamp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _AnimatedInterpolation = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./AnimatedInterpolation"));
+  var _AnimatedNode = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./AnimatedNode"));
+  var _AnimatedValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./AnimatedValue"));
+  var _AnimatedWithChildren2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./AnimatedWithChildren"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  var AnimatedDivision = exports.default = /*#__PURE__*/function (_AnimatedWithChildren) {
+    function AnimatedDivision(a, b, config) {
+      var _this;
+      (0, _classCallCheck2.default)(this, AnimatedDivision);
+      _this = _callSuper(this, AnimatedDivision, [config]);
+      _this._warnedAboutDivideByZero = false;
+      if (b === 0 || b instanceof _AnimatedNode.default && b.__getValue() === 0) {
+        console.error('Detected potential division by zero in AnimatedDivision');
+      }
+      _this._a = typeof a === 'number' ? new _AnimatedValue.default(a) : a;
+      _this._b = typeof b === 'number' ? new _AnimatedValue.default(b) : b;
+      return _this;
+    }
+    (0, _inherits2.default)(AnimatedDivision, _AnimatedWithChildren);
+    return (0, _createClass2.default)(AnimatedDivision, [{
+      key: "__makeNative",
+      value: function __makeNative(platformConfig) {
+        this._a.__makeNative(platformConfig);
+        this._b.__makeNative(platformConfig);
+        _superPropGet(AnimatedDivision, "__makeNative", this, 3)([platformConfig]);
+      }
+    }, {
+      key: "__getValue",
+      value: function __getValue() {
+        var a = this._a.__getValue();
+        var b = this._b.__getValue();
+        if (b === 0) {
+          if (!this._warnedAboutDivideByZero) {
+            console.error('Detected division by zero in AnimatedDivision');
+            this._warnedAboutDivideByZero = true;
+          }
+          return 0;
+        }
+        this._warnedAboutDivideByZero = false;
+        return a / b;
+      }
+    }, {
+      key: "interpolate",
+      value: function interpolate(config) {
+        return new _AnimatedInterpolation.default(this, config);
+      }
+    }, {
+      key: "__attach",
+      value: function __attach() {
+        this._a.__addChild(this);
+        this._b.__addChild(this);
+        _superPropGet(AnimatedDivision, "__attach", this, 3)([]);
+      }
+    }, {
+      key: "__detach",
+      value: function __detach() {
+        this._a.__removeChild(this);
+        this._b.__removeChild(this);
+        _superPropGet(AnimatedDivision, "__detach", this, 3)([]);
+      }
+    }, {
+      key: "__getNativeConfig",
+      value: function __getNativeConfig() {
+        return {
+          type: 'division',
+          input: [this._a.__getNativeTag(), this._b.__getNativeTag()],
+          debugID: this.__getDebugID()
+        };
+      }
+    }]);
+  }(_AnimatedWithChildren2.default);
+},424,[1,11,12,18,20,21,23,410,398,406,400],"../../node_modules/react-native/Libraries/Animated/nodes/AnimatedDivision.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _AnimatedInterpolation = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./AnimatedInterpolation"));
+  var _AnimatedWithChildren2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./AnimatedWithChildren"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  var AnimatedModulo = exports.default = /*#__PURE__*/function (_AnimatedWithChildren) {
+    function AnimatedModulo(a, modulus, config) {
+      var _this;
+      (0, _classCallCheck2.default)(this, AnimatedModulo);
+      _this = _callSuper(this, AnimatedModulo, [config]);
+      _this._a = a;
+      _this._modulus = modulus;
+      return _this;
+    }
+    (0, _inherits2.default)(AnimatedModulo, _AnimatedWithChildren);
+    return (0, _createClass2.default)(AnimatedModulo, [{
+      key: "__makeNative",
+      value: function __makeNative(platformConfig) {
+        this._a.__makeNative(platformConfig);
+        _superPropGet(AnimatedModulo, "__makeNative", this, 3)([platformConfig]);
+      }
+    }, {
+      key: "__getValue",
+      value: function __getValue() {
+        return (this._a.__getValue() % this._modulus + this._modulus) % this._modulus;
+      }
+    }, {
+      key: "interpolate",
+      value: function interpolate(config) {
+        return new _AnimatedInterpolation.default(this, config);
+      }
+    }, {
+      key: "__attach",
+      value: function __attach() {
+        this._a.__addChild(this);
+        _superPropGet(AnimatedModulo, "__attach", this, 3)([]);
+      }
+    }, {
+      key: "__detach",
+      value: function __detach() {
+        this._a.__removeChild(this);
+        _superPropGet(AnimatedModulo, "__detach", this, 3)([]);
+      }
+    }, {
+      key: "__getNativeConfig",
+      value: function __getNativeConfig() {
+        return {
+          type: 'modulus',
+          input: this._a.__getNativeTag(),
+          modulus: this._modulus,
+          debugID: this.__getDebugID()
+        };
+      }
+    }]);
+  }(_AnimatedWithChildren2.default);
+},425,[1,11,12,18,20,21,23,410,400],"../../node_modules/react-native/Libraries/Animated/nodes/AnimatedModulo.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _AnimatedInterpolation = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./AnimatedInterpolation"));
+  var _AnimatedValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./AnimatedValue"));
+  var _AnimatedWithChildren2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./AnimatedWithChildren"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  var AnimatedMultiplication = exports.default = /*#__PURE__*/function (_AnimatedWithChildren) {
+    function AnimatedMultiplication(a, b, config) {
+      var _this;
+      (0, _classCallCheck2.default)(this, AnimatedMultiplication);
+      _this = _callSuper(this, AnimatedMultiplication, [config]);
+      _this._a = typeof a === 'number' ? new _AnimatedValue.default(a) : a;
+      _this._b = typeof b === 'number' ? new _AnimatedValue.default(b) : b;
+      return _this;
+    }
+    (0, _inherits2.default)(AnimatedMultiplication, _AnimatedWithChildren);
+    return (0, _createClass2.default)(AnimatedMultiplication, [{
+      key: "__makeNative",
+      value: function __makeNative(platformConfig) {
+        this._a.__makeNative(platformConfig);
+        this._b.__makeNative(platformConfig);
+        _superPropGet(AnimatedMultiplication, "__makeNative", this, 3)([platformConfig]);
+      }
+    }, {
+      key: "__getValue",
+      value: function __getValue() {
+        return this._a.__getValue() * this._b.__getValue();
+      }
+    }, {
+      key: "interpolate",
+      value: function interpolate(config) {
+        return new _AnimatedInterpolation.default(this, config);
+      }
+    }, {
+      key: "__attach",
+      value: function __attach() {
+        this._a.__addChild(this);
+        this._b.__addChild(this);
+        _superPropGet(AnimatedMultiplication, "__attach", this, 3)([]);
+      }
+    }, {
+      key: "__detach",
+      value: function __detach() {
+        this._a.__removeChild(this);
+        this._b.__removeChild(this);
+        _superPropGet(AnimatedMultiplication, "__detach", this, 3)([]);
+      }
+    }, {
+      key: "__getNativeConfig",
+      value: function __getNativeConfig() {
+        return {
+          type: 'multiplication',
+          input: [this._a.__getNativeTag(), this._b.__getNativeTag()],
+          debugID: this.__getDebugID()
+        };
+      }
+    }]);
+  }(_AnimatedWithChildren2.default);
+},426,[1,11,12,18,20,21,23,410,406,400],"../../node_modules/react-native/Libraries/Animated/nodes/AnimatedMultiplication.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _AnimatedInterpolation = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./AnimatedInterpolation"));
+  var _AnimatedValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./AnimatedValue"));
+  var _AnimatedWithChildren2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./AnimatedWithChildren"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  var AnimatedSubtraction = exports.default = /*#__PURE__*/function (_AnimatedWithChildren) {
+    function AnimatedSubtraction(a, b, config) {
+      var _this;
+      (0, _classCallCheck2.default)(this, AnimatedSubtraction);
+      _this = _callSuper(this, AnimatedSubtraction, [config]);
+      _this._a = typeof a === 'number' ? new _AnimatedValue.default(a) : a;
+      _this._b = typeof b === 'number' ? new _AnimatedValue.default(b) : b;
+      return _this;
+    }
+    (0, _inherits2.default)(AnimatedSubtraction, _AnimatedWithChildren);
+    return (0, _createClass2.default)(AnimatedSubtraction, [{
+      key: "__makeNative",
+      value: function __makeNative(platformConfig) {
+        this._a.__makeNative(platformConfig);
+        this._b.__makeNative(platformConfig);
+        _superPropGet(AnimatedSubtraction, "__makeNative", this, 3)([platformConfig]);
+      }
+    }, {
+      key: "__getValue",
+      value: function __getValue() {
+        return this._a.__getValue() - this._b.__getValue();
+      }
+    }, {
+      key: "interpolate",
+      value: function interpolate(config) {
+        return new _AnimatedInterpolation.default(this, config);
+      }
+    }, {
+      key: "__attach",
+      value: function __attach() {
+        this._a.__addChild(this);
+        this._b.__addChild(this);
+        _superPropGet(AnimatedSubtraction, "__attach", this, 3)([]);
+      }
+    }, {
+      key: "__detach",
+      value: function __detach() {
+        this._a.__removeChild(this);
+        this._b.__removeChild(this);
+        _superPropGet(AnimatedSubtraction, "__detach", this, 3)([]);
+      }
+    }, {
+      key: "__getNativeConfig",
+      value: function __getNativeConfig() {
+        return {
+          type: 'subtraction',
+          input: [this._a.__getNativeTag(), this._b.__getNativeTag()],
+          debugID: this.__getDebugID()
+        };
+      }
+    }]);
+  }(_AnimatedWithChildren2.default);
+},427,[1,11,12,18,20,21,23,410,406,400],"../../node_modules/react-native/Libraries/Animated/nodes/AnimatedSubtraction.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _NativeAnimatedHelper = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../../../src/private/animated/NativeAnimatedHelper"));
+  var _AnimatedNode2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./AnimatedNode"));
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  var AnimatedTracking = exports.default = /*#__PURE__*/function (_AnimatedNode) {
+    function AnimatedTracking(value, parent, animationClass, animationConfig, callback, config) {
+      var _this;
+      (0, _classCallCheck2.default)(this, AnimatedTracking);
+      _this = _callSuper(this, AnimatedTracking, [config]);
+      _this._value = value;
+      _this._parent = parent;
+      _this._animationClass = animationClass;
+      _this._animationConfig = animationConfig;
+      _this._useNativeDriver = _NativeAnimatedHelper.default.shouldUseNativeDriver(animationConfig);
+      _this._callback = callback;
+      _this.__attach();
+      return _this;
+    }
+    (0, _inherits2.default)(AnimatedTracking, _AnimatedNode);
+    return (0, _createClass2.default)(AnimatedTracking, [{
+      key: "__makeNative",
+      value: function __makeNative(platformConfig) {
+        this.__isNative = true;
+        this._parent.__makeNative(platformConfig);
+        _superPropGet(AnimatedTracking, "__makeNative", this, 3)([platformConfig]);
+        this._value.__makeNative(platformConfig);
+      }
+    }, {
+      key: "__getValue",
+      value: function __getValue() {
+        return this._parent.__getValue();
+      }
+    }, {
+      key: "__attach",
+      value: function __attach() {
+        this._parent.__addChild(this);
+        if (this._useNativeDriver) {
+          var platformConfig = this._animationConfig.platformConfig;
+          this.__makeNative(platformConfig);
+        }
+        _superPropGet(AnimatedTracking, "__attach", this, 3)([]);
+      }
+    }, {
+      key: "__detach",
+      value: function __detach() {
+        this._parent.__removeChild(this);
+        _superPropGet(AnimatedTracking, "__detach", this, 3)([]);
+      }
+    }, {
+      key: "update",
+      value: function update() {
+        this._value.animate(new this._animationClass(Object.assign({}, this._animationConfig, {
+          toValue: this._animationConfig.toValue.__getValue()
+        })), this._callback);
+      }
+    }, {
+      key: "__getNativeConfig",
+      value: function __getNativeConfig() {
+        var animation = new this._animationClass(Object.assign({}, this._animationConfig, {
+          toValue: undefined
+        }));
+        var animationConfig = animation.__getNativeAnimationConfig();
+        return {
+          type: 'tracking',
+          animationId: _NativeAnimatedHelper.default.generateNewAnimationId(),
+          animationConfig: animationConfig,
+          toValue: this._parent.__getNativeTag(),
+          value: this._value.__getNativeTag(),
+          debugID: this.__getDebugID()
+        };
+      }
+    }]);
+  }(_AnimatedNode2.default);
+},428,[1,11,12,18,20,21,23,391,398],"../../node_modules/react-native/Libraries/Animated/nodes/AnimatedTracking.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _NativeFrameRateLogger = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativeFrameRateLogger"));
+  var FrameRateLogger = {
+    setGlobalOptions: function setGlobalOptions(options) {
+      if (options.debug !== undefined) {
+        _$$_REQUIRE(_dependencyMap[2], "invariant")(_NativeFrameRateLogger.default, 'Trying to debug FrameRateLogger without the native module!');
+      }
+      _NativeFrameRateLogger.default == null || _NativeFrameRateLogger.default.setGlobalOptions({
+        debug: !!options.debug
+      });
+    },
+    setContext: function setContext(context) {
+      _NativeFrameRateLogger.default == null || _NativeFrameRateLogger.default.setContext(context);
+    },
+    beginScroll: function beginScroll() {
+      _NativeFrameRateLogger.default == null || _NativeFrameRateLogger.default.beginScroll();
+    },
+    endScroll: function endScroll() {
+      _NativeFrameRateLogger.default == null || _NativeFrameRateLogger.default.endScroll();
+    }
+  };
+  var _default = exports.default = FrameRateLogger;
+},429,[1,430,32],"../../node_modules/react-native/Libraries/Interaction/FrameRateLogger.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeFrameRateLogger = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativeFrameRateLogger"));
+  Object.keys(_NativeFrameRateLogger).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeFrameRateLogger[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeFrameRateLogger[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeFrameRateLogger.default;
+},430,[431],"../../node_modules/react-native/Libraries/Interaction/NativeFrameRateLogger.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.get('FrameRateLogger');
+},431,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeFrameRateLogger.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = splitLayoutProps;
+  function splitLayoutProps(props) {
+    var outer = null;
+    var inner = null;
+    if (props != null) {
+      outer = {};
+      inner = {};
+      for (var prop of Object.keys(props)) {
+        switch (prop) {
+          case 'margin':
+          case 'marginHorizontal':
+          case 'marginVertical':
+          case 'marginBottom':
+          case 'marginTop':
+          case 'marginLeft':
+          case 'marginRight':
+          case 'flex':
+          case 'flexGrow':
+          case 'flexShrink':
+          case 'flexBasis':
+          case 'alignSelf':
+          case 'height':
+          case 'minHeight':
+          case 'maxHeight':
+          case 'width':
+          case 'minWidth':
+          case 'maxWidth':
+          case 'position':
+          case 'left':
+          case 'right':
+          case 'bottom':
+          case 'top':
+          case 'transform':
+          case 'transformOrigin':
+          case 'rowGap':
+          case 'columnGap':
+          case 'gap':
+            outer[prop] = props[prop];
+            break;
+          default:
+            inner[prop] = props[prop];
+            break;
+        }
+      }
+    }
+    return {
+      outer: outer,
+      inner: inner
+    };
+  }
+},432,[],"../../node_modules/react-native/Libraries/StyleSheet/splitLayoutProps.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  function dismissKeyboard() {
+    _$$_REQUIRE(_dependencyMap[0], "../Components/TextInput/TextInputState").default.blurTextInput(_$$_REQUIRE(_dependencyMap[0], "../Components/TextInput/TextInputState").default.currentlyFocusedInput());
+  }
+  var _default = exports.default = dismissKeyboard;
+},433,[130],"../../node_modules/react-native/Libraries/Utilities/dismissKeyboard.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _NativeEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../EventEmitter/NativeEventEmitter"));
+  var _LayoutAnimation = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../../LayoutAnimation/LayoutAnimation"));
+  var _dismissKeyboard = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../../Utilities/dismissKeyboard"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../../Utilities/Platform"));
+  var _NativeKeyboardObserver = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./NativeKeyboardObserver"));
+  var KeyboardImpl = /*#__PURE__*/function () {
+    function KeyboardImpl() {
+      var _this = this;
+      (0, _classCallCheck2.default)(this, KeyboardImpl);
+      this._emitter = new _NativeEventEmitter.default(_Platform.default.OS !== 'ios' ? null : _NativeKeyboardObserver.default);
+      this.addListener('keyboardDidShow', function (ev) {
+        _this._currentlyShowing = ev;
+      });
+      this.addListener('keyboardDidHide', function (_ev) {
+        _this._currentlyShowing = null;
+      });
+    }
+    return (0, _createClass2.default)(KeyboardImpl, [{
+      key: "addListener",
+      value: function addListener(eventType, listener, context) {
+        return this._emitter.addListener(eventType, listener);
+      }
+    }, {
+      key: "removeAllListeners",
+      value: function removeAllListeners(eventType) {
+        this._emitter.removeAllListeners(eventType);
+      }
+    }, {
+      key: "dismiss",
+      value: function dismiss() {
+        (0, _dismissKeyboard.default)();
+      }
+    }, {
+      key: "isVisible",
+      value: function isVisible() {
+        return !!this._currentlyShowing;
+      }
+    }, {
+      key: "metrics",
+      value: function metrics() {
+        var _this$_currentlyShowi;
+        return (_this$_currentlyShowi = this._currentlyShowing) == null ? void 0 : _this$_currentlyShowi.endCoordinates;
+      }
+    }, {
+      key: "scheduleLayoutAnimation",
+      value: function scheduleLayoutAnimation(event) {
+        var duration = event.duration,
+          easing = event.easing;
+        if (duration != null && duration !== 0) {
+          _LayoutAnimation.default.configureNext({
+            duration: duration,
+            update: {
+              duration: duration,
+              type: easing != null && _LayoutAnimation.default.Types[easing] || 'keyboard'
+            }
+          });
+        }
+      }
+    }]);
+  }();
+  var Keyboard = new KeyboardImpl();
+  var _default = exports.default = Keyboard;
+},434,[1,11,12,221,435,433,68,436],"../../node_modules/react-native/Libraries/Components/Keyboard/Keyboard.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var ReactNativeFeatureFlags = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../src/private/featureflags/ReactNativeFeatureFlags"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../Utilities/Platform"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var isLayoutAnimationEnabled = ReactNativeFeatureFlags.isLayoutAnimationEnabled();
+  function setEnabled(value) {
+    isLayoutAnimationEnabled = isLayoutAnimationEnabled;
+  }
+  function configureNext(config, onAnimationDidEnd, onAnimationDidFail) {
+    var _config$duration;
+    if (_Platform.default.isDisableAnimations) {
+      return;
+    }
+    if (!isLayoutAnimationEnabled) {
+      return;
+    }
+    var animationCompletionHasRun = false;
+    var onAnimationComplete = function onAnimationComplete() {
+      if (animationCompletionHasRun) {
+        return;
+      }
+      animationCompletionHasRun = true;
+      clearTimeout(raceWithAnimationId);
+      onAnimationDidEnd == null || onAnimationDidEnd();
+    };
+    var raceWithAnimationId = setTimeout(onAnimationComplete, ((_config$duration = config.duration) != null ? _config$duration : 0) + 17);
+    var FabricUIManager = (0, _$$_REQUIRE(_dependencyMap[3], "../ReactNative/FabricUIManager").getFabricUIManager)();
+    if (FabricUIManager != null && FabricUIManager.configureNextLayoutAnimation) {
+      var _global;
+      (_global = global) == null || (_global = _global.nativeFabricUIManager) == null || _global.configureNextLayoutAnimation(config, onAnimationComplete, onAnimationDidFail != null ? onAnimationDidFail : function () {});
+      return;
+    }
+    if (_$$_REQUIRE(_dependencyMap[4], "../ReactNative/UIManager").default != null && _$$_REQUIRE(_dependencyMap[4], "../ReactNative/UIManager").default.configureNextLayoutAnimation) {
+      _$$_REQUIRE(_dependencyMap[4], "../ReactNative/UIManager").default.configureNextLayoutAnimation(config, onAnimationComplete != null ? onAnimationComplete : function () {}, onAnimationDidFail != null ? onAnimationDidFail : function () {});
+    }
+  }
+  function create(duration, type, property) {
+    return {
+      duration: duration,
+      create: {
+        type: type,
+        property: property
+      },
+      update: {
+        type: type
+      },
+      delete: {
+        type: type,
+        property: property
+      }
+    };
+  }
+  var Presets = {
+    easeInEaseOut: create(300, 'easeInEaseOut', 'opacity'),
+    linear: create(500, 'linear', 'opacity'),
+    spring: {
+      duration: 700,
+      create: {
+        type: 'linear',
+        property: 'opacity'
+      },
+      update: {
+        type: 'spring',
+        springDamping: 0.4
+      },
+      delete: {
+        type: 'linear',
+        property: 'opacity'
+      }
+    }
+  };
+  var LayoutAnimation = {
+    configureNext: configureNext,
+    create: create,
+    Types: Object.freeze({
+      spring: 'spring',
+      linear: 'linear',
+      easeInEaseOut: 'easeInEaseOut',
+      easeIn: 'easeIn',
+      easeOut: 'easeOut',
+      keyboard: 'keyboard'
+    }),
+    Properties: Object.freeze({
+      opacity: 'opacity',
+      scaleX: 'scaleX',
+      scaleY: 'scaleY',
+      scaleXY: 'scaleXY'
+    }),
+    checkConfig: function checkConfig() {
+      console.error('LayoutAnimation.checkConfig(...) has been disabled.');
+    },
+    Presets: Presets,
+    easeInEaseOut: configureNext.bind(null, Presets.easeInEaseOut),
+    linear: configureNext.bind(null, Presets.linear),
+    spring: configureNext.bind(null, Presets.spring),
+    setEnabled: setEnabled
+  };
+  var _default = exports.default = LayoutAnimation;
+},435,[1,52,68,82,79],"../../node_modules/react-native/Libraries/LayoutAnimation/LayoutAnimation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeKeyboardObserver = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../src/private/specs_DEPRECATED/modules/NativeKeyboardObserver"));
+  Object.keys(_NativeKeyboardObserver).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeKeyboardObserver[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeKeyboardObserver[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeKeyboardObserver.default;
+},436,[437],"../../node_modules/react-native/Libraries/Components/Keyboard/NativeKeyboardObserver.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.get('KeyboardObserver');
+},437,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeKeyboardObserver.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Utilities/Platform"));
+  function processDecelerationRate(decelerationRate) {
+    if (decelerationRate === 'normal') {
+      return _Platform.default.select({
+        ios: 0.998,
+        android: 0.985
+      });
+    } else if (decelerationRate === 'fast') {
+      return _Platform.default.select({
+        ios: 0.99,
+        android: 0.9
+      });
+    }
+    return decelerationRate;
+  }
+  var _default = exports.default = processDecelerationRate;
+},438,[1,68],"../../node_modules/react-native/Libraries/Components/ScrollView/processDecelerationRate.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _codegenNativeCommands = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Utilities/codegenNativeCommands"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[2], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = (0, _codegenNativeCommands.default)({
+    supportedCommands: ['flashScrollIndicators', 'scrollTo', 'scrollToEnd', 'zoomToRect']
+  });
+},439,[1,105,73],"../../node_modules/react-native/Libraries/Components/ScrollView/ScrollViewCommands.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = exports.VERTICAL = exports.HORIZONTAL = void 0;
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var ScrollViewContext = React.createContext(null);
+  if (__DEV__) {
+    ScrollViewContext.displayName = 'ScrollViewContext';
+  }
+  var _default = exports.default = ScrollViewContext;
+  var HORIZONTAL = exports.HORIZONTAL = Object.freeze({
+    horizontal: true
+  });
+  var VERTICAL = exports.VERTICAL = Object.freeze({
+    horizontal: false
+  });
+},440,[73],"../../node_modules/react-native/Libraries/Components/ScrollView/ScrollViewContext.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _Animated = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../Animated/Animated"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/StyleSheet"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../../Utilities/Platform"));
+  var _useMergeRefs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../../Utilities/useMergeRefs"));
+  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[6], "react"));
+  var React = _react;
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[7], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Components/ScrollView/ScrollViewStickyHeader.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var ScrollViewStickyHeaderWithForwardedRef = React.forwardRef(function ScrollViewStickyHeader(props, forwardedRef) {
+    var inverted = props.inverted,
+      scrollViewHeight = props.scrollViewHeight,
+      hiddenOnScroll = props.hiddenOnScroll,
+      scrollAnimatedValue = props.scrollAnimatedValue,
+      _nextHeaderLayoutY = props.nextHeaderLayoutY;
+    var _useState = (0, _react.useState)(false),
+      _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+      measured = _useState2[0],
+      setMeasured = _useState2[1];
+    var _useState3 = (0, _react.useState)(0),
+      _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
+      layoutY = _useState4[0],
+      setLayoutY = _useState4[1];
+    var _useState5 = (0, _react.useState)(0),
+      _useState6 = (0, _slicedToArray2.default)(_useState5, 2),
+      layoutHeight = _useState6[0],
+      setLayoutHeight = _useState6[1];
+    var _useState7 = (0, _react.useState)(null),
+      _useState8 = (0, _slicedToArray2.default)(_useState7, 2),
+      translateY = _useState8[0],
+      setTranslateY = _useState8[1];
+    var _useState9 = (0, _react.useState)(_nextHeaderLayoutY),
+      _useState0 = (0, _slicedToArray2.default)(_useState9, 2),
+      nextHeaderLayoutY = _useState0[0],
+      setNextHeaderLayoutY = _useState0[1];
+    var _useState1 = (0, _react.useState)(false),
+      _useState10 = (0, _slicedToArray2.default)(_useState1, 2),
+      isFabric = _useState10[0],
+      setIsFabric = _useState10[1];
+    var callbackRef = (0, _react.useCallback)(function (ref) {
+      if (ref == null) {
+        return;
+      }
+      ref.setNextHeaderY = setNextHeaderLayoutY;
+      setIsFabric((0, _$$_REQUIRE(_dependencyMap[8], "../../ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstanceUtils").isPublicInstance)(ref));
+    }, []);
+    var ref = (0, _useMergeRefs.default)(callbackRef, forwardedRef);
+    var offset = (0, _react.useMemo)(function () {
+      return hiddenOnScroll === true ? _Animated.default.diffClamp(scrollAnimatedValue.interpolate({
+        extrapolateLeft: 'clamp',
+        inputRange: [layoutY, layoutY + 1],
+        outputRange: [0, 1]
+      }).interpolate({
+        inputRange: [0, 1],
+        outputRange: [0, -1]
+      }), -layoutHeight, 0) : null;
+    }, [scrollAnimatedValue, layoutHeight, layoutY, hiddenOnScroll]);
+    var _useState11 = (0, _react.useState)(function () {
+        var inputRange = [-1, 0];
+        var outputRange = [0, 0];
+        var initialTranslateY = scrollAnimatedValue.interpolate({
+          inputRange: inputRange,
+          outputRange: outputRange
+        });
+        if (offset != null) {
+          return _Animated.default.add(initialTranslateY, offset);
+        }
+        return initialTranslateY;
+      }),
+      _useState12 = (0, _slicedToArray2.default)(_useState11, 2),
+      animatedTranslateY = _useState12[0],
+      setAnimatedTranslateY = _useState12[1];
+    var haveReceivedInitialZeroTranslateY = (0, _react.useRef)(true);
+    var translateYDebounceTimer = (0, _react.useRef)(null);
+    (0, _react.useEffect)(function () {
+      if (translateY !== 0 && translateY != null) {
+        haveReceivedInitialZeroTranslateY.current = false;
+      }
+    }, [translateY]);
+    var animatedValueListener = (0, _react.useCallback)(function (_ref) {
+      var value = _ref.value;
+      var debounceTimeout = _Platform.default.OS === 'android' ? 15 : 64;
+      if (value === 0 && !haveReceivedInitialZeroTranslateY.current) {
+        haveReceivedInitialZeroTranslateY.current = true;
+        return;
+      }
+      if (translateYDebounceTimer.current != null) {
+        clearTimeout(translateYDebounceTimer.current);
+      }
+      translateYDebounceTimer.current = setTimeout(function () {
+        return setTranslateY(value);
+      }, debounceTimeout);
+    }, []);
+    (0, _react.useEffect)(function () {
+      var inputRange = [-1, 0];
+      var outputRange = [0, 0];
+      if (measured) {
+        if (inverted === true) {
+          if (scrollViewHeight != null) {
+            var stickStartPoint = layoutY + layoutHeight - scrollViewHeight;
+            if (stickStartPoint > 0) {
+              inputRange.push(stickStartPoint);
+              outputRange.push(0);
+              inputRange.push(stickStartPoint + 1);
+              outputRange.push(1);
+              var collisionPoint = (nextHeaderLayoutY || 0) - layoutHeight - scrollViewHeight;
+              if (collisionPoint > stickStartPoint) {
+                inputRange.push(collisionPoint, collisionPoint + 1);
+                outputRange.push(collisionPoint - stickStartPoint, collisionPoint - stickStartPoint);
+              }
+            }
+          }
+        } else {
+          inputRange.push(layoutY);
+          outputRange.push(0);
+          var _collisionPoint = (nextHeaderLayoutY || 0) - layoutHeight;
+          if (_collisionPoint >= layoutY) {
+            inputRange.push(_collisionPoint, _collisionPoint + 1);
+            outputRange.push(_collisionPoint - layoutY, _collisionPoint - layoutY);
+          } else {
+            inputRange.push(layoutY + 1);
+            outputRange.push(1);
+          }
+        }
+      }
+      var newAnimatedTranslateY = scrollAnimatedValue.interpolate({
+        inputRange: inputRange,
+        outputRange: outputRange
+      });
+      if (offset != null) {
+        newAnimatedTranslateY = _Animated.default.add(newAnimatedTranslateY, offset);
+      }
+      var animatedListenerId;
+      if (isFabric) {
+        animatedListenerId = newAnimatedTranslateY.addListener(animatedValueListener);
+      }
+      setAnimatedTranslateY(newAnimatedTranslateY);
+      return function () {
+        if (animatedListenerId) {
+          newAnimatedTranslateY.removeListener(animatedListenerId);
+        }
+        if (translateYDebounceTimer.current != null) {
+          clearTimeout(translateYDebounceTimer.current);
+        }
+      };
+    }, [nextHeaderLayoutY, measured, layoutHeight, layoutY, scrollViewHeight, scrollAnimatedValue, inverted, offset, animatedValueListener, isFabric]);
+    var _onLayout = function _onLayout(event) {
+      setLayoutY(event.nativeEvent.layout.y);
+      setLayoutHeight(event.nativeEvent.layout.height);
+      setMeasured(true);
+      props.onLayout(event);
+      var child = React.Children.only(props.children);
+      if (child.props.onLayout) {
+        child.props.onLayout(event);
+      }
+    };
+    var child = React.Children.only(props.children);
+    var passthroughAnimatedPropExplicitValues = isFabric && translateY != null ? {
+      style: {
+        transform: [{
+          translateY: translateY
+        }]
+      }
+    } : null;
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_Animated.default.View, {
+      collapsable: false,
+      nativeID: props.nativeID,
+      onLayout: _onLayout,
+      ref: ref,
+      style: [child.props.style, styles.header, {
+        transform: [{
+          translateY: animatedTranslateY
+        }]
+      }],
+      passthroughAnimatedPropExplicitValues: passthroughAnimatedPropExplicitValues,
+      children: React.cloneElement(child, {
+        style: styles.fill,
+        onLayout: undefined
+      })
+    });
+  });
+  var styles = _StyleSheet.default.create({
+    header: {
+      zIndex: 10
+    },
+    fill: {
+      flex: 1
+    }
+  });
+  var _default = exports.default = ScrollViewStickyHeaderWithForwardedRef;
+},441,[1,34,442,6,68,364,73,171,421],"../../node_modules/react-native/Libraries/Components/ScrollView/ScrollViewStickyHeader.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _default = exports.default = _$$_REQUIRE(_dependencyMap[0], "./AnimatedExports").default;
+},442,[443],"../../node_modules/react-native/Libraries/Animated/Animated.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../Utilities/Platform"));
+  var _AnimatedImplementation = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./AnimatedImplementation"));
+  var _AnimatedMock = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./AnimatedMock"));
+  var Animated = _Platform.default.isDisableAnimations ? _AnimatedMock.default : _AnimatedImplementation.default;
+  var _default = exports.default = Object.assign({
+    get FlatList() {
+      return _$$_REQUIRE(_dependencyMap[4], "./components/AnimatedFlatList").default;
+    },
+    get Image() {
+      return _$$_REQUIRE(_dependencyMap[5], "./components/AnimatedImage").default;
+    },
+    get ScrollView() {
+      return _$$_REQUIRE(_dependencyMap[6], "./components/AnimatedScrollView").default;
+    },
+    get SectionList() {
+      return _$$_REQUIRE(_dependencyMap[7], "./components/AnimatedSectionList").default;
+    },
+    get Text() {
+      return _$$_REQUIRE(_dependencyMap[8], "./components/AnimatedText").default;
+    },
+    get View() {
+      return _$$_REQUIRE(_dependencyMap[9], "./components/AnimatedView").default;
+    }
+  }, Animated);
+},443,[1,68,388,444,445,463,464,471,473,474],"../../node_modules/react-native/Libraries/Animated/AnimatedExports.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _AnimatedImplementation = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./AnimatedImplementation"));
+  var _createAnimatedComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./createAnimatedComponent"));
+  var _AnimatedColor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./nodes/AnimatedColor"));
+  var _AnimatedInterpolation = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./nodes/AnimatedInterpolation"));
+  var _AnimatedNode = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./nodes/AnimatedNode"));
+  var _AnimatedValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./nodes/AnimatedValue"));
+  var _AnimatedValueXY = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./nodes/AnimatedValueXY"));
+  var inAnimationCallback = false;
+  function mockAnimationStart(start) {
+    return function (callback) {
+      var guardedCallback = callback == null ? callback : function () {
+        if (inAnimationCallback) {
+          console.warn('Ignoring recursive animation callback when running mock animations');
+          return;
+        }
+        inAnimationCallback = true;
+        try {
+          callback.apply(void 0, arguments);
+        } finally {
+          inAnimationCallback = false;
+        }
+      };
+      start(guardedCallback);
+    };
+  }
+  var emptyAnimation = {
+    start: function start() {},
+    stop: function stop() {},
+    reset: function reset() {},
+    _startNativeLoop: function _startNativeLoop() {},
+    _isUsingNativeDriver: function _isUsingNativeDriver() {
+      return false;
+    }
+  };
+  var mockCompositeAnimation = function mockCompositeAnimation(animations) {
+    return Object.assign({}, emptyAnimation, {
+      start: mockAnimationStart(function (callback) {
+        animations.forEach(function (animation) {
+          return animation.start();
+        });
+        callback == null || callback({
+          finished: true
+        });
+      })
+    });
+  };
+  var spring = function spring(value, config) {
+    var anyValue = value;
+    return Object.assign({}, emptyAnimation, {
+      start: mockAnimationStart(function (callback) {
+        anyValue.setValue(config.toValue);
+        callback == null || callback({
+          finished: true
+        });
+      })
+    });
+  };
+  var timing = function timing(value, config) {
+    var anyValue = value;
+    return Object.assign({}, emptyAnimation, {
+      start: mockAnimationStart(function (callback) {
+        anyValue.setValue(config.toValue);
+        callback == null || callback({
+          finished: true
+        });
+      })
+    });
+  };
+  var decay = function decay(value, config) {
+    return emptyAnimation;
+  };
+  var sequence = function sequence(animations) {
+    return mockCompositeAnimation(animations);
+  };
+  var parallel = function parallel(animations, config) {
+    return mockCompositeAnimation(animations);
+  };
+  var delay = function delay(time) {
+    return emptyAnimation;
+  };
+  var stagger = function stagger(time, animations) {
+    return mockCompositeAnimation(animations);
+  };
+  var loop = function loop(animation) {
+    var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      _ref$iterations = _ref.iterations,
+      iterations = _ref$iterations === void 0 ? -1 : _ref$iterations;
+    return emptyAnimation;
+  };
+  var _default = exports.default = {
+    Value: _AnimatedValue.default,
+    ValueXY: _AnimatedValueXY.default,
+    Color: _AnimatedColor.default,
+    Interpolation: _AnimatedInterpolation.default,
+    Node: _AnimatedNode.default,
+    decay: decay,
+    timing: timing,
+    spring: spring,
+    add: _AnimatedImplementation.default.add,
+    subtract: _AnimatedImplementation.default.subtract,
+    divide: _AnimatedImplementation.default.divide,
+    multiply: _AnimatedImplementation.default.multiply,
+    modulo: _AnimatedImplementation.default.modulo,
+    diffClamp: _AnimatedImplementation.default.diffClamp,
+    delay: delay,
+    sequence: sequence,
+    parallel: parallel,
+    stagger: stagger,
+    loop: loop,
+    event: _AnimatedImplementation.default.event,
+    createAnimatedComponent: _createAnimatedComponent.default,
+    attachNativeEvent: _$$_REQUIRE(_dependencyMap[8], "./AnimatedEvent").attachNativeEvent,
+    forkEvent: _AnimatedImplementation.default.forkEvent,
+    unforkEvent: _AnimatedImplementation.default.unforkEvent,
+    Event: _$$_REQUIRE(_dependencyMap[8], "./AnimatedEvent").AnimatedEvent
+  };
+},444,[1,388,418,415,410,398,406,413,405],"../../node_modules/react-native/Libraries/Animated/AnimatedMock.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _FlatList = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Lists/FlatList"));
+  var _createAnimatedComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../createAnimatedComponent"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[3], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = (0, _createAnimatedComponent.default)(_FlatList.default);
+},445,[1,446,418,73],"../../node_modules/react-native/Libraries/Animated/components/AnimatedFlatList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var ReactNativeFeatureFlags = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "../../src/private/featureflags/ReactNativeFeatureFlags"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../Components/View/View"));
+  var _virtualizedLists = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "@react-native/virtualized-lists"));
+  var _memoizeOne = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "memoize-one"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[11], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[12], "react/jsx-runtime");
+  var _excluded = ["numColumns", "columnWrapperStyle", "removeClippedSubviews", "strictMode"];
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Lists/FlatList.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var VirtualizedList = _virtualizedLists.default.VirtualizedList;
+  var defaultKeyExtractor = _virtualizedLists.default.keyExtractor;
+  function removeClippedSubviewsOrDefault(removeClippedSubviews) {
+    if (ReactNativeFeatureFlags.shouldUseRemoveClippedSubviewsAsDefaultOnIOS()) {
+      return removeClippedSubviews != null ? removeClippedSubviews : true;
+    } else {
+      return removeClippedSubviews != null ? removeClippedSubviews : "ios" === 'android';
+    }
+  }
+  function numColumnsOrDefault(numColumns) {
+    return numColumns != null ? numColumns : 1;
+  }
+  function isArrayLike(data) {
+    return typeof Object(data).length === 'number';
+  }
+  var FlatList = /*#__PURE__*/function (_React$PureComponent) {
+    function FlatList(_props) {
+      var _this;
+      (0, _classCallCheck2.default)(this, FlatList);
+      _this = _callSuper(this, FlatList, [_props]);
+      _this._virtualizedListPairs = [];
+      _this._captureRef = function (ref) {
+        _this._listRef = ref;
+      };
+      _this._getItem = function (data, index) {
+        var numColumns = numColumnsOrDefault(_this.props.numColumns);
+        if (numColumns > 1) {
+          var ret = [];
+          for (var kk = 0; kk < numColumns; kk++) {
+            var itemIndex = index * numColumns + kk;
+            if (itemIndex < data.length) {
+              var _item = data[itemIndex];
+              ret.push(_item);
+            }
+          }
+          return ret;
+        } else {
+          return data[index];
+        }
+      };
+      _this._getItemCount = function (data) {
+        if (data != null && isArrayLike(data)) {
+          var numColumns = numColumnsOrDefault(_this.props.numColumns);
+          return numColumns > 1 ? Math.ceil(data.length / numColumns) : data.length;
+        } else {
+          return 0;
+        }
+      };
+      _this._keyExtractor = function (items, index) {
+        var _this$props$keyExtrac;
+        var numColumns = numColumnsOrDefault(_this.props.numColumns);
+        var keyExtractor = (_this$props$keyExtrac = _this.props.keyExtractor) != null ? _this$props$keyExtrac : defaultKeyExtractor;
+        if (numColumns > 1) {
+          _$$_REQUIRE(_dependencyMap[13], "invariant")(Array.isArray(items), 'FlatList: Encountered internal consistency error, expected each item to consist of an ' + 'array with 1-%s columns; instead, received a single item.', numColumns);
+          return items.map(function (item, kk) {
+            return keyExtractor(item, index * numColumns + kk);
+          }).join(':');
+        }
+        return keyExtractor(items, index);
+      };
+      _this._renderer = function (ListItemComponent, renderItem, columnWrapperStyle, numColumns, extraData) {
+        var cols = numColumnsOrDefault(numColumns);
+        var render = function render(props) {
+          if (ListItemComponent) {
+            return /*#__PURE__*/(0, _jsxRuntime.jsx)(ListItemComponent, Object.assign({}, props));
+          } else if (renderItem) {
+            return renderItem(props);
+          } else {
+            return null;
+          }
+        };
+        var renderProp = function renderProp(info) {
+          if (cols > 1) {
+            var _item2 = info.item,
+              _index = info.index;
+            _$$_REQUIRE(_dependencyMap[13], "invariant")(Array.isArray(_item2), 'Expected array of items with numColumns > 1');
+            return /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+              style: _$$_REQUIRE(_dependencyMap[14], "../StyleSheet/StyleSheet").default.compose(styles.row, columnWrapperStyle),
+              children: _item2.map(function (it, kk) {
+                var element = render({
+                  item: it,
+                  index: _index * cols + kk,
+                  separators: info.separators
+                });
+                return element != null ? /*#__PURE__*/(0, _jsxRuntime.jsx)(React.Fragment, {
+                  children: element
+                }, kk) : null;
+              })
+            });
+          } else {
+            return render(info);
+          }
+        };
+        return ListItemComponent ? {
+          ListItemComponent: renderProp
+        } : {
+          renderItem: renderProp
+        };
+      };
+      _this._memoizedRenderer = (0, _memoizeOne.default)(_this._renderer);
+      _this._checkProps(_this.props);
+      if (_this.props.viewabilityConfigCallbackPairs) {
+        _this._virtualizedListPairs = _this.props.viewabilityConfigCallbackPairs.map(function (pair) {
+          return {
+            viewabilityConfig: pair.viewabilityConfig,
+            onViewableItemsChanged: _this._createOnViewableItemsChanged(pair.onViewableItemsChanged)
+          };
+        });
+      } else if (_this.props.onViewableItemsChanged) {
+        _this._virtualizedListPairs.push({
+          viewabilityConfig: _this.props.viewabilityConfig,
+          onViewableItemsChanged: _this._createOnViewableItemsChanged(function () {
+            var _this$props;
+            _$$_REQUIRE(_dependencyMap[13], "invariant")(_this.props.onViewableItemsChanged, 'Changing the nullability of onViewableItemsChanged is not supported. ' + 'Once a function or null is supplied that cannot be changed.');
+            return (_this$props = _this.props).onViewableItemsChanged.apply(_this$props, arguments);
+          })
+        });
+      }
+      return _this;
+    }
+    (0, _inherits2.default)(FlatList, _React$PureComponent);
+    return (0, _createClass2.default)(FlatList, [{
+      key: "scrollToEnd",
+      value: function scrollToEnd(params) {
+        if (this._listRef) {
+          this._listRef.scrollToEnd(params);
+        }
+      }
+    }, {
+      key: "scrollToIndex",
+      value: function scrollToIndex(params) {
+        if (this._listRef) {
+          this._listRef.scrollToIndex(params);
+        }
+      }
+    }, {
+      key: "scrollToItem",
+      value: function scrollToItem(params) {
+        if (this._listRef) {
+          this._listRef.scrollToItem(params);
+        }
+      }
+    }, {
+      key: "scrollToOffset",
+      value: function scrollToOffset(params) {
+        if (this._listRef) {
+          this._listRef.scrollToOffset(params);
+        }
+      }
+    }, {
+      key: "recordInteraction",
+      value: function recordInteraction() {
+        if (this._listRef) {
+          this._listRef.recordInteraction();
+        }
+      }
+    }, {
+      key: "flashScrollIndicators",
+      value: function flashScrollIndicators() {
+        if (this._listRef) {
+          this._listRef.flashScrollIndicators();
+        }
+      }
+    }, {
+      key: "getScrollResponder",
+      value: function getScrollResponder() {
+        if (this._listRef) {
+          return this._listRef.getScrollResponder();
+        }
+      }
+    }, {
+      key: "getNativeScrollRef",
+      value: function getNativeScrollRef() {
+        if (this._listRef) {
+          return this._listRef.getScrollRef();
+        }
+      }
+    }, {
+      key: "getScrollableNode",
+      value: function getScrollableNode() {
+        if (this._listRef) {
+          return this._listRef.getScrollableNode();
+        }
+      }
+    }, {
+      key: "setNativeProps",
+      value: function setNativeProps(props) {
+        if (this._listRef) {
+          this._listRef.setNativeProps(props);
+        }
+      }
+    }, {
+      key: "componentDidUpdate",
+      value: function componentDidUpdate(prevProps) {
+        _$$_REQUIRE(_dependencyMap[13], "invariant")(prevProps.numColumns === this.props.numColumns, 'Changing numColumns on the fly is not supported. Change the key prop on FlatList when ' + 'changing the number of columns to force a fresh render of the component.');
+        _$$_REQUIRE(_dependencyMap[13], "invariant")(prevProps.onViewableItemsChanged == null === (this.props.onViewableItemsChanged == null), 'Changing onViewableItemsChanged nullability on the fly is not supported');
+        _$$_REQUIRE(_dependencyMap[13], "invariant")(!_$$_REQUIRE(_dependencyMap[15], "../Utilities/differ/deepDiffer").default(prevProps.viewabilityConfig, this.props.viewabilityConfig), 'Changing viewabilityConfig on the fly is not supported');
+        _$$_REQUIRE(_dependencyMap[13], "invariant")(prevProps.viewabilityConfigCallbackPairs === this.props.viewabilityConfigCallbackPairs, 'Changing viewabilityConfigCallbackPairs on the fly is not supported');
+        this._checkProps(this.props);
+      }
+    }, {
+      key: "_checkProps",
+      value: function _checkProps(props) {
+        var getItem = props.getItem,
+          getItemCount = props.getItemCount,
+          horizontal = props.horizontal,
+          columnWrapperStyle = props.columnWrapperStyle,
+          onViewableItemsChanged = props.onViewableItemsChanged,
+          viewabilityConfigCallbackPairs = props.viewabilityConfigCallbackPairs;
+        var numColumns = numColumnsOrDefault(this.props.numColumns);
+        _$$_REQUIRE(_dependencyMap[13], "invariant")(!getItem && !getItemCount, 'FlatList does not support custom data formats.');
+        if (numColumns > 1) {
+          _$$_REQUIRE(_dependencyMap[13], "invariant")(!horizontal, 'numColumns does not support horizontal.');
+        } else {
+          _$$_REQUIRE(_dependencyMap[13], "invariant")(!columnWrapperStyle, 'columnWrapperStyle not supported for single column lists');
+        }
+        _$$_REQUIRE(_dependencyMap[13], "invariant")(!(onViewableItemsChanged && viewabilityConfigCallbackPairs), 'FlatList does not support setting both onViewableItemsChanged and ' + 'viewabilityConfigCallbackPairs.');
+      }
+    }, {
+      key: "_pushMultiColumnViewable",
+      value: function _pushMultiColumnViewable(arr, v) {
+        var _this$props$keyExtrac2;
+        var numColumns = numColumnsOrDefault(this.props.numColumns);
+        var keyExtractor = (_this$props$keyExtrac2 = this.props.keyExtractor) != null ? _this$props$keyExtrac2 : defaultKeyExtractor;
+        v.item.forEach(function (item, ii) {
+          _$$_REQUIRE(_dependencyMap[13], "invariant")(v.index != null, 'Missing index!');
+          var index = v.index * numColumns + ii;
+          arr.push(Object.assign({}, v, {
+            item: item,
+            key: keyExtractor(item, index),
+            index: index
+          }));
+        });
+      }
+    }, {
+      key: "_createOnViewableItemsChanged",
+      value: function _createOnViewableItemsChanged(onViewableItemsChanged) {
+        var _this2 = this;
+        return function (info) {
+          var numColumns = numColumnsOrDefault(_this2.props.numColumns);
+          if (onViewableItemsChanged) {
+            if (numColumns > 1) {
+              var changed = [];
+              var viewableItems = [];
+              info.viewableItems.forEach(function (v) {
+                return _this2._pushMultiColumnViewable(viewableItems, v);
+              });
+              info.changed.forEach(function (v) {
+                return _this2._pushMultiColumnViewable(changed, v);
+              });
+              onViewableItemsChanged({
+                viewableItems: viewableItems,
+                changed: changed
+              });
+            } else {
+              onViewableItemsChanged(info);
+            }
+          }
+        };
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props2 = this.props,
+          numColumns = _this$props2.numColumns,
+          columnWrapperStyle = _this$props2.columnWrapperStyle,
+          _removeClippedSubviews = _this$props2.removeClippedSubviews,
+          _this$props2$strictMo = _this$props2.strictMode,
+          strictMode = _this$props2$strictMo === void 0 ? false : _this$props2$strictMo,
+          restProps = (0, _objectWithoutProperties2.default)(_this$props2, _excluded);
+        var renderer = strictMode ? this._memoizedRenderer : this._renderer;
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(VirtualizedList, Object.assign({}, restProps, {
+          getItem: this._getItem,
+          getItemCount: this._getItemCount,
+          keyExtractor: this._keyExtractor,
+          ref: this._captureRef,
+          viewabilityConfigCallbackPairs: this._virtualizedListPairs,
+          removeClippedSubviews: removeClippedSubviewsOrDefault(_removeClippedSubviews)
+        }, renderer(this.props.ListItemComponent, this.props.renderItem, columnWrapperStyle, numColumns, this.props.extraData)));
+      }
+    }]);
+  }(React.PureComponent);
+  var styles = _$$_REQUIRE(_dependencyMap[14], "../StyleSheet/StyleSheet").default.create({
+    row: {
+      flexDirection: 'row'
+    }
+  });
+  var _default = exports.default = FlatList;
+},446,[1,4,11,12,18,20,23,52,71,447,462,73,171,32,6,136],"../../node_modules/react-native/Libraries/Lists/FlatList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _default = exports.default = {
+    keyExtractor: _$$_REQUIRE(_dependencyMap[0], "./Lists/VirtualizeUtils").keyExtractor,
+    get VirtualizedList() {
+      return _$$_REQUIRE(_dependencyMap[1], "./Lists/VirtualizedList").default;
+    },
+    get VirtualizedSectionList() {
+      return _$$_REQUIRE(_dependencyMap[2], "./Lists/VirtualizedSectionList").default;
+    },
+    get VirtualizedListContextResetter() {
+      var VirtualizedListContext = _$$_REQUIRE(_dependencyMap[3], "./Lists/VirtualizedListContext");
+      return VirtualizedListContext.VirtualizedListContextResetter;
+    },
+    get ViewabilityHelper() {
+      return _$$_REQUIRE(_dependencyMap[4], "./Lists/ViewabilityHelper").default;
+    },
+    get FillRateHelper() {
+      return _$$_REQUIRE(_dependencyMap[5], "./Lists/FillRateHelper").default;
+    }
+  };
+},447,[448,449,461,458,456,453],"../../node_modules/@react-native/virtualized-lists/index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.computeWindowedRenderLimits = computeWindowedRenderLimits;
+  exports.elementsThatOverlapOffsets = elementsThatOverlapOffsets;
+  exports.keyExtractor = keyExtractor;
+  exports.newRangeCount = newRangeCount;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var ReactNativeFeatureFlags = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[2], "react-native/src/private/featureflags/ReactNativeFeatureFlags"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function elementsThatOverlapOffsets(offsets, props, listMetrics) {
+    var zoomScale = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
+    var itemCount = props.getItemCount(props.data);
+    var result = [];
+    for (var offsetIndex = 0; offsetIndex < offsets.length; offsetIndex++) {
+      var currentOffset = offsets[offsetIndex];
+      var left = 0;
+      var right = itemCount - 1;
+      while (left <= right) {
+        var mid = left + Math.floor((right - left) / 2);
+        var frame = listMetrics.getCellMetricsApprox(mid, props);
+        var scaledOffsetStart = frame.offset * zoomScale;
+        var scaledOffsetEnd = (frame.offset + frame.length) * zoomScale;
+        if (mid === 0 && currentOffset < scaledOffsetStart || mid !== 0 && currentOffset <= scaledOffsetStart) {
+          right = mid - 1;
+        } else if (currentOffset > scaledOffsetEnd) {
+          left = mid + 1;
+        } else {
+          result[offsetIndex] = mid;
+          break;
+        }
+      }
+    }
+    return result;
+  }
+  function newRangeCount(prev, next) {
+    return next.last - next.first + 1 - Math.max(0, 1 + Math.min(next.last, prev.last) - Math.max(next.first, prev.first));
+  }
+  function computeWindowedRenderLimits(props, maxToRenderPerBatch, windowSize, prev, listMetrics, scrollMetrics) {
+    var itemCount = props.getItemCount(props.data);
+    if (itemCount === 0) {
+      return {
+        first: 0,
+        last: -1
+      };
+    }
+    var offset = scrollMetrics.offset,
+      velocity = scrollMetrics.velocity,
+      visibleLength = scrollMetrics.visibleLength,
+      _scrollMetrics$zoomSc = scrollMetrics.zoomScale,
+      zoomScale = _scrollMetrics$zoomSc === void 0 ? 1 : _scrollMetrics$zoomSc;
+    var visibleBegin = Math.max(0, offset);
+    var visibleEnd = visibleBegin + visibleLength;
+    var overscanLength = (windowSize - 1) * visibleLength;
+    var leadFactor = 0.5;
+    var fillPreference = velocity > 1 ? 'after' : velocity < -1 ? 'before' : 'none';
+    var overscanBegin = Math.max(0, visibleBegin - (1 - leadFactor) * overscanLength);
+    var overscanEnd = Math.max(0, visibleEnd + leadFactor * overscanLength);
+    var lastItemOffset = listMetrics.getCellMetricsApprox(itemCount - 1, props).offset * zoomScale;
+    if (lastItemOffset < overscanBegin) {
+      return {
+        first: Math.max(0, itemCount - 1 - maxToRenderPerBatch),
+        last: itemCount - 1
+      };
+    }
+    var _elementsThatOverlapO = elementsThatOverlapOffsets([overscanBegin, visibleBegin, visibleEnd, overscanEnd], props, listMetrics, zoomScale),
+      _elementsThatOverlapO2 = (0, _slicedToArray2.default)(_elementsThatOverlapO, 4),
+      overscanFirst = _elementsThatOverlapO2[0],
+      first = _elementsThatOverlapO2[1],
+      last = _elementsThatOverlapO2[2],
+      overscanLast = _elementsThatOverlapO2[3];
+    overscanFirst = overscanFirst == null ? 0 : overscanFirst;
+    first = first == null ? Math.max(0, overscanFirst) : first;
+    overscanLast = overscanLast == null ? itemCount - 1 : overscanLast;
+    last = last == null ? Math.min(overscanLast, first + maxToRenderPerBatch - 1) : last;
+    var visible = {
+      first: first,
+      last: last
+    };
+    var newCellCount = newRangeCount(prev, visible);
+    while (true) {
+      if (first <= overscanFirst && last >= overscanLast) {
+        break;
+      }
+      var maxNewCells = newCellCount >= maxToRenderPerBatch;
+      var firstWillAddMore = void 0;
+      var lastWillAddMore = void 0;
+      if (ReactNativeFeatureFlags.fixVirtualizeListCollapseWindowSize()) {
+        firstWillAddMore = first <= prev.first;
+        lastWillAddMore = last >= prev.last;
+      } else {
+        firstWillAddMore = first <= prev.first || first > prev.last;
+        lastWillAddMore = last >= prev.last || last < prev.first;
+      }
+      var firstShouldIncrement = first > overscanFirst && (!maxNewCells || !firstWillAddMore);
+      var lastShouldIncrement = last < overscanLast && (!maxNewCells || !lastWillAddMore);
+      if (maxNewCells && !firstShouldIncrement && !lastShouldIncrement) {
+        break;
+      }
+      if (firstShouldIncrement && !(fillPreference === 'after' && lastShouldIncrement && lastWillAddMore)) {
+        if (firstWillAddMore) {
+          newCellCount++;
+        }
+        first--;
+      }
+      if (lastShouldIncrement && !(fillPreference === 'before' && firstShouldIncrement && firstWillAddMore)) {
+        if (lastWillAddMore) {
+          newCellCount++;
+        }
+        last++;
+      }
+    }
+    if (!(last >= first && first >= 0 && last < itemCount && first >= overscanFirst && last <= overscanLast && first <= visible.first && last >= visible.last)) {
+      throw new Error('Bad window calculation ' + JSON.stringify({
+        first: first,
+        last: last,
+        itemCount: itemCount,
+        overscanFirst: overscanFirst,
+        overscanLast: overscanLast,
+        visible: visible
+      }));
+    }
+    return {
+      first: first,
+      last: last
+    };
+  }
+  function keyExtractor(item, index) {
+    if (typeof item === 'object' && (item == null ? void 0 : item.key) != null) {
+      return item.key;
+    }
+    if (typeof item === 'object' && (item == null ? void 0 : item.id) != null) {
+      return item.id;
+    }
+    return String(index);
+  }
+},448,[1,34,52],"../../node_modules/@react-native/virtualized-lists/Lists/VirtualizeUtils.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _toConsumableArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/toConsumableArray"));
+  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/defineProperty"));
+  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/objectWithoutProperties"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/inherits"));
+  var _clamp = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "../Utilities/clamp"));
+  var _infoLog = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "../Utilities/infoLog"));
+  var _ChildListCollection = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "./ChildListCollection"));
+  var _FillRateHelper = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "./FillRateHelper"));
+  var _ListMetricsAggregator = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[13], "./ListMetricsAggregator"));
+  var _StateSafePureComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[14], "./StateSafePureComponent"));
+  var _ViewabilityHelper = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[15], "./ViewabilityHelper"));
+  var _VirtualizedListCellRenderer = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[16], "./VirtualizedListCellRenderer"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[17], "invariant"));
+  var _nullthrows = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[18], "nullthrows"));
+  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[19], "react"));
+  var React = _react;
+  var _reactNative = _$$_REQUIRE(_dependencyMap[20], "react-native");
+  var ReactNativeFeatureFlags = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[21], "react-native/src/private/featureflags/ReactNativeFeatureFlags"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[22], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/@react-native/virtualized-lists/Lists/VirtualizedList.js";
+  var _excluded = ["onContentSizeChange"];
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var ON_EDGE_REACHED_EPSILON = 0.001;
+  var _usedIndexForKey = false;
+  var _keylessItemComponentName = '';
+  function getScrollingThreshold(threshold, visibleLength) {
+    return threshold * visibleLength / 2;
+  }
+  var VirtualizedList = /*#__PURE__*/function (_StateSafePureCompone) {
+    function VirtualizedList(_props) {
+      var _this$props$maintainV, _this$props$maintainV2;
+      var _this;
+      (0, _classCallCheck2.default)(this, VirtualizedList);
+      _this = _callSuper(this, VirtualizedList, [_props]);
+      _this._getScrollMetrics = function () {
+        return _this._scrollMetrics;
+      };
+      _this._getOutermostParentListRef = function () {
+        if (_this._isNestedWithSameOrientation()) {
+          return _this.context.getOutermostParentListRef();
+        } else {
+          return _this;
+        }
+      };
+      _this._registerAsNestedChild = function (childList) {
+        _this._nestedChildLists.add(childList.ref, childList.cellKey);
+        if (_this._hasInteracted) {
+          childList.ref.recordInteraction();
+        }
+      };
+      _this._unregisterAsNestedChild = function (childList) {
+        _this._nestedChildLists.remove(childList.ref);
+      };
+      _this._onUpdateSeparators = function (keys, newProps) {
+        keys.forEach(function (key) {
+          var ref = key != null && _this._cellRefs[key];
+          ref && ref.updateSeparatorProps(newProps);
+        });
+      };
+      _this._getSpacerKey = function (isVertical) {
+        return isVertical ? 'height' : 'width';
+      };
+      _this._cellRefs = {};
+      _this._listMetrics = new _ListMetricsAggregator.default();
+      _this._footerLength = 0;
+      _this._hasTriggeredInitialScrollToIndex = false;
+      _this._hasInteracted = false;
+      _this._hasMore = false;
+      _this._hasWarned = {};
+      _this._headerLength = 0;
+      _this._hiPriInProgress = false;
+      _this._indicesToKeys = new Map();
+      _this._lastFocusedCellKey = null;
+      _this._nestedChildLists = new _ChildListCollection.default();
+      _this._offsetFromParentVirtualizedList = 0;
+      _this._pendingViewabilityUpdate = false;
+      _this._prevParentOffset = 0;
+      _this._scrollMetrics = {
+        dOffset: 0,
+        dt: 10,
+        offset: 0,
+        timestamp: 0,
+        velocity: 0,
+        visibleLength: 0,
+        zoomScale: 1
+      };
+      _this._scrollRef = null;
+      _this._sentStartForContentLength = 0;
+      _this._sentEndForContentLength = 0;
+      _this._updateCellsToRenderTimeoutID = null;
+      _this._viewabilityTuples = [];
+      _this._captureScrollRef = function (ref) {
+        _this._scrollRef = ref;
+      };
+      _this._defaultRenderScrollComponent = function (props) {
+        var onRefresh = props.onRefresh;
+        if (_this._isNestedWithSameOrientation()) {
+          var onContentSizeChange = props.onContentSizeChange,
+            otherProps = (0, _objectWithoutProperties2.default)(props, _excluded);
+          return /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, Object.assign({}, otherProps));
+        } else if (onRefresh) {
+          var _props$refreshing;
+          (0, _invariant.default)(typeof props.refreshing === 'boolean', '`refreshing` prop must be set as a boolean in order to use `onRefresh`, but got `' + JSON.stringify((_props$refreshing = props.refreshing) != null ? _props$refreshing : 'undefined') + '`');
+          return /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.ScrollView, Object.assign({}, props, {
+            refreshControl: props.refreshControl == null ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.RefreshControl, {
+              refreshing: props.refreshing,
+              onRefresh: onRefresh,
+              progressViewOffset: props.progressViewOffset
+            }) : props.refreshControl
+          }));
+        } else {
+          return /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.ScrollView, Object.assign({}, props));
+        }
+      };
+      _this._onCellLayout = function (e, cellKey, cellIndex) {
+        var layoutHasChanged = _this._listMetrics.notifyCellLayout({
+          cellIndex: cellIndex,
+          cellKey: cellKey,
+          layout: e.nativeEvent.layout,
+          orientation: _this._orientation()
+        });
+        if (layoutHasChanged) {
+          _this._scheduleCellsToRenderUpdate();
+        }
+        _this._triggerRemeasureForChildListsInCell(cellKey);
+        _this._computeBlankness();
+        _this._updateViewableItems(_this.props, _this.state.cellsAroundViewport);
+      };
+      _this._onCellFocusCapture = function (cellKey) {
+        _this._lastFocusedCellKey = cellKey;
+        if (ReactNativeFeatureFlags.deferFlatListFocusChangeRenderUpdate()) {
+          _this._scheduleCellsToRenderUpdate();
+        } else {
+          _this._updateCellsToRender();
+        }
+      };
+      _this._onCellUnmount = function (cellKey) {
+        delete _this._cellRefs[cellKey];
+        _this._listMetrics.notifyCellUnmounted(cellKey);
+      };
+      _this._onLayout = function (e) {
+        if (_this._isNestedWithSameOrientation()) {
+          _this.measureLayoutRelativeToContainingList();
+        } else {
+          _this._scrollMetrics.visibleLength = _this._selectLength(e.nativeEvent.layout);
+        }
+        _this.props.onLayout && _this.props.onLayout(e);
+        _this._scheduleCellsToRenderUpdate();
+        _this._maybeCallOnEdgeReached();
+      };
+      _this._onLayoutEmpty = function (e) {
+        _this.props.onLayout && _this.props.onLayout(e);
+      };
+      _this._onLayoutFooter = function (e) {
+        _this._triggerRemeasureForChildListsInCell(_this._getFooterCellKey());
+        _this._footerLength = _this._selectLength(e.nativeEvent.layout);
+      };
+      _this._onLayoutHeader = function (e) {
+        _this._headerLength = _this._selectLength(e.nativeEvent.layout);
+      };
+      _this._onContentSizeChange = function (width, height) {
+        _this._listMetrics.notifyListContentLayout({
+          layout: {
+            width: width,
+            height: height
+          },
+          orientation: _this._orientation()
+        });
+        _this._maybeScrollToInitialScrollIndex(width, height);
+        if (_this.props.onContentSizeChange) {
+          _this.props.onContentSizeChange(width, height);
+        }
+        _this._scheduleCellsToRenderUpdate();
+        _this._maybeCallOnEdgeReached();
+      };
+      _this._convertParentScrollMetrics = function (metrics) {
+        var offset = metrics.offset - _this._offsetFromParentVirtualizedList;
+        var visibleLength = metrics.visibleLength;
+        var dOffset = offset - _this._scrollMetrics.offset;
+        var contentLength = _this._listMetrics.getContentLength();
+        return {
+          visibleLength: visibleLength,
+          contentLength: contentLength,
+          offset: offset,
+          dOffset: dOffset
+        };
+      };
+      _this._onScroll = function (e) {
+        _this._nestedChildLists.forEach(function (childList) {
+          childList._onScroll(e);
+        });
+        if (_this.props.onScroll) {
+          _this.props.onScroll(e);
+        }
+        var timestamp = e.timeStamp;
+        var visibleLength = _this._selectLength(e.nativeEvent.layoutMeasurement);
+        var contentLength = _this._selectLength(e.nativeEvent.contentSize);
+        var offset = _this._offsetFromScrollEvent(e);
+        var dOffset = offset - _this._scrollMetrics.offset;
+        if (_this._isNestedWithSameOrientation()) {
+          if (_this._listMetrics.getContentLength() === 0) {
+            return;
+          }
+          var _this$_convertParentS = _this._convertParentScrollMetrics({
+            visibleLength: visibleLength,
+            offset: offset
+          });
+          visibleLength = _this$_convertParentS.visibleLength;
+          contentLength = _this$_convertParentS.contentLength;
+          offset = _this$_convertParentS.offset;
+          dOffset = _this$_convertParentS.dOffset;
+        }
+        var dt = _this._scrollMetrics.timestamp ? Math.max(1, timestamp - _this._scrollMetrics.timestamp) : 1;
+        var velocity = dOffset / dt;
+        if (dt > 500 && _this._scrollMetrics.dt > 500 && contentLength > 5 * visibleLength && !_this._hasWarned.perf) {
+          (0, _infoLog.default)('VirtualizedList: You have a large list that is slow to update - make sure your ' + 'renderItem function renders components that follow React performance best practices ' + 'like PureComponent, shouldComponentUpdate, etc.', {
+            dt: dt,
+            prevDt: _this._scrollMetrics.dt,
+            contentLength: contentLength
+          });
+          _this._hasWarned.perf = true;
+        }
+        var zoomScale = e.nativeEvent.zoomScale < 0 ? 1 : e.nativeEvent.zoomScale;
+        _this._scrollMetrics = {
+          dt: dt,
+          dOffset: dOffset,
+          offset: offset,
+          timestamp: timestamp,
+          velocity: velocity,
+          visibleLength: visibleLength,
+          zoomScale: zoomScale
+        };
+        if (_this.state.pendingScrollUpdateCount > 0) {
+          _this.setState(function (state) {
+            return {
+              pendingScrollUpdateCount: state.pendingScrollUpdateCount - 1
+            };
+          });
+        }
+        _this._updateViewableItems(_this.props, _this.state.cellsAroundViewport);
+        if (!_this.props) {
+          return;
+        }
+        _this._maybeCallOnEdgeReached();
+        if (velocity !== 0) {
+          _this._fillRateHelper.activate();
+        }
+        _this._computeBlankness();
+        _this._scheduleCellsToRenderUpdate();
+      };
+      _this._onScrollBeginDrag = function (e) {
+        _this._nestedChildLists.forEach(function (childList) {
+          childList._onScrollBeginDrag(e);
+        });
+        _this._viewabilityTuples.forEach(function (tuple) {
+          tuple.viewabilityHelper.recordInteraction();
+        });
+        _this._hasInteracted = true;
+        _this.props.onScrollBeginDrag && _this.props.onScrollBeginDrag(e);
+      };
+      _this._onScrollEndDrag = function (e) {
+        _this._nestedChildLists.forEach(function (childList) {
+          childList._onScrollEndDrag(e);
+        });
+        var velocity = e.nativeEvent.velocity;
+        if (velocity) {
+          _this._scrollMetrics.velocity = _this._selectOffset(velocity);
+        }
+        _this._computeBlankness();
+        _this.props.onScrollEndDrag && _this.props.onScrollEndDrag(e);
+      };
+      _this._onMomentumScrollBegin = function (e) {
+        _this._nestedChildLists.forEach(function (childList) {
+          childList._onMomentumScrollBegin(e);
+        });
+        _this.props.onMomentumScrollBegin && _this.props.onMomentumScrollBegin(e);
+      };
+      _this._onMomentumScrollEnd = function (e) {
+        _this._nestedChildLists.forEach(function (childList) {
+          childList._onMomentumScrollEnd(e);
+        });
+        _this._scrollMetrics.velocity = 0;
+        _this._computeBlankness();
+        _this.props.onMomentumScrollEnd && _this.props.onMomentumScrollEnd(e);
+      };
+      _this._updateCellsToRender = function () {
+        _this._updateViewableItems(_this.props, _this.state.cellsAroundViewport);
+        _this.setState(function (state, props) {
+          var cellsAroundViewport = _this._adjustCellsAroundViewport(props, state.cellsAroundViewport, state.pendingScrollUpdateCount);
+          var renderMask = VirtualizedList._createRenderMask(props, cellsAroundViewport, _this._getNonViewportRenderRegions(props));
+          if (cellsAroundViewport.first === state.cellsAroundViewport.first && cellsAroundViewport.last === state.cellsAroundViewport.last && renderMask.equals(state.renderMask)) {
+            return null;
+          }
+          return {
+            cellsAroundViewport: cellsAroundViewport,
+            renderMask: renderMask
+          };
+        });
+      };
+      _this._createViewToken = function (index, isViewable, props) {
+        var data = props.data,
+          getItem = props.getItem;
+        var item = getItem(data, index);
+        return {
+          index: index,
+          item: item,
+          key: VirtualizedList._keyExtractor(item, index, props),
+          isViewable: isViewable
+        };
+      };
+      _this._getNonViewportRenderRegions = function (props) {
+        if (!(_this._lastFocusedCellKey && _this._cellRefs[_this._lastFocusedCellKey])) {
+          return [];
+        }
+        var lastFocusedCellRenderer = _this._cellRefs[_this._lastFocusedCellKey];
+        var focusedCellIndex = lastFocusedCellRenderer.props.index;
+        var itemCount = props.getItemCount(props.data);
+        if (focusedCellIndex >= itemCount || VirtualizedList._getItemKey(props, focusedCellIndex) !== _this._lastFocusedCellKey) {
+          return [];
+        }
+        var first = focusedCellIndex;
+        var heightOfCellsBeforeFocused = 0;
+        for (var i = first - 1; i >= 0 && heightOfCellsBeforeFocused < _this._scrollMetrics.visibleLength; i--) {
+          first--;
+          heightOfCellsBeforeFocused += _this._listMetrics.getCellMetricsApprox(i, props).length;
+        }
+        var last = focusedCellIndex;
+        var heightOfCellsAfterFocused = 0;
+        for (var _i = last + 1; _i < itemCount && heightOfCellsAfterFocused < _this._scrollMetrics.visibleLength; _i++) {
+          last++;
+          heightOfCellsAfterFocused += _this._listMetrics.getCellMetricsApprox(_i, props).length;
+        }
+        return [{
+          first: first,
+          last: last
+        }];
+      };
+      _this._checkProps(_props);
+      _this._fillRateHelper = new _FillRateHelper.default(_this._listMetrics);
+      if (_this.props.viewabilityConfigCallbackPairs) {
+        _this._viewabilityTuples = _this.props.viewabilityConfigCallbackPairs.map(function (pair) {
+          return {
+            viewabilityHelper: new _ViewabilityHelper.default(pair.viewabilityConfig),
+            onViewableItemsChanged: pair.onViewableItemsChanged
+          };
+        });
+      } else {
+        var _this$props = _this.props,
+          onViewableItemsChanged = _this$props.onViewableItemsChanged,
+          viewabilityConfig = _this$props.viewabilityConfig;
+        if (onViewableItemsChanged) {
+          _this._viewabilityTuples.push({
+            viewabilityHelper: new _ViewabilityHelper.default(viewabilityConfig),
+            onViewableItemsChanged: onViewableItemsChanged
+          });
+        }
+      }
+      var initialRenderRegion = VirtualizedList._initialRenderRegion(_props);
+      var minIndexForVisible = (_this$props$maintainV = (_this$props$maintainV2 = _this.props.maintainVisibleContentPosition) == null ? void 0 : _this$props$maintainV2.minIndexForVisible) != null ? _this$props$maintainV : 0;
+      _this.state = {
+        cellsAroundViewport: initialRenderRegion,
+        renderMask: VirtualizedList._createRenderMask(_props, initialRenderRegion),
+        firstVisibleItemKey: _this.props.getItemCount(_this.props.data) > minIndexForVisible ? VirtualizedList._getItemKey(_this.props, minIndexForVisible) : null,
+        pendingScrollUpdateCount: _this.props.initialScrollIndex != null && _this.props.initialScrollIndex > 0 ? 1 : 0
+      };
+      return _this;
+    }
+    (0, _inherits2.default)(VirtualizedList, _StateSafePureCompone);
+    return (0, _createClass2.default)(VirtualizedList, [{
+      key: "scrollToEnd",
+      value: function scrollToEnd(params) {
+        var animated = params ? params.animated : true;
+        var veryLast = this.props.getItemCount(this.props.data) - 1;
+        if (veryLast < 0) {
+          return;
+        }
+        var frame = this._listMetrics.getCellMetricsApprox(veryLast, this.props);
+        var offset = Math.max(0, frame.offset + frame.length + this._footerLength - this._scrollMetrics.visibleLength);
+        this.scrollToOffset({
+          animated: animated,
+          offset: offset
+        });
+      }
+    }, {
+      key: "scrollToIndex",
+      value: function scrollToIndex(params) {
+        var _this$props2 = this.props,
+          data = _this$props2.data,
+          getItemCount = _this$props2.getItemCount,
+          getItemLayout = _this$props2.getItemLayout,
+          onScrollToIndexFailed = _this$props2.onScrollToIndexFailed;
+        var animated = params.animated,
+          index = params.index,
+          viewOffset = params.viewOffset,
+          viewPosition = params.viewPosition;
+        (0, _invariant.default)(index >= 0, `scrollToIndex out of range: requested index ${index} but minimum is 0`);
+        (0, _invariant.default)(getItemCount(data) >= 1, `scrollToIndex out of range: item length ${getItemCount(data)} but minimum is 1`);
+        (0, _invariant.default)(index < getItemCount(data), `scrollToIndex out of range: requested index ${index} is out of 0 to ${getItemCount(data) - 1}`);
+        if (!getItemLayout && index > this._listMetrics.getHighestMeasuredCellIndex()) {
+          (0, _invariant.default)(!!onScrollToIndexFailed, 'scrollToIndex should be used in conjunction with getItemLayout or onScrollToIndexFailed, ' + 'otherwise there is no way to know the location of offscreen indices or handle failures.');
+          onScrollToIndexFailed({
+            averageItemLength: this._listMetrics.getAverageCellLength(),
+            highestMeasuredFrameIndex: this._listMetrics.getHighestMeasuredCellIndex(),
+            index: index
+          });
+          return;
+        }
+        var frame = this._listMetrics.getCellMetricsApprox(Math.floor(index), this.props);
+        var offset = Math.max(0, this._listMetrics.getCellOffsetApprox(index, this.props) - (viewPosition || 0) * (this._scrollMetrics.visibleLength - frame.length)) - (viewOffset || 0);
+        this.scrollToOffset({
+          offset: offset,
+          animated: animated
+        });
+      }
+    }, {
+      key: "scrollToItem",
+      value: function scrollToItem(params) {
+        var item = params.item;
+        var _this$props3 = this.props,
+          data = _this$props3.data,
+          getItem = _this$props3.getItem,
+          getItemCount = _this$props3.getItemCount;
+        var itemCount = getItemCount(data);
+        for (var index = 0; index < itemCount; index++) {
+          if (getItem(data, index) === item) {
+            this.scrollToIndex(Object.assign({}, params, {
+              index: index
+            }));
+            break;
+          }
+        }
+      }
+    }, {
+      key: "scrollToOffset",
+      value: function scrollToOffset(params) {
+        var animated = params.animated,
+          offset = params.offset;
+        var scrollRef = this._scrollRef;
+        if (scrollRef == null) {
+          return;
+        }
+        if (scrollRef.scrollTo == null) {
+          console.warn('No scrollTo method provided. This may be because you have two nested ' + 'VirtualizedLists with the same orientation, or because you are ' + 'using a custom component that does not implement scrollTo.');
+          return;
+        }
+        var _this$_orientation = this._orientation(),
+          horizontal = _this$_orientation.horizontal,
+          rtl = _this$_orientation.rtl;
+        if (horizontal && rtl && !this._listMetrics.hasContentLength()) {
+          console.warn('scrollToOffset may not be called in RTL before content is laid out');
+          return;
+        }
+        scrollRef.scrollTo(Object.assign({
+          animated: animated
+        }, this._scrollToParamsFromOffset(offset)));
+      }
+    }, {
+      key: "_scrollToParamsFromOffset",
+      value: function _scrollToParamsFromOffset(offset) {
+        var _this$_orientation2 = this._orientation(),
+          horizontal = _this$_orientation2.horizontal,
+          rtl = _this$_orientation2.rtl;
+        if (horizontal && rtl) {
+          var cartOffset = this._listMetrics.cartesianOffset(offset + this._scrollMetrics.visibleLength);
+          return horizontal ? {
+            x: cartOffset
+          } : {
+            y: cartOffset
+          };
+        } else {
+          return horizontal ? {
+            x: offset
+          } : {
+            y: offset
+          };
+        }
+      }
+    }, {
+      key: "recordInteraction",
+      value: function recordInteraction() {
+        this._nestedChildLists.forEach(function (childList) {
+          childList.recordInteraction();
+        });
+        this._viewabilityTuples.forEach(function (t) {
+          t.viewabilityHelper.recordInteraction();
+        });
+        this._updateViewableItems(this.props, this.state.cellsAroundViewport);
+      }
+    }, {
+      key: "flashScrollIndicators",
+      value: function flashScrollIndicators() {
+        if (this._scrollRef == null) {
+          return;
+        }
+        this._scrollRef.flashScrollIndicators();
+      }
+    }, {
+      key: "getScrollResponder",
+      value: function getScrollResponder() {
+        if (this._scrollRef && this._scrollRef.getScrollResponder) {
+          return this._scrollRef.getScrollResponder();
+        }
+      }
+    }, {
+      key: "getScrollableNode",
+      value: function getScrollableNode() {
+        if (this._scrollRef && this._scrollRef.getScrollableNode) {
+          return this._scrollRef.getScrollableNode();
+        } else {
+          return (0, _reactNative.findNodeHandle)(this._scrollRef);
+        }
+      }
+    }, {
+      key: "getScrollRef",
+      value: function getScrollRef() {
+        if (this._scrollRef && this._scrollRef.getScrollRef) {
+          return this._scrollRef.getScrollRef();
+        } else {
+          return this._scrollRef;
+        }
+      }
+    }, {
+      key: "setNativeProps",
+      value: function setNativeProps(props) {
+        if (this._scrollRef) {
+          this._scrollRef.setNativeProps(props);
+        }
+      }
+    }, {
+      key: "_getCellKey",
+      value: function _getCellKey() {
+        var _this$context;
+        return ((_this$context = this.context) == null ? void 0 : _this$context.cellKey) || 'rootList';
+      }
+    }, {
+      key: "hasMore",
+      value: function hasMore() {
+        return this._hasMore;
+      }
+    }, {
+      key: "_checkProps",
+      value: function _checkProps(props) {
+        var onScroll = props.onScroll,
+          windowSize = props.windowSize,
+          getItemCount = props.getItemCount,
+          data = props.data,
+          initialScrollIndex = props.initialScrollIndex;
+        (0, _invariant.default)(!onScroll || !onScroll.__isNative, 'Components based on VirtualizedList must be wrapped with Animated.createAnimatedComponent ' + 'to support native onScroll events with useNativeDriver');
+        (0, _invariant.default)((0, _$$_REQUIRE(_dependencyMap[23], "./VirtualizedListProps").windowSizeOrDefault)(windowSize) > 0, 'VirtualizedList: The windowSize prop must be present and set to a value greater than 0.');
+        (0, _invariant.default)(getItemCount, 'VirtualizedList: The "getItemCount" prop must be provided');
+        var itemCount = getItemCount(data);
+        if (initialScrollIndex != null && !this._hasTriggeredInitialScrollToIndex && (initialScrollIndex < 0 || itemCount > 0 && initialScrollIndex >= itemCount) && !this._hasWarned.initialScrollIndex) {
+          console.warn(`initialScrollIndex "${initialScrollIndex}" is not valid (list has ${itemCount} items)`);
+          this._hasWarned.initialScrollIndex = true;
+        }
+        if (__DEV__ && !this._hasWarned.flexWrap) {
+          var flatStyles = _reactNative.StyleSheet.flatten(this.props.contentContainerStyle);
+          if (flatStyles != null && flatStyles.flexWrap === 'wrap') {
+            console.warn('`flexWrap: `wrap`` is not supported with the `VirtualizedList` components.' + 'Consider using `numColumns` with `FlatList` instead.');
+            this._hasWarned.flexWrap = true;
+          }
+        }
+      }
+    }, {
+      key: "_adjustCellsAroundViewport",
+      value: function _adjustCellsAroundViewport(props, cellsAroundViewport, pendingScrollUpdateCount) {
+        var data = props.data,
+          getItemCount = props.getItemCount;
+        var onEndReachedThreshold = (0, _$$_REQUIRE(_dependencyMap[23], "./VirtualizedListProps").onEndReachedThresholdOrDefault)(props.onEndReachedThreshold);
+        var _this$_scrollMetrics = this._scrollMetrics,
+          offset = _this$_scrollMetrics.offset,
+          visibleLength = _this$_scrollMetrics.visibleLength;
+        var contentLength = this._listMetrics.getContentLength();
+        var distanceFromEnd = contentLength - visibleLength - offset;
+        if (visibleLength <= 0 || contentLength <= 0) {
+          return cellsAroundViewport.last >= getItemCount(data) ? VirtualizedList._constrainToItemCount(cellsAroundViewport, props) : cellsAroundViewport;
+        }
+        var newCellsAroundViewport;
+        if (props.disableVirtualization) {
+          var renderAhead = distanceFromEnd < onEndReachedThreshold * visibleLength ? (0, _$$_REQUIRE(_dependencyMap[23], "./VirtualizedListProps").maxToRenderPerBatchOrDefault)(props.maxToRenderPerBatch) : 0;
+          newCellsAroundViewport = {
+            first: 0,
+            last: Math.min(cellsAroundViewport.last + renderAhead, getItemCount(data) - 1)
+          };
+        } else {
+          if (pendingScrollUpdateCount > 0) {
+            return cellsAroundViewport.last >= getItemCount(data) ? VirtualizedList._constrainToItemCount(cellsAroundViewport, props) : cellsAroundViewport;
+          }
+          newCellsAroundViewport = (0, _$$_REQUIRE(_dependencyMap[24], "./VirtualizeUtils").computeWindowedRenderLimits)(props, (0, _$$_REQUIRE(_dependencyMap[23], "./VirtualizedListProps").maxToRenderPerBatchOrDefault)(props.maxToRenderPerBatch), (0, _$$_REQUIRE(_dependencyMap[23], "./VirtualizedListProps").windowSizeOrDefault)(props.windowSize), cellsAroundViewport, this._listMetrics, this._scrollMetrics);
+          (0, _invariant.default)(newCellsAroundViewport.last < getItemCount(data), 'computeWindowedRenderLimits() should return range in-bounds');
+        }
+        if (this._nestedChildLists.size() > 0) {
+          var childIdx = this._findFirstChildWithMore(newCellsAroundViewport.first, newCellsAroundViewport.last);
+          newCellsAroundViewport.last = childIdx != null ? childIdx : newCellsAroundViewport.last;
+        }
+        return newCellsAroundViewport;
+      }
+    }, {
+      key: "_findFirstChildWithMore",
+      value: function _findFirstChildWithMore(first, last) {
+        for (var ii = first; ii <= last; ii++) {
+          var cellKeyForIndex = this._indicesToKeys.get(ii);
+          if (cellKeyForIndex != null && this._nestedChildLists.anyInCell(cellKeyForIndex, function (childList) {
+            return childList.hasMore();
+          })) {
+            return ii;
+          }
+        }
+        return null;
+      }
+    }, {
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        if (this._isNestedWithSameOrientation()) {
+          this.context.registerAsNestedChild({
+            ref: this,
+            cellKey: this.context.cellKey
+          });
+        }
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        if (this._isNestedWithSameOrientation()) {
+          this.context.unregisterAsNestedChild({
+            ref: this
+          });
+        }
+        clearTimeout(this._updateCellsToRenderTimeoutID);
+        this._viewabilityTuples.forEach(function (tuple) {
+          tuple.viewabilityHelper.dispose();
+        });
+        this._fillRateHelper.deactivateAndFlush();
+      }
+    }, {
+      key: "_pushCells",
+      value: function _pushCells(cells, stickyHeaderIndices, stickyIndicesFromProps, first, last, inversionStyle) {
+        var _this2 = this;
+        var _this$props4 = this.props,
+          CellRendererComponent = _this$props4.CellRendererComponent,
+          ItemSeparatorComponent = _this$props4.ItemSeparatorComponent,
+          ListHeaderComponent = _this$props4.ListHeaderComponent,
+          ListItemComponent = _this$props4.ListItemComponent,
+          data = _this$props4.data,
+          debug = _this$props4.debug,
+          getItem = _this$props4.getItem,
+          getItemCount = _this$props4.getItemCount,
+          getItemLayout = _this$props4.getItemLayout,
+          horizontal = _this$props4.horizontal,
+          renderItem = _this$props4.renderItem;
+        var stickyOffset = ListHeaderComponent ? 1 : 0;
+        var end = getItemCount(data) - 1;
+        var prevCellKey;
+        last = Math.min(end, last);
+        var _loop = function _loop() {
+          var item = getItem(data, ii);
+          var key = VirtualizedList._keyExtractor(item, ii, _this2.props);
+          _this2._indicesToKeys.set(ii, key);
+          if (stickyIndicesFromProps.has(ii + stickyOffset)) {
+            stickyHeaderIndices.push(cells.length);
+          }
+          var shouldListenForLayout = getItemLayout == null || debug || _this2._fillRateHelper.enabled();
+          cells.push(/*#__PURE__*/(0, _jsxRuntime.jsx)(_VirtualizedListCellRenderer.default, Object.assign({
+            CellRendererComponent: CellRendererComponent,
+            ItemSeparatorComponent: ii < end ? ItemSeparatorComponent : undefined,
+            ListItemComponent: ListItemComponent,
+            cellKey: key,
+            horizontal: horizontal,
+            index: ii,
+            inversionStyle: inversionStyle,
+            item: item,
+            prevCellKey: prevCellKey,
+            onUpdateSeparators: _this2._onUpdateSeparators,
+            onCellFocusCapture: _this2._onCellFocusCapture,
+            onUnmount: _this2._onCellUnmount,
+            ref: function ref(_ref) {
+              _this2._cellRefs[key] = _ref;
+            },
+            renderItem: renderItem
+          }, shouldListenForLayout && {
+            onCellLayout: _this2._onCellLayout
+          }), key));
+          prevCellKey = key;
+        };
+        for (var ii = first; ii <= last; ii++) {
+          _loop();
+        }
+      }
+    }, {
+      key: "_isNestedWithSameOrientation",
+      value: function _isNestedWithSameOrientation() {
+        var nestedContext = this.context;
+        return !!(nestedContext && !!nestedContext.horizontal === (0, _$$_REQUIRE(_dependencyMap[23], "./VirtualizedListProps").horizontalOrDefault)(this.props.horizontal));
+      }
+    }, {
+      key: "_renderEmptyComponent",
+      value: function _renderEmptyComponent(element, inversionStyle) {
+        var _this3 = this;
+        var isFragment = element.type === React.Fragment;
+        if (isFragment) {
+          return element;
+        }
+        return (0, _react.cloneElement)(element, {
+          onLayout: function onLayout(event) {
+            _this3._onLayoutEmpty(event);
+            if (element.props.onLayout) {
+              element.props.onLayout(event);
+            }
+          },
+          style: _reactNative.StyleSheet.compose(inversionStyle, element.props.style)
+        });
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props$scrollEve,
+          _this4 = this;
+        this._checkProps(this.props);
+        var _this$props5 = this.props,
+          ListEmptyComponent = _this$props5.ListEmptyComponent,
+          ListFooterComponent = _this$props5.ListFooterComponent,
+          ListHeaderComponent = _this$props5.ListHeaderComponent;
+        var _this$props6 = this.props,
+          data = _this$props6.data,
+          horizontal = _this$props6.horizontal;
+        var inversionStyle = this.props.inverted ? (0, _$$_REQUIRE(_dependencyMap[23], "./VirtualizedListProps").horizontalOrDefault)(this.props.horizontal) ? styles.horizontallyInverted : styles.verticallyInverted : null;
+        var cells = [];
+        var stickyIndicesFromProps = new Set(this.props.stickyHeaderIndices);
+        var stickyHeaderIndices = [];
+        if (ListHeaderComponent) {
+          if (stickyIndicesFromProps.has(0)) {
+            stickyHeaderIndices.push(0);
+          }
+          var element = (0, _react.isValidElement)(ListHeaderComponent) ? ListHeaderComponent : /*#__PURE__*/(0, _jsxRuntime.jsx)(ListHeaderComponent, {});
+          cells.push(/*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[25], "./VirtualizedListContext.js").VirtualizedListCellContextProvider, {
+            cellKey: this._getCellKey() + '-header',
+            children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
+              collapsable: false,
+              onLayout: this._onLayoutHeader,
+              style: _reactNative.StyleSheet.compose(inversionStyle, this.props.ListHeaderComponentStyle),
+              children: element
+            })
+          }, "$header"));
+        }
+        var itemCount = this.props.getItemCount(data);
+        if (itemCount === 0 && ListEmptyComponent) {
+          var _element = (0, _react.isValidElement)(ListEmptyComponent) ? ListEmptyComponent : /*#__PURE__*/(0, _jsxRuntime.jsx)(ListEmptyComponent, {});
+          cells.push(/*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[25], "./VirtualizedListContext.js").VirtualizedListCellContextProvider, {
+            cellKey: this._getCellKey() + '-empty',
+            children: this._renderEmptyComponent(_element, inversionStyle)
+          }, "$empty"));
+        }
+        if (itemCount > 0) {
+          _usedIndexForKey = false;
+          _keylessItemComponentName = '';
+          var spacerKey = this._getSpacerKey(!horizontal);
+          var renderRegions = this.state.renderMask.enumerateRegions();
+          var lastRegion = renderRegions[renderRegions.length - 1];
+          var lastSpacer = lastRegion != null && lastRegion.isSpacer ? lastRegion : null;
+          for (var section of renderRegions) {
+            if (section.isSpacer) {
+              if (this.props.disableVirtualization) {
+                continue;
+              }
+              var isLastSpacer = section === lastSpacer;
+              var constrainToMeasured = isLastSpacer && !this.props.getItemLayout;
+              var last = constrainToMeasured ? (0, _clamp.default)(section.first - 1, section.last, this._listMetrics.getHighestMeasuredCellIndex()) : section.last;
+              var firstMetrics = this._listMetrics.getCellMetricsApprox(section.first, this.props);
+              var lastMetrics = this._listMetrics.getCellMetricsApprox(last, this.props);
+              var spacerSize = lastMetrics.offset + lastMetrics.length - firstMetrics.offset;
+              cells.push(/*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
+                style: (0, _defineProperty2.default)({}, spacerKey, spacerSize)
+              }, `$spacer-${section.first}`));
+            } else {
+              this._pushCells(cells, stickyHeaderIndices, stickyIndicesFromProps, section.first, section.last, inversionStyle);
+            }
+          }
+          if (!this._hasWarned.keys && _usedIndexForKey) {
+            console.warn('VirtualizedList: missing keys for items, make sure to specify a key or id property on each ' + 'item or provide a custom keyExtractor.', _keylessItemComponentName);
+            this._hasWarned.keys = true;
+          }
+        }
+        if (ListFooterComponent) {
+          var _element2 = (0, _react.isValidElement)(ListFooterComponent) ? ListFooterComponent : /*#__PURE__*/(0, _jsxRuntime.jsx)(ListFooterComponent, {});
+          cells.push(/*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[25], "./VirtualizedListContext.js").VirtualizedListCellContextProvider, {
+            cellKey: this._getFooterCellKey(),
+            children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
+              onLayout: this._onLayoutFooter,
+              style: _reactNative.StyleSheet.compose(inversionStyle, this.props.ListFooterComponentStyle),
+              children: _element2
+            })
+          }, "$footer"));
+        }
+        var scrollProps = Object.assign({}, this.props, {
+          onContentSizeChange: this._onContentSizeChange,
+          onLayout: this._onLayout,
+          onScroll: this._onScroll,
+          onScrollBeginDrag: this._onScrollBeginDrag,
+          onScrollEndDrag: this._onScrollEndDrag,
+          onMomentumScrollBegin: this._onMomentumScrollBegin,
+          onMomentumScrollEnd: this._onMomentumScrollEnd,
+          scrollEventThrottle: (_this$props$scrollEve = this.props.scrollEventThrottle) != null ? _this$props$scrollEve : 0.0001,
+          invertStickyHeaders: this.props.invertStickyHeaders !== undefined ? this.props.invertStickyHeaders : this.props.inverted,
+          stickyHeaderIndices: stickyHeaderIndices,
+          style: inversionStyle ? [inversionStyle, this.props.style] : this.props.style,
+          isInvertedVirtualizedList: this.props.inverted,
+          maintainVisibleContentPosition: this.props.maintainVisibleContentPosition != null ? Object.assign({}, this.props.maintainVisibleContentPosition, {
+            minIndexForVisible: this.props.maintainVisibleContentPosition.minIndexForVisible + (this.props.ListHeaderComponent ? 1 : 0)
+          }) : undefined
+        });
+        this._hasMore = this.state.cellsAroundViewport.last < itemCount - 1;
+        var innerRet = /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[25], "./VirtualizedListContext.js").VirtualizedListContextProvider, {
+          value: {
+            cellKey: null,
+            getScrollMetrics: this._getScrollMetrics,
+            horizontal: (0, _$$_REQUIRE(_dependencyMap[23], "./VirtualizedListProps").horizontalOrDefault)(this.props.horizontal),
+            getOutermostParentListRef: this._getOutermostParentListRef,
+            registerAsNestedChild: this._registerAsNestedChild,
+            unregisterAsNestedChild: this._unregisterAsNestedChild
+          },
+          children: (0, _react.cloneElement)((this.props.renderScrollComponent || this._defaultRenderScrollComponent)(scrollProps), {
+            ref: this._captureScrollRef
+          }, cells)
+        });
+        var ret = innerRet;
+        if (__DEV__) {
+          ret = /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.ScrollView.Context.Consumer, {
+            children: function children(scrollContext) {
+              if (scrollContext != null && !scrollContext.horizontal === !(0, _$$_REQUIRE(_dependencyMap[23], "./VirtualizedListProps").horizontalOrDefault)(_this4.props.horizontal) && !_this4._hasWarned.nesting && _this4.context == null && _this4.props.scrollEnabled !== false) {
+                console.error('VirtualizedLists should never be nested inside plain ScrollViews with the same ' + 'orientation because it can break windowing and other functionality - use another ' + 'VirtualizedList-backed container instead.');
+                _this4._hasWarned.nesting = true;
+              }
+              return innerRet;
+            }
+          });
+        }
+        if (this.props.debug) {
+          return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, {
+            style: styles.debug,
+            children: [ret, this._renderDebugOverlay()]
+          });
+        } else {
+          return ret;
+        }
+      }
+    }, {
+      key: "componentDidUpdate",
+      value: function componentDidUpdate(prevProps) {
+        var _this$props7 = this.props,
+          data = _this$props7.data,
+          extraData = _this$props7.extraData,
+          getItemLayout = _this$props7.getItemLayout;
+        if (data !== prevProps.data || extraData !== prevProps.extraData) {
+          this._viewabilityTuples.forEach(function (tuple) {
+            tuple.viewabilityHelper.resetViewableIndices();
+          });
+        }
+        var hiPriInProgress = this._hiPriInProgress;
+        this._scheduleCellsToRenderUpdate();
+        if (hiPriInProgress) {
+          this._hiPriInProgress = false;
+        }
+        if (getItemLayout != null) {
+          this._maybeCallOnEdgeReached();
+        }
+      }
+    }, {
+      key: "_computeBlankness",
+      value: function _computeBlankness() {
+        this._fillRateHelper.computeBlankness(this.props, this.state.cellsAroundViewport, this._scrollMetrics);
+      }
+    }, {
+      key: "_triggerRemeasureForChildListsInCell",
+      value: function _triggerRemeasureForChildListsInCell(cellKey) {
+        this._nestedChildLists.forEachInCell(cellKey, function (childList) {
+          childList.measureLayoutRelativeToContainingList();
+        });
+      }
+    }, {
+      key: "measureLayoutRelativeToContainingList",
+      value: function measureLayoutRelativeToContainingList() {
+        var _this5 = this;
+        try {
+          if (!this._scrollRef) {
+            return;
+          }
+          this._scrollRef.measureLayout(this.context.getOutermostParentListRef().getScrollRef(), function (x, y, width, height) {
+            _this5._offsetFromParentVirtualizedList = _this5._selectOffset({
+              x: x,
+              y: y
+            });
+            _this5._listMetrics.notifyListContentLayout({
+              layout: {
+                width: width,
+                height: height
+              },
+              orientation: _this5._orientation()
+            });
+            var scrollMetrics = _this5._convertParentScrollMetrics(_this5.context.getScrollMetrics());
+            var metricsChanged = _this5._scrollMetrics.visibleLength !== scrollMetrics.visibleLength || _this5._scrollMetrics.offset !== scrollMetrics.offset;
+            if (metricsChanged) {
+              _this5._scrollMetrics.visibleLength = scrollMetrics.visibleLength;
+              _this5._scrollMetrics.offset = scrollMetrics.offset;
+              _this5._nestedChildLists.forEach(function (childList) {
+                childList.measureLayoutRelativeToContainingList();
+              });
+            }
+          }, function (error) {
+            console.warn("VirtualizedList: Encountered an error while measuring a list's" + ' offset from its containing VirtualizedList.');
+          });
+        } catch (error) {
+          console.warn('measureLayoutRelativeToContainingList threw an error', error.stack);
+        }
+      }
+    }, {
+      key: "_getFooterCellKey",
+      value: function _getFooterCellKey() {
+        return this._getCellKey() + '-footer';
+      }
+    }, {
+      key: "_renderDebugOverlay",
+      value: function _renderDebugOverlay() {
+        var _this6 = this;
+        var normalize = this._scrollMetrics.visibleLength / (this._listMetrics.getContentLength() || 1);
+        var framesInLayout = [];
+        var itemCount = this.props.getItemCount(this.props.data);
+        for (var ii = 0; ii < itemCount; ii++) {
+          var frame = this._listMetrics.getCellMetricsApprox(ii, this.props);
+          if (frame.isMounted) {
+            framesInLayout.push(frame);
+          }
+        }
+        var windowTop = this._listMetrics.getCellMetricsApprox(this.state.cellsAroundViewport.first, this.props).offset;
+        var frameLast = this._listMetrics.getCellMetricsApprox(this.state.cellsAroundViewport.last, this.props);
+        var windowLen = frameLast.offset + frameLast.length - windowTop;
+        var visTop = this._scrollMetrics.offset;
+        var visLen = this._scrollMetrics.visibleLength;
+        return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, {
+          style: [styles.debugOverlayBase, styles.debugOverlay],
+          children: [framesInLayout.map(function (f, ii) {
+            return /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
+              style: [styles.debugOverlayBase, styles.debugOverlayFrame, {
+                top: f.offset * normalize,
+                height: f.length * normalize
+              }]
+            }, 'f' + ii);
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
+            style: [styles.debugOverlayBase, styles.debugOverlayFrameLast, {
+              top: windowTop * normalize,
+              height: windowLen * normalize
+            }]
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
+            style: [styles.debugOverlayBase, styles.debugOverlayFrameVis, {
+              top: visTop * normalize,
+              height: visLen * normalize
+            }]
+          })]
+        });
+      }
+    }, {
+      key: "_selectLength",
+      value: function _selectLength(metrics) {
+        return !(0, _$$_REQUIRE(_dependencyMap[23], "./VirtualizedListProps").horizontalOrDefault)(this.props.horizontal) ? metrics.height : metrics.width;
+      }
+    }, {
+      key: "_selectOffset",
+      value: function _selectOffset(_ref3) {
+        var x = _ref3.x,
+          y = _ref3.y;
+        return this._orientation().horizontal ? x : y;
+      }
+    }, {
+      key: "_orientation",
+      value: function _orientation() {
+        return {
+          horizontal: (0, _$$_REQUIRE(_dependencyMap[23], "./VirtualizedListProps").horizontalOrDefault)(this.props.horizontal),
+          rtl: _reactNative.I18nManager.isRTL
+        };
+      }
+    }, {
+      key: "_maybeCallOnEdgeReached",
+      value: function _maybeCallOnEdgeReached() {
+        var _this$props8 = this.props,
+          data = _this$props8.data,
+          getItemCount = _this$props8.getItemCount,
+          onStartReached = _this$props8.onStartReached,
+          onStartReachedThreshold = _this$props8.onStartReachedThreshold,
+          onEndReached = _this$props8.onEndReached,
+          onEndReachedThreshold = _this$props8.onEndReachedThreshold;
+        if (!this._listMetrics.hasContentLength() || this._scrollMetrics.visibleLength === 0) {
+          return;
+        }
+        if (this.state.pendingScrollUpdateCount > 0) {
+          return;
+        }
+        var _this$_scrollMetrics2 = this._scrollMetrics,
+          visibleLength = _this$_scrollMetrics2.visibleLength,
+          offset = _this$_scrollMetrics2.offset;
+        var distanceFromStart = offset;
+        var distanceFromEnd = this._listMetrics.getContentLength() - visibleLength - offset;
+        if (distanceFromStart < ON_EDGE_REACHED_EPSILON) {
+          distanceFromStart = 0;
+        }
+        if (distanceFromEnd < ON_EDGE_REACHED_EPSILON) {
+          distanceFromEnd = 0;
+        }
+        var DEFAULT_THRESHOLD_PX = 2;
+        var startThreshold = onStartReachedThreshold != null ? onStartReachedThreshold * visibleLength : DEFAULT_THRESHOLD_PX;
+        var endThreshold = onEndReachedThreshold != null ? onEndReachedThreshold * visibleLength : DEFAULT_THRESHOLD_PX;
+        var isWithinStartThreshold = distanceFromStart <= startThreshold;
+        var isWithinEndThreshold = distanceFromEnd <= endThreshold;
+        if (onEndReached && this.state.cellsAroundViewport.last === getItemCount(data) - 1 && isWithinEndThreshold && this._listMetrics.getContentLength() !== this._sentEndForContentLength) {
+          this._sentEndForContentLength = this._listMetrics.getContentLength();
+          onEndReached({
+            distanceFromEnd: distanceFromEnd
+          });
+        }
+        if (onStartReached != null && this.state.cellsAroundViewport.first === 0 && isWithinStartThreshold && this._listMetrics.getContentLength() !== this._sentStartForContentLength) {
+          this._sentStartForContentLength = this._listMetrics.getContentLength();
+          onStartReached({
+            distanceFromStart: distanceFromStart
+          });
+        }
+        if (!isWithinStartThreshold) {
+          this._sentStartForContentLength = 0;
+        }
+        if (!isWithinEndThreshold) {
+          this._sentEndForContentLength = 0;
+        }
+      }
+    }, {
+      key: "_maybeScrollToInitialScrollIndex",
+      value: function _maybeScrollToInitialScrollIndex(contentWidth, contentHeight) {
+        if (contentWidth > 0 && contentHeight > 0 && this.props.initialScrollIndex != null && this.props.initialScrollIndex > 0 && !this._hasTriggeredInitialScrollToIndex) {
+          if (this.props.contentOffset == null) {
+            if (this.props.initialScrollIndex < this.props.getItemCount(this.props.data)) {
+              this.scrollToIndex({
+                animated: false,
+                index: (0, _nullthrows.default)(this.props.initialScrollIndex)
+              });
+            } else {
+              this.scrollToEnd({
+                animated: false
+              });
+            }
+          }
+          this._hasTriggeredInitialScrollToIndex = true;
+        }
+      }
+    }, {
+      key: "unstable_onScroll",
+      value: function unstable_onScroll(e) {
+        this._onScroll(e);
+      }
+    }, {
+      key: "_offsetFromScrollEvent",
+      value: function _offsetFromScrollEvent(e) {
+        var _e$nativeEvent = e.nativeEvent,
+          contentOffset = _e$nativeEvent.contentOffset,
+          contentSize = _e$nativeEvent.contentSize,
+          layoutMeasurement = _e$nativeEvent.layoutMeasurement;
+        var _this$_orientation3 = this._orientation(),
+          horizontal = _this$_orientation3.horizontal,
+          rtl = _this$_orientation3.rtl;
+        if (horizontal && rtl) {
+          return this._selectLength(contentSize) - (this._selectOffset(contentOffset) + this._selectLength(layoutMeasurement));
+        } else {
+          return this._selectOffset(contentOffset);
+        }
+      }
+    }, {
+      key: "_scheduleCellsToRenderUpdate",
+      value: function _scheduleCellsToRenderUpdate() {
+        var _this7 = this;
+        if ((this._listMetrics.getAverageCellLength() > 0 || this.props.getItemLayout != null) && this._shouldRenderWithPriority() && !this._hiPriInProgress) {
+          this._hiPriInProgress = true;
+          if (this._updateCellsToRenderTimeoutID != null) {
+            clearTimeout(this._updateCellsToRenderTimeoutID);
+            this._updateCellsToRenderTimeoutID = null;
+          }
+          this._updateCellsToRender();
+          return;
+        } else {
+          if (this._updateCellsToRenderTimeoutID == null) {
+            var _this$props$updateCel;
+            this._updateCellsToRenderTimeoutID = setTimeout(function () {
+              _this7._updateCellsToRenderTimeoutID = null;
+              _this7._updateCellsToRender();
+            }, (_this$props$updateCel = this.props.updateCellsBatchingPeriod) != null ? _this$props$updateCel : 50);
+          }
+        }
+      }
+    }, {
+      key: "_shouldRenderWithPriority",
+      value: function _shouldRenderWithPriority() {
+        var _this$state$cellsArou = this.state.cellsAroundViewport,
+          first = _this$state$cellsArou.first,
+          last = _this$state$cellsArou.last;
+        var _this$_scrollMetrics3 = this._scrollMetrics,
+          offset = _this$_scrollMetrics3.offset,
+          visibleLength = _this$_scrollMetrics3.visibleLength,
+          velocity = _this$_scrollMetrics3.velocity;
+        var itemCount = this.props.getItemCount(this.props.data);
+        var hiPri = false;
+        var onStartReachedThreshold = (0, _$$_REQUIRE(_dependencyMap[23], "./VirtualizedListProps").onStartReachedThresholdOrDefault)(this.props.onStartReachedThreshold);
+        var onEndReachedThreshold = (0, _$$_REQUIRE(_dependencyMap[23], "./VirtualizedListProps").onEndReachedThresholdOrDefault)(this.props.onEndReachedThreshold);
+        if (first > 0) {
+          var distTop = offset - this._listMetrics.getCellMetricsApprox(first, this.props).offset;
+          hiPri = distTop < 0 || velocity < -2 && distTop < getScrollingThreshold(onStartReachedThreshold, visibleLength);
+        }
+        if (!hiPri && last >= 0 && last < itemCount - 1) {
+          var distBottom = this._listMetrics.getCellMetricsApprox(last, this.props).offset - (offset + visibleLength);
+          hiPri = distBottom < 0 || velocity > 2 && distBottom < getScrollingThreshold(onEndReachedThreshold, visibleLength);
+        }
+        return hiPri;
+      }
+    }, {
+      key: "unstable_onScrollBeginDrag",
+      value: function unstable_onScrollBeginDrag(e) {
+        this._onScrollBeginDrag(e);
+      }
+    }, {
+      key: "unstable_onScrollEndDrag",
+      value: function unstable_onScrollEndDrag(e) {
+        this._onScrollEndDrag(e);
+      }
+    }, {
+      key: "unstable_onMomentumScrollBegin",
+      value: function unstable_onMomentumScrollBegin(e) {
+        this._onMomentumScrollBegin(e);
+      }
+    }, {
+      key: "unstable_onMomentumScrollEnd",
+      value: function unstable_onMomentumScrollEnd(e) {
+        this._onMomentumScrollEnd(e);
+      }
+    }, {
+      key: "__getListMetrics",
+      value: function __getListMetrics() {
+        return this._listMetrics;
+      }
+    }, {
+      key: "_updateViewableItems",
+      value: function _updateViewableItems(props, cellsAroundViewport) {
+        var _this8 = this;
+        if (this.state.pendingScrollUpdateCount > 0) {
+          return;
+        }
+        this._viewabilityTuples.forEach(function (tuple) {
+          tuple.viewabilityHelper.onUpdate(props, _this8._scrollMetrics.offset, _this8._scrollMetrics.visibleLength, _this8._listMetrics, _this8._createViewToken, tuple.onViewableItemsChanged, cellsAroundViewport);
+        });
+      }
+    }], [{
+      key: "_findItemIndexWithKey",
+      value: function _findItemIndexWithKey(props, key, hint) {
+        var itemCount = props.getItemCount(props.data);
+        if (hint != null && hint >= 0 && hint < itemCount) {
+          var curKey = VirtualizedList._getItemKey(props, hint);
+          if (curKey === key) {
+            return hint;
+          }
+        }
+        for (var ii = 0; ii < itemCount; ii++) {
+          var _curKey = VirtualizedList._getItemKey(props, ii);
+          if (_curKey === key) {
+            return ii;
+          }
+        }
+        return null;
+      }
+    }, {
+      key: "_getItemKey",
+      value: function _getItemKey(props, index) {
+        var item = props.getItem(props.data, index);
+        return VirtualizedList._keyExtractor(item, index, props);
+      }
+    }, {
+      key: "_createRenderMask",
+      value: function _createRenderMask(props, cellsAroundViewport, additionalRegions) {
+        var itemCount = props.getItemCount(props.data);
+        (0, _invariant.default)(cellsAroundViewport.first >= 0 && cellsAroundViewport.last >= cellsAroundViewport.first - 1 && cellsAroundViewport.last < itemCount, `Invalid cells around viewport "[${cellsAroundViewport.first}, ${cellsAroundViewport.last}]" was passed to VirtualizedList._createRenderMask`);
+        var renderMask = new (_$$_REQUIRE(_dependencyMap[26], "./CellRenderMask").CellRenderMask)(itemCount);
+        if (itemCount > 0) {
+          var allRegions = [cellsAroundViewport].concat((0, _toConsumableArray2.default)(additionalRegions != null ? additionalRegions : []));
+          for (var region of allRegions) {
+            renderMask.addCells(region);
+          }
+          if (props.initialScrollIndex == null || props.initialScrollIndex <= 0) {
+            var initialRegion = VirtualizedList._initialRenderRegion(props);
+            renderMask.addCells(initialRegion);
+          }
+          var stickyIndicesSet = new Set(props.stickyHeaderIndices);
+          VirtualizedList._ensureClosestStickyHeader(props, stickyIndicesSet, renderMask, cellsAroundViewport.first);
+        }
+        return renderMask;
+      }
+    }, {
+      key: "_initialRenderRegion",
+      value: function _initialRenderRegion(props) {
+        var _props$initialScrollI;
+        var itemCount = props.getItemCount(props.data);
+        var firstCellIndex = Math.max(0, Math.min(itemCount - 1, Math.floor((_props$initialScrollI = props.initialScrollIndex) != null ? _props$initialScrollI : 0)));
+        var lastCellIndex = Math.min(itemCount, firstCellIndex + (0, _$$_REQUIRE(_dependencyMap[23], "./VirtualizedListProps").initialNumToRenderOrDefault)(props.initialNumToRender)) - 1;
+        return {
+          first: firstCellIndex,
+          last: lastCellIndex
+        };
+      }
+    }, {
+      key: "_ensureClosestStickyHeader",
+      value: function _ensureClosestStickyHeader(props, stickyIndicesSet, renderMask, cellIdx) {
+        var stickyOffset = props.ListHeaderComponent ? 1 : 0;
+        for (var itemIdx = cellIdx - 1; itemIdx >= 0; itemIdx--) {
+          if (stickyIndicesSet.has(itemIdx + stickyOffset)) {
+            renderMask.addCells({
+              first: itemIdx,
+              last: itemIdx
+            });
+            break;
+          }
+        }
+      }
+    }, {
+      key: "getDerivedStateFromProps",
+      value: function getDerivedStateFromProps(newProps, prevState) {
+        var _newProps$maintainVis, _newProps$maintainVis2;
+        var itemCount = newProps.getItemCount(newProps.data);
+        if (itemCount === prevState.renderMask.numCells()) {
+          return prevState;
+        }
+        var maintainVisibleContentPositionAdjustment = null;
+        var prevFirstVisibleItemKey = prevState.firstVisibleItemKey;
+        var minIndexForVisible = (_newProps$maintainVis = (_newProps$maintainVis2 = newProps.maintainVisibleContentPosition) == null ? void 0 : _newProps$maintainVis2.minIndexForVisible) != null ? _newProps$maintainVis : 0;
+        var newFirstVisibleItemKey = newProps.getItemCount(newProps.data) > minIndexForVisible ? VirtualizedList._getItemKey(newProps, minIndexForVisible) : null;
+        if (newProps.maintainVisibleContentPosition != null && prevFirstVisibleItemKey != null && newFirstVisibleItemKey != null) {
+          if (newFirstVisibleItemKey !== prevFirstVisibleItemKey) {
+            var hint = itemCount - prevState.renderMask.numCells() + minIndexForVisible;
+            var firstVisibleItemIndex = VirtualizedList._findItemIndexWithKey(newProps, prevFirstVisibleItemKey, hint);
+            maintainVisibleContentPositionAdjustment = firstVisibleItemIndex != null ? firstVisibleItemIndex - minIndexForVisible : null;
+          } else {
+            maintainVisibleContentPositionAdjustment = null;
+          }
+        }
+        var constrainedCells = VirtualizedList._constrainToItemCount(maintainVisibleContentPositionAdjustment != null ? {
+          first: prevState.cellsAroundViewport.first + maintainVisibleContentPositionAdjustment,
+          last: prevState.cellsAroundViewport.last + maintainVisibleContentPositionAdjustment
+        } : prevState.cellsAroundViewport, newProps);
+        return {
+          cellsAroundViewport: constrainedCells,
+          renderMask: VirtualizedList._createRenderMask(newProps, constrainedCells),
+          firstVisibleItemKey: newFirstVisibleItemKey,
+          pendingScrollUpdateCount: maintainVisibleContentPositionAdjustment != null ? prevState.pendingScrollUpdateCount + 1 : prevState.pendingScrollUpdateCount
+        };
+      }
+    }, {
+      key: "_constrainToItemCount",
+      value: function _constrainToItemCount(cells, props) {
+        var itemCount = props.getItemCount(props.data);
+        var lastPossibleCellIndex = itemCount - 1;
+        var maxToRenderPerBatch = (0, _$$_REQUIRE(_dependencyMap[23], "./VirtualizedListProps").maxToRenderPerBatchOrDefault)(props.maxToRenderPerBatch);
+        var maxFirst = Math.max(0, lastPossibleCellIndex - maxToRenderPerBatch);
+        return {
+          first: (0, _clamp.default)(0, cells.first, maxFirst),
+          last: Math.min(lastPossibleCellIndex, cells.last)
+        };
+      }
+    }, {
+      key: "_keyExtractor",
+      value: function _keyExtractor(item, index, props) {
+        if (props.keyExtractor != null) {
+          return props.keyExtractor(item, index);
+        }
+        var key = (0, _$$_REQUIRE(_dependencyMap[24], "./VirtualizeUtils").keyExtractor)(item, index);
+        if (key === String(index)) {
+          _usedIndexForKey = true;
+          if (item.type && item.type.displayName) {
+            _keylessItemComponentName = item.type.displayName;
+          }
+        }
+        return key;
+      }
+    }]);
+  }(_StateSafePureComponent.default);
+  VirtualizedList.contextType = _$$_REQUIRE(_dependencyMap[25], "./VirtualizedListContext.js").VirtualizedListContext;
+  var styles = _reactNative.StyleSheet.create({
+    verticallyInverted: _reactNative.Platform.OS === 'android' ? {
+      transform: [{
+        scale: -1
+      }]
+    } : {
+      transform: [{
+        scaleY: -1
+      }]
+    },
+    horizontallyInverted: {
+      transform: [{
+        scaleX: -1
+      }]
+    },
+    debug: {
+      flex: 1
+    },
+    debugOverlayBase: {
+      position: 'absolute',
+      top: 0,
+      right: 0
+    },
+    debugOverlay: {
+      bottom: 0,
+      width: 20,
+      borderColor: 'blue',
+      borderWidth: 1
+    },
+    debugOverlayFrame: {
+      left: 0,
+      backgroundColor: 'orange'
+    },
+    debugOverlayFrameLast: {
+      left: 0,
+      borderColor: 'green',
+      borderWidth: 2
+    },
+    debugOverlayFrameVis: {
+      left: 0,
+      borderColor: 'red',
+      borderWidth: 2
+    }
+  });
+  var _default = exports.default = VirtualizedList;
+},449,[1,42,65,4,11,12,18,20,23,450,451,452,453,454,455,456,457,32,80,73,2,52,171,459,448,458,460],"../../node_modules/@react-native/virtualized-lists/Lists/VirtualizedList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  function clamp(min, value, max) {
+    if (value < min) {
+      return min;
+    }
+    if (value > max) {
+      return max;
+    }
+    return value;
+  }
+  var _default = exports.default = clamp;
+},450,[],"../../node_modules/@react-native/virtualized-lists/Utilities/clamp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  function infoLog() {
+    var _console;
+    return (_console = console).log.apply(_console, arguments);
+  }
+  var _default = exports.default = infoLog;
+},451,[],"../../node_modules/@react-native/virtualized-lists/Utilities/infoLog.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "invariant"));
+  var ChildListCollection = exports.default = /*#__PURE__*/function () {
+    function ChildListCollection() {
+      (0, _classCallCheck2.default)(this, ChildListCollection);
+      this._cellKeyToChildren = new Map();
+      this._childrenToCellKey = new Map();
+    }
+    return (0, _createClass2.default)(ChildListCollection, [{
+      key: "add",
+      value: function add(list, cellKey) {
+        var _this$_cellKeyToChild;
+        (0, _invariant.default)(!this._childrenToCellKey.has(list), 'Trying to add already present child list');
+        var cellLists = (_this$_cellKeyToChild = this._cellKeyToChildren.get(cellKey)) != null ? _this$_cellKeyToChild : new Set();
+        cellLists.add(list);
+        this._cellKeyToChildren.set(cellKey, cellLists);
+        this._childrenToCellKey.set(list, cellKey);
+      }
+    }, {
+      key: "remove",
+      value: function remove(list) {
+        var cellKey = this._childrenToCellKey.get(list);
+        (0, _invariant.default)(cellKey != null, 'Trying to remove non-present child list');
+        this._childrenToCellKey.delete(list);
+        var cellLists = this._cellKeyToChildren.get(cellKey);
+        (0, _invariant.default)(cellLists, '_cellKeyToChildren should contain cellKey');
+        cellLists.delete(list);
+        if (cellLists.size === 0) {
+          this._cellKeyToChildren.delete(cellKey);
+        }
+      }
+    }, {
+      key: "forEach",
+      value: function forEach(fn) {
+        for (var listSet of this._cellKeyToChildren.values()) {
+          for (var list of listSet) {
+            fn(list);
+          }
+        }
+      }
+    }, {
+      key: "forEachInCell",
+      value: function forEachInCell(cellKey, fn) {
+        var _this$_cellKeyToChild2;
+        var listSet = (_this$_cellKeyToChild2 = this._cellKeyToChildren.get(cellKey)) != null ? _this$_cellKeyToChild2 : [];
+        for (var list of listSet) {
+          fn(list);
+        }
+      }
+    }, {
+      key: "anyInCell",
+      value: function anyInCell(cellKey, fn) {
+        var _this$_cellKeyToChild3;
+        var listSet = (_this$_cellKeyToChild3 = this._cellKeyToChildren.get(cellKey)) != null ? _this$_cellKeyToChild3 : [];
+        for (var list of listSet) {
+          if (fn(list)) {
+            return true;
+          }
+        }
+        return false;
+      }
+    }, {
+      key: "size",
+      value: function size() {
+        return this._childrenToCellKey.size;
+      }
+    }]);
+  }();
+},452,[1,11,12,32],"../../node_modules/@react-native/virtualized-lists/Lists/ChildListCollection.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _ListMetricsAggregator = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./ListMetricsAggregator"));
+  var Info = /*#__PURE__*/(0, _createClass2.default)(function Info() {
+    (0, _classCallCheck2.default)(this, Info);
+    this.any_blank_count = 0;
+    this.any_blank_ms = 0;
+    this.any_blank_speed_sum = 0;
+    this.mostly_blank_count = 0;
+    this.mostly_blank_ms = 0;
+    this.pixels_blank = 0;
+    this.pixels_sampled = 0;
+    this.pixels_scrolled = 0;
+    this.total_time_spent = 0;
+    this.sample_count = 0;
+  });
+  var DEBUG = false;
+  var _listeners = [];
+  var _minSampleCount = 10;
+  var _sampleRate = DEBUG ? 1 : null;
+  var FillRateHelper = /*#__PURE__*/function () {
+    function FillRateHelper(listMetrics) {
+      (0, _classCallCheck2.default)(this, FillRateHelper);
+      this._anyBlankStartTime = null;
+      this._enabled = false;
+      this._info = new Info();
+      this._mostlyBlankStartTime = null;
+      this._samplesStartTime = null;
+      this._listMetrics = listMetrics;
+      this._enabled = (_sampleRate || 0) > Math.random();
+      this._resetData();
+    }
+    return (0, _createClass2.default)(FillRateHelper, [{
+      key: "activate",
+      value: function activate() {
+        if (this._enabled && this._samplesStartTime == null) {
+          DEBUG && console.debug('FillRateHelper: activate');
+          this._samplesStartTime = global.performance.now();
+        }
+      }
+    }, {
+      key: "deactivateAndFlush",
+      value: function deactivateAndFlush() {
+        if (!this._enabled) {
+          return;
+        }
+        var start = this._samplesStartTime;
+        if (start == null) {
+          DEBUG && console.debug('FillRateHelper: bail on deactivate with no start time');
+          return;
+        }
+        if (this._info.sample_count < _minSampleCount) {
+          this._resetData();
+          return;
+        }
+        var total_time_spent = global.performance.now() - start;
+        var info = Object.assign({}, this._info, {
+          total_time_spent: total_time_spent
+        });
+        if (DEBUG) {
+          var derived = {
+            avg_blankness: this._info.pixels_blank / this._info.pixels_sampled,
+            avg_speed: this._info.pixels_scrolled / (total_time_spent / 1000),
+            avg_speed_when_any_blank: this._info.any_blank_speed_sum / this._info.any_blank_count,
+            any_blank_per_min: this._info.any_blank_count / (total_time_spent / 1000 / 60),
+            any_blank_time_frac: this._info.any_blank_ms / total_time_spent,
+            mostly_blank_per_min: this._info.mostly_blank_count / (total_time_spent / 1000 / 60),
+            mostly_blank_time_frac: this._info.mostly_blank_ms / total_time_spent
+          };
+          for (var key in derived) {
+            derived[key] = Math.round(1000 * derived[key]) / 1000;
+          }
+          console.debug('FillRateHelper deactivateAndFlush: ', {
+            derived: derived,
+            info: info
+          });
+        }
+        _listeners.forEach(function (listener) {
+          return listener(info);
+        });
+        this._resetData();
+      }
+    }, {
+      key: "computeBlankness",
+      value: function computeBlankness(props, cellsAroundViewport, scrollMetrics) {
+        if (!this._enabled || props.getItemCount(props.data) === 0 || cellsAroundViewport.last < cellsAroundViewport.first || this._samplesStartTime == null) {
+          return 0;
+        }
+        var dOffset = scrollMetrics.dOffset,
+          offset = scrollMetrics.offset,
+          velocity = scrollMetrics.velocity,
+          visibleLength = scrollMetrics.visibleLength;
+        this._info.sample_count++;
+        this._info.pixels_sampled += Math.round(visibleLength);
+        this._info.pixels_scrolled += Math.round(Math.abs(dOffset));
+        var scrollSpeed = Math.round(Math.abs(velocity) * 1000);
+        var now = global.performance.now();
+        if (this._anyBlankStartTime != null) {
+          this._info.any_blank_ms += now - this._anyBlankStartTime;
+        }
+        this._anyBlankStartTime = null;
+        if (this._mostlyBlankStartTime != null) {
+          this._info.mostly_blank_ms += now - this._mostlyBlankStartTime;
+        }
+        this._mostlyBlankStartTime = null;
+        var blankTop = 0;
+        var first = cellsAroundViewport.first;
+        var firstFrame = this._listMetrics.getCellMetrics(first, props);
+        while (first <= cellsAroundViewport.last && (!firstFrame || !firstFrame.isMounted)) {
+          firstFrame = this._listMetrics.getCellMetrics(first, props);
+          first++;
+        }
+        if (firstFrame && first > 0) {
+          blankTop = Math.min(visibleLength, Math.max(0, firstFrame.offset - offset));
+        }
+        var blankBottom = 0;
+        var last = cellsAroundViewport.last;
+        var lastFrame = this._listMetrics.getCellMetrics(last, props);
+        while (last >= cellsAroundViewport.first && (!lastFrame || !lastFrame.isMounted)) {
+          lastFrame = this._listMetrics.getCellMetrics(last, props);
+          last--;
+        }
+        if (lastFrame && last < props.getItemCount(props.data) - 1) {
+          var bottomEdge = lastFrame.offset + lastFrame.length;
+          blankBottom = Math.min(visibleLength, Math.max(0, offset + visibleLength - bottomEdge));
+        }
+        var pixels_blank = Math.round(blankTop + blankBottom);
+        var blankness = pixels_blank / visibleLength;
+        if (blankness > 0) {
+          this._anyBlankStartTime = now;
+          this._info.any_blank_speed_sum += scrollSpeed;
+          this._info.any_blank_count++;
+          this._info.pixels_blank += pixels_blank;
+          if (blankness > 0.5) {
+            this._mostlyBlankStartTime = now;
+            this._info.mostly_blank_count++;
+          }
+        } else if (scrollSpeed < 0.01 || Math.abs(dOffset) < 1) {
+          this.deactivateAndFlush();
+        }
+        return blankness;
+      }
+    }, {
+      key: "enabled",
+      value: function enabled() {
+        return this._enabled;
+      }
+    }, {
+      key: "_resetData",
+      value: function _resetData() {
+        this._anyBlankStartTime = null;
+        this._info = new Info();
+        this._mostlyBlankStartTime = null;
+        this._samplesStartTime = null;
+      }
+    }], [{
+      key: "addListener",
+      value: function addListener(callback) {
+        if (_sampleRate === null) {
+          console.warn('Call `FillRateHelper.setSampleRate` before `addListener`.');
+        }
+        _listeners.push(callback);
+        return {
+          remove: function remove() {
+            _listeners = _listeners.filter(function (listener) {
+              return callback !== listener;
+            });
+          }
+        };
+      }
+    }, {
+      key: "setSampleRate",
+      value: function setSampleRate(sampleRate) {
+        _sampleRate = sampleRate;
+      }
+    }, {
+      key: "setMinSampleCount",
+      value: function setMinSampleCount(minSampleCount) {
+        _minSampleCount = minSampleCount;
+      }
+    }]);
+  }();
+  var _default = exports.default = FillRateHelper;
+},453,[1,12,11,454],"../../node_modules/@react-native/virtualized-lists/Lists/FillRateHelper.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "invariant"));
+  var ListMetricsAggregator = exports.default = /*#__PURE__*/function () {
+    function ListMetricsAggregator() {
+      (0, _classCallCheck2.default)(this, ListMetricsAggregator);
+      this._averageCellLength = 0;
+      this._cellMetrics = new Map();
+      this._highestMeasuredCellIndex = 0;
+      this._measuredCellsLength = 0;
+      this._measuredCellsCount = 0;
+      this._orientation = {
+        horizontal: false,
+        rtl: false
+      };
+    }
+    return (0, _createClass2.default)(ListMetricsAggregator, [{
+      key: "notifyCellLayout",
+      value: function notifyCellLayout(_ref) {
+        var cellIndex = _ref.cellIndex,
+          cellKey = _ref.cellKey,
+          orientation = _ref.orientation,
+          layout = _ref.layout;
+        this._invalidateIfOrientationChanged(orientation);
+        var next = {
+          index: cellIndex,
+          length: this._selectLength(layout),
+          isMounted: true,
+          offset: this.flowRelativeOffset(layout)
+        };
+        var curr = this._cellMetrics.get(cellKey);
+        if (!curr || next.offset !== curr.offset || next.length !== curr.length) {
+          if (curr) {
+            var dLength = next.length - curr.length;
+            this._measuredCellsLength += dLength;
+          } else {
+            this._measuredCellsLength += next.length;
+            this._measuredCellsCount += 1;
+          }
+          this._averageCellLength = this._measuredCellsLength / this._measuredCellsCount;
+          this._cellMetrics.set(cellKey, next);
+          this._highestMeasuredCellIndex = Math.max(this._highestMeasuredCellIndex, cellIndex);
+          return true;
+        } else {
+          curr.isMounted = true;
+          return false;
+        }
+      }
+    }, {
+      key: "notifyCellUnmounted",
+      value: function notifyCellUnmounted(cellKey) {
+        var curr = this._cellMetrics.get(cellKey);
+        if (curr) {
+          curr.isMounted = false;
+        }
+      }
+    }, {
+      key: "notifyListContentLayout",
+      value: function notifyListContentLayout(_ref2) {
+        var orientation = _ref2.orientation,
+          layout = _ref2.layout;
+        this._invalidateIfOrientationChanged(orientation);
+        this._contentLength = this._selectLength(layout);
+      }
+    }, {
+      key: "getAverageCellLength",
+      value: function getAverageCellLength() {
+        return this._averageCellLength;
+      }
+    }, {
+      key: "getHighestMeasuredCellIndex",
+      value: function getHighestMeasuredCellIndex() {
+        return this._highestMeasuredCellIndex;
+      }
+    }, {
+      key: "getCellMetricsApprox",
+      value: function getCellMetricsApprox(index, props) {
+        var frame = this.getCellMetrics(index, props);
+        if (frame && frame.index === index) {
+          return frame;
+        } else {
+          var offset;
+          var highestMeasuredCellIndex = this.getHighestMeasuredCellIndex();
+          if (highestMeasuredCellIndex < index) {
+            var highestMeasuredCellFrame = this.getCellMetrics(highestMeasuredCellIndex, props);
+            if (highestMeasuredCellFrame) {
+              offset = highestMeasuredCellFrame.offset + highestMeasuredCellFrame.length + this._averageCellLength * (index - highestMeasuredCellIndex - 1);
+            }
+          }
+          if (offset == null) {
+            offset = this._averageCellLength * index;
+          }
+          var data = props.data,
+            getItemCount = props.getItemCount;
+          (0, _invariant.default)(index >= 0 && index < getItemCount(data), 'Tried to get frame for out of range index ' + index);
+          return {
+            length: this._averageCellLength,
+            offset: offset,
+            index: index,
+            isMounted: false
+          };
+        }
+      }
+    }, {
+      key: "getCellMetrics",
+      value: function getCellMetrics(index, props) {
+        var _props$keyExtractor;
+        var data = props.data,
+          getItem = props.getItem,
+          getItemCount = props.getItemCount,
+          getItemLayout = props.getItemLayout;
+        (0, _invariant.default)(index >= 0 && index < getItemCount(data), 'Tried to get metrics for out of range cell index ' + index);
+        var keyExtractor = (_props$keyExtractor = props.keyExtractor) != null ? _props$keyExtractor : _$$_REQUIRE(_dependencyMap[4], "./VirtualizeUtils").keyExtractor;
+        var frame = this._cellMetrics.get(keyExtractor(getItem(data, index), index));
+        if (frame && frame.index === index) {
+          return frame;
+        }
+        if (getItemLayout) {
+          var _getItemLayout = getItemLayout(data, index),
+            length = _getItemLayout.length,
+            offset = _getItemLayout.offset;
+          return {
+            index: index,
+            length: length,
+            offset: offset,
+            isMounted: true
+          };
+        }
+        return null;
+      }
+    }, {
+      key: "getCellOffsetApprox",
+      value: function getCellOffsetApprox(index, props) {
+        if (Number.isInteger(index)) {
+          return this.getCellMetricsApprox(index, props).offset;
+        } else {
+          var frameMetrics = this.getCellMetricsApprox(Math.floor(index), props);
+          var remainder = index - Math.floor(index);
+          return frameMetrics.offset + remainder * frameMetrics.length;
+        }
+      }
+    }, {
+      key: "getContentLength",
+      value: function getContentLength() {
+        var _this$_contentLength;
+        return (_this$_contentLength = this._contentLength) != null ? _this$_contentLength : 0;
+      }
+    }, {
+      key: "hasContentLength",
+      value: function hasContentLength() {
+        return this._contentLength != null;
+      }
+    }, {
+      key: "flowRelativeOffset",
+      value: function flowRelativeOffset(layout, referenceContentLength) {
+        var _this$_orientation = this._orientation,
+          horizontal = _this$_orientation.horizontal,
+          rtl = _this$_orientation.rtl;
+        if (horizontal && rtl) {
+          var contentLength = referenceContentLength != null ? referenceContentLength : this._contentLength;
+          (0, _invariant.default)(contentLength != null, 'ListMetricsAggregator must be notified of list content layout before resolving offsets');
+          return contentLength - (this._selectOffset(layout) + this._selectLength(layout));
+        } else {
+          return this._selectOffset(layout);
+        }
+      }
+    }, {
+      key: "cartesianOffset",
+      value: function cartesianOffset(flowRelativeOffset) {
+        var _this$_orientation2 = this._orientation,
+          horizontal = _this$_orientation2.horizontal,
+          rtl = _this$_orientation2.rtl;
+        if (horizontal && rtl) {
+          (0, _invariant.default)(this._contentLength != null, 'ListMetricsAggregator must be notified of list content layout before resolving offsets');
+          return this._contentLength - flowRelativeOffset;
+        } else {
+          return flowRelativeOffset;
+        }
+      }
+    }, {
+      key: "_invalidateIfOrientationChanged",
+      value: function _invalidateIfOrientationChanged(orientation) {
+        if (orientation.rtl !== this._orientation.rtl) {
+          this._cellMetrics.clear();
+        }
+        if (orientation.horizontal !== this._orientation.horizontal) {
+          this._averageCellLength = 0;
+          this._highestMeasuredCellIndex = 0;
+          this._measuredCellsLength = 0;
+          this._measuredCellsCount = 0;
+        }
+        this._orientation = orientation;
+      }
+    }, {
+      key: "_selectLength",
+      value: function _selectLength(_ref3) {
+        var width = _ref3.width,
+          height = _ref3.height;
+        return this._orientation.horizontal ? width : height;
+      }
+    }, {
+      key: "_selectOffset",
+      value: function _selectOffset(_ref4) {
+        var x = _ref4.x,
+          y = _ref4.y;
+        return this._orientation.horizontal ? x : y;
+      }
+    }]);
+  }();
+},454,[1,11,12,32,448],"../../node_modules/@react-native/virtualized-lists/Lists/ListMetricsAggregator.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "invariant"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[8], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  function _superPropGet(t, o, e, r) { var p = (0, _get2.default)((0, _getPrototypeOf2.default)(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+  var StateSafePureComponent = exports.default = /*#__PURE__*/function (_React$PureComponent) {
+    function StateSafePureComponent(props) {
+      var _this;
+      (0, _classCallCheck2.default)(this, StateSafePureComponent);
+      _this = _callSuper(this, StateSafePureComponent, [props]);
+      _this._inAsyncStateUpdate = false;
+      _this._installSetStateHooks();
+      return _this;
+    }
+    (0, _inherits2.default)(StateSafePureComponent, _React$PureComponent);
+    return (0, _createClass2.default)(StateSafePureComponent, [{
+      key: "setState",
+      value: function setState(partialState, callback) {
+        var _this2 = this;
+        if (typeof partialState === 'function') {
+          _superPropGet(StateSafePureComponent, "setState", this, 3)([function (state, props) {
+            _this2._inAsyncStateUpdate = true;
+            var ret;
+            try {
+              ret = partialState(state, props);
+            } catch (err) {
+              throw err;
+            } finally {
+              _this2._inAsyncStateUpdate = false;
+            }
+            return ret;
+          }, callback]);
+        } else {
+          _superPropGet(StateSafePureComponent, "setState", this, 3)([partialState, callback]);
+        }
+      }
+    }, {
+      key: "_installSetStateHooks",
+      value: function _installSetStateHooks() {
+        var that = this;
+        var props = this.props,
+          state = this.state;
+        Object.defineProperty(this, 'props', {
+          get: function get() {
+            (0, _invariant.default)(!that._inAsyncStateUpdate, '"this.props" should not be accessed during state updates');
+            return props;
+          },
+          set: function set(newProps) {
+            props = newProps;
+          }
+        });
+        Object.defineProperty(this, 'state', {
+          get: function get() {
+            (0, _invariant.default)(!that._inAsyncStateUpdate, '"this.state" should not be acceessed during state updates');
+            return state;
+          },
+          set: function set(newState) {
+            state = newState;
+          }
+        });
+      }
+    }]);
+  }(React.PureComponent);
+},455,[1,11,12,18,20,21,23,32,73],"../../node_modules/@react-native/virtualized-lists/Lists/StateSafePureComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+  var _ListMetricsAggregator = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./ListMetricsAggregator"));
+  var ViewabilityHelper = /*#__PURE__*/function () {
+    function ViewabilityHelper() {
+      var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+        viewAreaCoveragePercentThreshold: 0
+      };
+      (0, _classCallCheck2.default)(this, ViewabilityHelper);
+      this._hasInteracted = false;
+      this._timers = new Set();
+      this._viewableIndices = [];
+      this._viewableItems = new Map();
+      this._config = config;
+    }
+    return (0, _createClass2.default)(ViewabilityHelper, [{
+      key: "dispose",
+      value: function dispose() {
+        this._timers.forEach(clearTimeout);
+      }
+    }, {
+      key: "computeViewableItems",
+      value: function computeViewableItems(props, scrollOffset, viewportHeight, listMetrics, renderRange) {
+        var itemCount = props.getItemCount(props.data);
+        var _this$_config = this._config,
+          itemVisiblePercentThreshold = _this$_config.itemVisiblePercentThreshold,
+          viewAreaCoveragePercentThreshold = _this$_config.viewAreaCoveragePercentThreshold;
+        var viewAreaMode = viewAreaCoveragePercentThreshold != null;
+        var viewablePercentThreshold = viewAreaMode ? viewAreaCoveragePercentThreshold : itemVisiblePercentThreshold;
+        _$$_REQUIRE(_dependencyMap[5], "invariant")(viewablePercentThreshold != null && itemVisiblePercentThreshold != null !== (viewAreaCoveragePercentThreshold != null), 'Must set exactly one of itemVisiblePercentThreshold or viewAreaCoveragePercentThreshold');
+        var viewableIndices = [];
+        if (itemCount === 0) {
+          return viewableIndices;
+        }
+        var firstVisible = -1;
+        var _ref = renderRange || {
+            first: 0,
+            last: itemCount - 1
+          },
+          first = _ref.first,
+          last = _ref.last;
+        if (last >= itemCount) {
+          console.warn('Invalid render range computing viewability ' + JSON.stringify({
+            renderRange: renderRange,
+            itemCount: itemCount
+          }));
+          return [];
+        }
+        for (var idx = first; idx <= last; idx++) {
+          var metrics = listMetrics.getCellMetrics(idx, props);
+          if (!metrics) {
+            continue;
+          }
+          var top = Math.floor(metrics.offset - scrollOffset);
+          var bottom = Math.floor(top + metrics.length);
+          if (top < viewportHeight && bottom > 0) {
+            firstVisible = idx;
+            if (_isViewable(viewAreaMode, viewablePercentThreshold, top, bottom, viewportHeight, metrics.length)) {
+              viewableIndices.push(idx);
+            }
+          } else if (firstVisible >= 0) {
+            break;
+          }
+        }
+        return viewableIndices;
+      }
+    }, {
+      key: "onUpdate",
+      value: function onUpdate(props, scrollOffset, viewportHeight, listMetrics, createViewToken, onViewableItemsChanged, renderRange) {
+        var _this = this;
+        var itemCount = props.getItemCount(props.data);
+        if (this._config.waitForInteraction && !this._hasInteracted || itemCount === 0 || !listMetrics.getCellMetrics(0, props)) {
+          return;
+        }
+        var viewableIndices = [];
+        if (itemCount) {
+          viewableIndices = this.computeViewableItems(props, scrollOffset, viewportHeight, listMetrics, renderRange);
+        }
+        if (this._viewableIndices.length === viewableIndices.length && this._viewableIndices.every(function (v, ii) {
+          return v === viewableIndices[ii];
+        })) {
+          return;
+        }
+        this._viewableIndices = viewableIndices;
+        if (this._config.minimumViewTime) {
+          var handle = setTimeout(function () {
+            _this._timers.delete(handle);
+            _this._onUpdateSync(props, viewableIndices, onViewableItemsChanged, createViewToken);
+          }, this._config.minimumViewTime);
+          this._timers.add(handle);
+        } else {
+          this._onUpdateSync(props, viewableIndices, onViewableItemsChanged, createViewToken);
+        }
+      }
+    }, {
+      key: "resetViewableIndices",
+      value: function resetViewableIndices() {
+        this._viewableIndices = [];
+      }
+    }, {
+      key: "recordInteraction",
+      value: function recordInteraction() {
+        this._hasInteracted = true;
+      }
+    }, {
+      key: "_onUpdateSync",
+      value: function _onUpdateSync(props, viewableIndicesToCheck, onViewableItemsChanged, createViewToken) {
+        var _this2 = this;
+        viewableIndicesToCheck = viewableIndicesToCheck.filter(function (ii) {
+          return _this2._viewableIndices.includes(ii);
+        });
+        var prevItems = this._viewableItems;
+        var nextItems = new Map(viewableIndicesToCheck.map(function (ii) {
+          var viewable = createViewToken(ii, true, props);
+          return [viewable.key, viewable];
+        }));
+        var changed = [];
+        for (var _ref2 of nextItems) {
+          var _ref3 = (0, _slicedToArray2.default)(_ref2, 2);
+          var key = _ref3[0];
+          var viewable = _ref3[1];
+          if (!prevItems.has(key)) {
+            changed.push(viewable);
+          }
+        }
+        for (var _ref4 of prevItems) {
+          var _ref5 = (0, _slicedToArray2.default)(_ref4, 2);
+          var _key = _ref5[0];
+          var _viewable = _ref5[1];
+          if (!nextItems.has(_key)) {
+            changed.push(Object.assign({}, _viewable, {
+              isViewable: false
+            }));
+          }
+        }
+        if (changed.length > 0) {
+          this._viewableItems = nextItems;
+          onViewableItemsChanged({
+            viewableItems: Array.from(nextItems.values()),
+            changed: changed,
+            viewabilityConfig: this._config
+          });
+        }
+      }
+    }]);
+  }();
+  function _isViewable(viewAreaMode, viewablePercentThreshold, top, bottom, viewportHeight, itemLength) {
+    if (_isEntirelyVisible(top, bottom, viewportHeight)) {
+      return true;
+    } else {
+      var pixels = _getPixelsVisible(top, bottom, viewportHeight);
+      var percent = 100 * (viewAreaMode ? pixels / viewportHeight : pixels / itemLength);
+      return percent >= viewablePercentThreshold;
+    }
+  }
+  function _getPixelsVisible(top, bottom, viewportHeight) {
+    var visibleHeight = Math.min(bottom, viewportHeight) - Math.max(top, 0);
+    return Math.max(0, visibleHeight);
+  }
+  function _isEntirelyVisible(top, bottom, viewportHeight) {
+    return top >= 0 && bottom <= viewportHeight && bottom > top;
+  }
+  var _default = exports.default = ViewabilityHelper;
+},456,[1,34,11,12,454,32],"../../node_modules/@react-native/virtualized-lists/Lists/ViewabilityHelper.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "invariant"));
+  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "react"));
+  var React = _react;
+  var _reactNative = _$$_REQUIRE(_dependencyMap[8], "react-native");
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[9], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/@react-native/virtualized-lists/Lists/VirtualizedListCellRenderer.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var CellRenderer = exports.default = /*#__PURE__*/function (_React$PureComponent) {
+    function CellRenderer() {
+      var _this;
+      (0, _classCallCheck2.default)(this, CellRenderer);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _callSuper(this, CellRenderer, [].concat(args));
+      _this.state = {
+        separatorProps: {
+          highlighted: false,
+          leadingItem: _this.props.item
+        }
+      };
+      _this._separators = {
+        highlight: function highlight() {
+          var _this$props = _this.props,
+            cellKey = _this$props.cellKey,
+            prevCellKey = _this$props.prevCellKey;
+          _this.props.onUpdateSeparators([cellKey, prevCellKey], {
+            highlighted: true
+          });
+        },
+        unhighlight: function unhighlight() {
+          var _this$props2 = _this.props,
+            cellKey = _this$props2.cellKey,
+            prevCellKey = _this$props2.prevCellKey;
+          _this.props.onUpdateSeparators([cellKey, prevCellKey], {
+            highlighted: false
+          });
+        },
+        updateProps: function updateProps(select, newProps) {
+          var _this$props3 = _this.props,
+            cellKey = _this$props3.cellKey,
+            prevCellKey = _this$props3.prevCellKey;
+          _this.props.onUpdateSeparators([select === 'leading' ? prevCellKey : cellKey], newProps);
+        }
+      };
+      _this._onLayout = function (nativeEvent) {
+        _this.props.onCellLayout == null || _this.props.onCellLayout(nativeEvent, _this.props.cellKey, _this.props.index);
+      };
+      _this._onCellFocusCapture = function (e) {
+        _this.props.onCellFocusCapture == null || _this.props.onCellFocusCapture(_this.props.cellKey);
+      };
+      return _this;
+    }
+    (0, _inherits2.default)(CellRenderer, _React$PureComponent);
+    return (0, _createClass2.default)(CellRenderer, [{
+      key: "updateSeparatorProps",
+      value: function updateSeparatorProps(newProps) {
+        this.setState(function (state) {
+          return {
+            separatorProps: Object.assign({}, state.separatorProps, newProps)
+          };
+        });
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        this.props.onUnmount(this.props.cellKey);
+      }
+    }, {
+      key: "_renderElement",
+      value: function _renderElement(renderItem, ListItemComponent, item, index) {
+        if (renderItem && ListItemComponent) {
+          console.warn('VirtualizedList: Both ListItemComponent and renderItem props are present. ListItemComponent will take' + ' precedence over renderItem.');
+        }
+        if (ListItemComponent) {
+          return /*#__PURE__*/(0, _jsxRuntime.jsx)(ListItemComponent, {
+            item: item,
+            index: index,
+            separators: this._separators
+          });
+        }
+        if (renderItem) {
+          return renderItem({
+            item: item,
+            index: index,
+            separators: this._separators
+          });
+        }
+        (0, _invariant.default)(false, 'VirtualizedList: Either ListItemComponent or renderItem props are required but none were found.');
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props4 = this.props,
+          CellRendererComponent = _this$props4.CellRendererComponent,
+          ItemSeparatorComponent = _this$props4.ItemSeparatorComponent,
+          ListItemComponent = _this$props4.ListItemComponent,
+          cellKey = _this$props4.cellKey,
+          horizontal = _this$props4.horizontal,
+          item = _this$props4.item,
+          index = _this$props4.index,
+          inversionStyle = _this$props4.inversionStyle,
+          onCellLayout = _this$props4.onCellLayout,
+          renderItem = _this$props4.renderItem;
+        var element = this._renderElement(renderItem, ListItemComponent, item, index);
+        var itemSeparator = (0, _react.isValidElement)(ItemSeparatorComponent) ? ItemSeparatorComponent : ItemSeparatorComponent && /*#__PURE__*/(0, _jsxRuntime.jsx)(ItemSeparatorComponent, Object.assign({}, this.state.separatorProps));
+        var cellStyle = inversionStyle ? horizontal ? [styles.rowReverse, inversionStyle] : [styles.columnReverse, inversionStyle] : horizontal ? [styles.row, inversionStyle] : inversionStyle;
+        var result = !CellRendererComponent ? /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, Object.assign({
+          style: cellStyle,
+          onFocusCapture: this._onCellFocusCapture
+        }, onCellLayout && {
+          onLayout: this._onLayout
+        }, {
+          children: [element, itemSeparator]
+        })) : /*#__PURE__*/(0, _jsxRuntime.jsxs)(CellRendererComponent, Object.assign({
+          cellKey: cellKey,
+          index: index,
+          item: item,
+          style: cellStyle,
+          onFocusCapture: this._onCellFocusCapture
+        }, onCellLayout && {
+          onLayout: this._onLayout
+        }, {
+          children: [element, itemSeparator]
+        }));
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[10], "./VirtualizedListContext.js").VirtualizedListCellContextProvider, {
+          cellKey: this.props.cellKey,
+          children: result
+        });
+      }
+    }], [{
+      key: "getDerivedStateFromProps",
+      value: function getDerivedStateFromProps(props, prevState) {
+        if (props.item !== prevState.separatorProps.leadingItem) {
+          return {
+            separatorProps: Object.assign({}, prevState.separatorProps, {
+              leadingItem: props.item
+            })
+          };
+        }
+        return null;
+      }
+    }]);
+  }(React.PureComponent);
+  var styles = _reactNative.StyleSheet.create({
+    row: {
+      flexDirection: 'row'
+    },
+    rowReverse: {
+      flexDirection: 'row-reverse'
+    },
+    columnReverse: {
+      flexDirection: 'column-reverse'
+    }
+  });
+},457,[1,11,12,18,20,23,32,73,2,171,458],"../../node_modules/@react-native/virtualized-lists/Lists/VirtualizedListCellRenderer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.VirtualizedListCellContextProvider = VirtualizedListCellContextProvider;
+  exports.VirtualizedListContext = void 0;
+  exports.VirtualizedListContextProvider = VirtualizedListContextProvider;
+  exports.VirtualizedListContextResetter = VirtualizedListContextResetter;
+  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "react"));
+  var React = _react;
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[1], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/@react-native/virtualized-lists/Lists/VirtualizedListContext.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var VirtualizedListContext = exports.VirtualizedListContext = (0, _react.createContext)(null);
+  if (__DEV__) {
+    VirtualizedListContext.displayName = 'VirtualizedListContext';
+  }
+  function VirtualizedListContextResetter(_ref) {
+    var children = _ref.children;
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(VirtualizedListContext.Provider, {
+      value: null,
+      children: children
+    });
+  }
+  function VirtualizedListContextProvider(_ref2) {
+    var children = _ref2.children,
+      value = _ref2.value;
+    var context = (0, _react.useMemo)(function () {
+      return {
+        cellKey: null,
+        getScrollMetrics: value.getScrollMetrics,
+        horizontal: value.horizontal,
+        getOutermostParentListRef: value.getOutermostParentListRef,
+        registerAsNestedChild: value.registerAsNestedChild,
+        unregisterAsNestedChild: value.unregisterAsNestedChild
+      };
+    }, [value.getScrollMetrics, value.horizontal, value.getOutermostParentListRef, value.registerAsNestedChild, value.unregisterAsNestedChild]);
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(VirtualizedListContext.Provider, {
+      value: context,
+      children: children
+    });
+  }
+  function VirtualizedListCellContextProvider(_ref3) {
+    var cellKey = _ref3.cellKey,
+      children = _ref3.children;
+    var currContext = (0, _react.useContext)(VirtualizedListContext);
+    var context = (0, _react.useMemo)(function () {
+      return currContext == null ? null : Object.assign({}, currContext, {
+        cellKey: cellKey
+      });
+    }, [currContext, cellKey]);
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(VirtualizedListContext.Provider, {
+      value: context,
+      children: children
+    });
+  }
+},458,[73,171],"../../node_modules/@react-native/virtualized-lists/Lists/VirtualizedListContext.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.horizontalOrDefault = horizontalOrDefault;
+  exports.initialNumToRenderOrDefault = initialNumToRenderOrDefault;
+  exports.maxToRenderPerBatchOrDefault = maxToRenderPerBatchOrDefault;
+  exports.onEndReachedThresholdOrDefault = onEndReachedThresholdOrDefault;
+  exports.onStartReachedThresholdOrDefault = onStartReachedThresholdOrDefault;
+  exports.windowSizeOrDefault = windowSizeOrDefault;
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function horizontalOrDefault(horizontal) {
+    return horizontal != null ? horizontal : false;
+  }
+  function initialNumToRenderOrDefault(initialNumToRender) {
+    return initialNumToRender != null ? initialNumToRender : 10;
+  }
+  function maxToRenderPerBatchOrDefault(maxToRenderPerBatch) {
+    return maxToRenderPerBatch != null ? maxToRenderPerBatch : 10;
+  }
+  function onStartReachedThresholdOrDefault(onStartReachedThreshold) {
+    return onStartReachedThreshold != null ? onStartReachedThreshold : 2;
+  }
+  function onEndReachedThresholdOrDefault(onEndReachedThreshold) {
+    return onEndReachedThreshold != null ? onEndReachedThreshold : 2;
+  }
+  function windowSizeOrDefault(windowSize) {
+    return windowSize != null ? windowSize : 21;
+  }
+},459,[73],"../../node_modules/@react-native/virtualized-lists/Lists/VirtualizedListProps.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.CellRenderMask = void 0;
+  var _toConsumableArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/toConsumableArray"));
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/slicedToArray"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "invariant"));
+  var CellRenderMask = exports.CellRenderMask = /*#__PURE__*/function () {
+    function CellRenderMask(numCells) {
+      (0, _classCallCheck2.default)(this, CellRenderMask);
+      (0, _invariant.default)(numCells >= 0, 'CellRenderMask must contain a non-negative number os cells');
+      this._numCells = numCells;
+      if (numCells === 0) {
+        this._regions = [];
+      } else {
+        this._regions = [{
+          first: 0,
+          last: numCells - 1,
+          isSpacer: true
+        }];
+      }
+    }
+    return (0, _createClass2.default)(CellRenderMask, [{
+      key: "enumerateRegions",
+      value: function enumerateRegions() {
+        return this._regions;
+      }
+    }, {
+      key: "addCells",
+      value: function addCells(cells) {
+        var _this$_regions;
+        (0, _invariant.default)(cells.first >= 0 && cells.first < this._numCells && cells.last >= -1 && cells.last < this._numCells && cells.last >= cells.first - 1, 'CellRenderMask.addCells called with invalid cell range');
+        if (cells.last < cells.first) {
+          return;
+        }
+        var _this$_findRegion = this._findRegion(cells.first),
+          _this$_findRegion2 = (0, _slicedToArray2.default)(_this$_findRegion, 2),
+          firstIntersect = _this$_findRegion2[0],
+          firstIntersectIdx = _this$_findRegion2[1];
+        var _this$_findRegion3 = this._findRegion(cells.last),
+          _this$_findRegion4 = (0, _slicedToArray2.default)(_this$_findRegion3, 2),
+          lastIntersect = _this$_findRegion4[0],
+          lastIntersectIdx = _this$_findRegion4[1];
+        if (firstIntersectIdx === lastIntersectIdx && !firstIntersect.isSpacer) {
+          return;
+        }
+        var newLeadRegion = [];
+        var newTailRegion = [];
+        var newMainRegion = Object.assign({}, cells, {
+          isSpacer: false
+        });
+        if (firstIntersect.first < newMainRegion.first) {
+          if (firstIntersect.isSpacer) {
+            newLeadRegion.push({
+              first: firstIntersect.first,
+              last: newMainRegion.first - 1,
+              isSpacer: true
+            });
+          } else {
+            newMainRegion.first = firstIntersect.first;
+          }
+        }
+        if (lastIntersect.last > newMainRegion.last) {
+          if (lastIntersect.isSpacer) {
+            newTailRegion.push({
+              first: newMainRegion.last + 1,
+              last: lastIntersect.last,
+              isSpacer: true
+            });
+          } else {
+            newMainRegion.last = lastIntersect.last;
+          }
+        }
+        var replacementRegions = [].concat(newLeadRegion, [newMainRegion], newTailRegion);
+        var numRegionsToDelete = lastIntersectIdx - firstIntersectIdx + 1;
+        (_this$_regions = this._regions).splice.apply(_this$_regions, [firstIntersectIdx, numRegionsToDelete].concat((0, _toConsumableArray2.default)(replacementRegions)));
+      }
+    }, {
+      key: "numCells",
+      value: function numCells() {
+        return this._numCells;
+      }
+    }, {
+      key: "equals",
+      value: function equals(other) {
+        return this._numCells === other._numCells && this._regions.length === other._regions.length && this._regions.every(function (region, i) {
+          return region.first === other._regions[i].first && region.last === other._regions[i].last && region.isSpacer === other._regions[i].isSpacer;
+        });
+      }
+    }, {
+      key: "_findRegion",
+      value: function _findRegion(cellIdx) {
+        var firstIdx = 0;
+        var lastIdx = this._regions.length - 1;
+        while (firstIdx <= lastIdx) {
+          var middleIdx = Math.floor((firstIdx + lastIdx) / 2);
+          var middleRegion = this._regions[middleIdx];
+          if (cellIdx >= middleRegion.first && cellIdx <= middleRegion.last) {
+            return [middleRegion, middleIdx];
+          } else if (cellIdx < middleRegion.first) {
+            lastIdx = middleIdx - 1;
+          } else if (cellIdx > middleRegion.last) {
+            firstIdx = middleIdx + 1;
+          }
+        }
+        (0, _invariant.default)(false, `A region was not found containing cellIdx ${cellIdx}`);
+      }
+    }]);
+  }();
+},460,[1,42,34,11,12,32],"../../node_modules/@react-native/virtualized-lists/Lists/CellRenderMask.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/objectWithoutProperties"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits"));
+  var _VirtualizedList = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./VirtualizedList"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "invariant"));
+  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[10], "react"));
+  var React = _react;
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[11], "react/jsx-runtime");
+  var _excluded = ["ItemSeparatorComponent", "SectionSeparatorComponent", "renderItem", "renderSectionFooter", "renderSectionHeader", "sections", "stickySectionHeadersEnabled"];
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/@react-native/virtualized-lists/Lists/VirtualizedSectionList.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var VirtualizedSectionList = /*#__PURE__*/function (_React$PureComponent) {
+    function VirtualizedSectionList() {
+      var _this;
+      (0, _classCallCheck2.default)(this, VirtualizedSectionList);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _callSuper(this, VirtualizedSectionList, [].concat(args));
+      _this._keyExtractor = function (item, index) {
+        var info = _this._subExtractor(index);
+        return info && info.key || String(index);
+      };
+      _this._convertViewable = function (viewable) {
+        var _info$index;
+        (0, _invariant.default)(viewable.index != null, 'Received a broken ViewToken');
+        var info = _this._subExtractor(viewable.index);
+        if (!info) {
+          return null;
+        }
+        var keyExtractorWithNullableIndex = info.section.keyExtractor;
+        var keyExtractorWithNonNullableIndex = _this.props.keyExtractor || _$$_REQUIRE(_dependencyMap[12], "./VirtualizeUtils").keyExtractor;
+        var key = keyExtractorWithNullableIndex != null ? keyExtractorWithNullableIndex(viewable.item, info.index) : keyExtractorWithNonNullableIndex(viewable.item, (_info$index = info.index) != null ? _info$index : 0);
+        return Object.assign({}, viewable, {
+          index: info.index,
+          key: key,
+          section: info.section
+        });
+      };
+      _this._onViewableItemsChanged = function (_ref) {
+        var viewableItems = _ref.viewableItems,
+          changed = _ref.changed;
+        var onViewableItemsChanged = _this.props.onViewableItemsChanged;
+        if (onViewableItemsChanged != null) {
+          onViewableItemsChanged({
+            viewableItems: viewableItems.map(_this._convertViewable, _this).filter(Boolean),
+            changed: changed.map(_this._convertViewable, _this).filter(Boolean)
+          });
+        }
+      };
+      _this._renderItem = function (listItemCount) {
+        return function (_ref2) {
+          var item = _ref2.item,
+            index = _ref2.index;
+          var info = _this._subExtractor(index);
+          if (!info) {
+            return null;
+          }
+          var infoIndex = info.index;
+          if (infoIndex == null) {
+            var section = info.section;
+            if (info.header === true) {
+              var renderSectionHeader = _this.props.renderSectionHeader;
+              return renderSectionHeader ? renderSectionHeader({
+                section: section
+              }) : null;
+            } else {
+              var renderSectionFooter = _this.props.renderSectionFooter;
+              return renderSectionFooter ? renderSectionFooter({
+                section: section
+              }) : null;
+            }
+          } else {
+            var renderItem = info.section.renderItem || _this.props.renderItem;
+            var SeparatorComponent = _this._getSeparatorComponent(index, info, listItemCount);
+            (0, _invariant.default)(renderItem, 'no renderItem!');
+            return /*#__PURE__*/(0, _jsxRuntime.jsx)(ItemWithSeparator, {
+              SeparatorComponent: SeparatorComponent,
+              LeadingSeparatorComponent: infoIndex === 0 ? _this.props.SectionSeparatorComponent : undefined,
+              cellKey: info.key,
+              index: infoIndex,
+              item: item,
+              leadingItem: info.leadingItem,
+              leadingSection: info.leadingSection,
+              prevCellKey: (_this._subExtractor(index - 1) || {}).key,
+              setSelfHighlightCallback: _this._setUpdateHighlightFor,
+              setSelfUpdatePropsCallback: _this._setUpdatePropsFor,
+              updateHighlightFor: _this._updateHighlightFor,
+              updatePropsFor: _this._updatePropsFor,
+              renderItem: renderItem,
+              section: info.section,
+              trailingItem: info.trailingItem,
+              trailingSection: info.trailingSection,
+              inverted: !!_this.props.inverted
+            });
+          }
+        };
+      };
+      _this._updatePropsFor = function (cellKey, value) {
+        var updateProps = _this._updatePropsMap[cellKey];
+        if (updateProps != null) {
+          updateProps(value);
+        }
+      };
+      _this._updateHighlightFor = function (cellKey, value) {
+        var updateHighlight = _this._updateHighlightMap[cellKey];
+        if (updateHighlight != null) {
+          updateHighlight(value);
+        }
+      };
+      _this._setUpdateHighlightFor = function (cellKey, updateHighlightFn) {
+        if (updateHighlightFn != null) {
+          _this._updateHighlightMap[cellKey] = updateHighlightFn;
+        } else {
+          delete _this._updateHighlightFor[cellKey];
+        }
+      };
+      _this._setUpdatePropsFor = function (cellKey, updatePropsFn) {
+        if (updatePropsFn != null) {
+          _this._updatePropsMap[cellKey] = updatePropsFn;
+        } else {
+          delete _this._updatePropsMap[cellKey];
+        }
+      };
+      _this._updateHighlightMap = {};
+      _this._updatePropsMap = {};
+      _this._captureRef = function (ref) {
+        _this._listRef = ref;
+      };
+      return _this;
+    }
+    (0, _inherits2.default)(VirtualizedSectionList, _React$PureComponent);
+    return (0, _createClass2.default)(VirtualizedSectionList, [{
+      key: "scrollToLocation",
+      value: function scrollToLocation(params) {
+        var index = params.itemIndex;
+        for (var i = 0; i < params.sectionIndex; i++) {
+          index += this.props.getItemCount(this.props.sections[i].data) + 2;
+        }
+        var viewOffset = params.viewOffset || 0;
+        if (this._listRef == null) {
+          return;
+        }
+        var listRef = this._listRef;
+        if (params.itemIndex > 0 && this.props.stickySectionHeadersEnabled) {
+          var frame = listRef.__getListMetrics().getCellMetricsApprox(index - params.itemIndex, listRef.props);
+          viewOffset += frame.length;
+        }
+        var toIndexParams = Object.assign({}, params, {
+          viewOffset: viewOffset,
+          index: index
+        });
+        this._listRef.scrollToIndex(toIndexParams);
+      }
+    }, {
+      key: "getListRef",
+      value: function getListRef() {
+        return this._listRef;
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this2 = this;
+        var _this$props = this.props,
+          ItemSeparatorComponent = _this$props.ItemSeparatorComponent,
+          SectionSeparatorComponent = _this$props.SectionSeparatorComponent,
+          _renderItem = _this$props.renderItem,
+          renderSectionFooter = _this$props.renderSectionFooter,
+          renderSectionHeader = _this$props.renderSectionHeader,
+          _sections = _this$props.sections,
+          stickySectionHeadersEnabled = _this$props.stickySectionHeadersEnabled,
+          passThroughProps = (0, _objectWithoutProperties2.default)(_this$props, _excluded);
+        var listHeaderOffset = this.props.ListHeaderComponent ? 1 : 0;
+        var stickyHeaderIndices = this.props.stickySectionHeadersEnabled ? [] : undefined;
+        var itemCount = 0;
+        for (var section of this.props.sections) {
+          if (stickyHeaderIndices != null) {
+            stickyHeaderIndices.push(itemCount + listHeaderOffset);
+          }
+          itemCount += 2;
+          itemCount += this.props.getItemCount(section.data);
+        }
+        var renderItem = this._renderItem(itemCount);
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(_VirtualizedList.default, Object.assign({}, passThroughProps, {
+          keyExtractor: this._keyExtractor,
+          stickyHeaderIndices: stickyHeaderIndices,
+          renderItem: renderItem,
+          data: this.props.sections,
+          getItem: function getItem(sections, index) {
+            return _this2._getItem(_this2.props, sections, index);
+          },
+          getItemCount: function getItemCount() {
+            return itemCount;
+          },
+          onViewableItemsChanged: this.props.onViewableItemsChanged ? this._onViewableItemsChanged : undefined,
+          ref: this._captureRef
+        }));
+      }
+    }, {
+      key: "_getItem",
+      value: function _getItem(props, sections, index) {
+        if (!sections) {
+          return null;
+        }
+        var itemIdx = index - 1;
+        for (var i = 0; i < sections.length; i++) {
+          var section = sections[i];
+          var sectionData = section.data;
+          var itemCount = props.getItemCount(sectionData);
+          if (itemIdx === -1 || itemIdx === itemCount) {
+            return section;
+          } else if (itemIdx < itemCount) {
+            return props.getItem(sectionData, itemIdx);
+          } else {
+            itemIdx -= itemCount + 2;
+          }
+        }
+        return null;
+      }
+    }, {
+      key: "_subExtractor",
+      value: function _subExtractor(index) {
+        var itemIndex = index;
+        var _this$props2 = this.props,
+          getItem = _this$props2.getItem,
+          getItemCount = _this$props2.getItemCount,
+          keyExtractor = _this$props2.keyExtractor,
+          sections = _this$props2.sections;
+        for (var i = 0; i < sections.length; i++) {
+          var section = sections[i];
+          var sectionData = section.data;
+          var _key2 = section.key || String(i);
+          itemIndex -= 1;
+          if (itemIndex >= getItemCount(sectionData) + 1) {
+            itemIndex -= getItemCount(sectionData) + 1;
+          } else if (itemIndex === -1) {
+            return {
+              section: section,
+              key: _key2 + ':header',
+              index: null,
+              header: true,
+              trailingSection: sections[i + 1]
+            };
+          } else if (itemIndex === getItemCount(sectionData)) {
+            return {
+              section: section,
+              key: _key2 + ':footer',
+              index: null,
+              header: false,
+              trailingSection: sections[i + 1]
+            };
+          } else {
+            var extractor = section.keyExtractor || keyExtractor || _$$_REQUIRE(_dependencyMap[12], "./VirtualizeUtils").keyExtractor;
+            return {
+              section: section,
+              key: _key2 + ':' + extractor(getItem(sectionData, itemIndex), itemIndex),
+              index: itemIndex,
+              leadingItem: getItem(sectionData, itemIndex - 1),
+              leadingSection: sections[i - 1],
+              trailingItem: getItem(sectionData, itemIndex + 1),
+              trailingSection: sections[i + 1]
+            };
+          }
+        }
+      }
+    }, {
+      key: "_getSeparatorComponent",
+      value: function _getSeparatorComponent(index, info, listItemCount) {
+        info = info || this._subExtractor(index);
+        if (!info) {
+          return null;
+        }
+        var ItemSeparatorComponent = info.section.ItemSeparatorComponent || this.props.ItemSeparatorComponent;
+        var SectionSeparatorComponent = this.props.SectionSeparatorComponent;
+        var isLastItemInList = index === listItemCount - 1;
+        var isLastItemInSection = info.index === this.props.getItemCount(info.section.data) - 1;
+        if (SectionSeparatorComponent && isLastItemInSection) {
+          return SectionSeparatorComponent;
+        }
+        if (ItemSeparatorComponent && !isLastItemInSection && !isLastItemInList) {
+          return ItemSeparatorComponent;
+        }
+        return null;
+      }
+    }]);
+  }(React.PureComponent);
+  function ItemWithSeparator(props) {
+    var LeadingSeparatorComponent = props.LeadingSeparatorComponent,
+      SeparatorComponent = props.SeparatorComponent,
+      cellKey = props.cellKey,
+      prevCellKey = props.prevCellKey,
+      setSelfHighlightCallback = props.setSelfHighlightCallback,
+      updateHighlightFor = props.updateHighlightFor,
+      setSelfUpdatePropsCallback = props.setSelfUpdatePropsCallback,
+      updatePropsFor = props.updatePropsFor,
+      item = props.item,
+      index = props.index,
+      section = props.section,
+      inverted = props.inverted;
+    var _useState = (0, _react.useState)(false),
+      _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+      leadingSeparatorHiglighted = _useState2[0],
+      setLeadingSeparatorHighlighted = _useState2[1];
+    var _useState3 = (0, _react.useState)(false),
+      _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
+      separatorHighlighted = _useState4[0],
+      setSeparatorHighlighted = _useState4[1];
+    var _useState5 = (0, _react.useState)({
+        leadingItem: props.leadingItem,
+        leadingSection: props.leadingSection,
+        section: props.section,
+        trailingItem: props.item,
+        trailingSection: props.trailingSection
+      }),
+      _useState6 = (0, _slicedToArray2.default)(_useState5, 2),
+      leadingSeparatorProps = _useState6[0],
+      setLeadingSeparatorProps = _useState6[1];
+    var _useState7 = (0, _react.useState)({
+        leadingItem: props.item,
+        leadingSection: props.leadingSection,
+        section: props.section,
+        trailingItem: props.trailingItem,
+        trailingSection: props.trailingSection
+      }),
+      _useState8 = (0, _slicedToArray2.default)(_useState7, 2),
+      separatorProps = _useState8[0],
+      setSeparatorProps = _useState8[1];
+    (0, _react.useEffect)(function () {
+      setSelfHighlightCallback(cellKey, setSeparatorHighlighted);
+      setSelfUpdatePropsCallback(cellKey, setSeparatorProps);
+      return function () {
+        setSelfUpdatePropsCallback(cellKey, null);
+        setSelfHighlightCallback(cellKey, null);
+      };
+    }, [cellKey, setSelfHighlightCallback, setSeparatorProps, setSelfUpdatePropsCallback]);
+    var separators = {
+      highlight: function highlight() {
+        setLeadingSeparatorHighlighted(true);
+        setSeparatorHighlighted(true);
+        if (prevCellKey != null) {
+          updateHighlightFor(prevCellKey, true);
+        }
+      },
+      unhighlight: function unhighlight() {
+        setLeadingSeparatorHighlighted(false);
+        setSeparatorHighlighted(false);
+        if (prevCellKey != null) {
+          updateHighlightFor(prevCellKey, false);
+        }
+      },
+      updateProps: function updateProps(select, newProps) {
+        if (select === 'leading') {
+          if (LeadingSeparatorComponent != null) {
+            setLeadingSeparatorProps(Object.assign({}, leadingSeparatorProps, newProps));
+          } else if (prevCellKey != null) {
+            updatePropsFor(prevCellKey, Object.assign({}, leadingSeparatorProps, newProps));
+          }
+        } else if (select === 'trailing' && SeparatorComponent != null) {
+          setSeparatorProps(Object.assign({}, separatorProps, newProps));
+        }
+      }
+    };
+    var element = props.renderItem({
+      item: item,
+      index: index,
+      section: section,
+      separators: separators
+    });
+    var leadingSeparator = LeadingSeparatorComponent != null && /*#__PURE__*/(0, _jsxRuntime.jsx)(LeadingSeparatorComponent, Object.assign({
+      highlighted: leadingSeparatorHiglighted
+    }, leadingSeparatorProps));
+    var separator = SeparatorComponent != null && /*#__PURE__*/(0, _jsxRuntime.jsx)(SeparatorComponent, Object.assign({
+      highlighted: separatorHighlighted
+    }, separatorProps));
+    var RenderSeparator = leadingSeparator || separator;
+    var firstSeparator = inverted === false ? leadingSeparator : separator;
+    var secondSeparator = inverted === false ? separator : leadingSeparator;
+    return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_jsxRuntime.Fragment, {
+      children: [RenderSeparator ? firstSeparator : null, element, RenderSeparator ? secondSeparator : null]
+    });
+  }
+  var VirtualizedSectionListComponent = VirtualizedSectionList;
+  var _default = exports.default = VirtualizedSectionListComponent;
+},461,[1,34,4,11,12,18,20,23,449,32,73,171,448],"../../node_modules/@react-native/virtualized-lists/Lists/VirtualizedSectionList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var safeIsNaN = Number.isNaN || function ponyfill(value) {
+    return typeof value === 'number' && value !== value;
+  };
+  function isEqual(first, second) {
+    if (first === second) {
+      return true;
+    }
+    if (safeIsNaN(first) && safeIsNaN(second)) {
+      return true;
+    }
+    return false;
+  }
+  function areInputsEqual(newInputs, lastInputs) {
+    if (newInputs.length !== lastInputs.length) {
+      return false;
+    }
+    for (var i = 0; i < newInputs.length; i++) {
+      if (!isEqual(newInputs[i], lastInputs[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function memoizeOne(resultFn, isEqual) {
+    if (isEqual === void 0) {
+      isEqual = areInputsEqual;
+    }
+    var cache = null;
+    function memoized() {
+      var newArgs = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        newArgs[_i] = arguments[_i];
+      }
+      if (cache && cache.lastThis === this && isEqual(newArgs, cache.lastArgs)) {
+        return cache.lastResult;
+      }
+      var lastResult = resultFn.apply(this, newArgs);
+      cache = {
+        lastResult: lastResult,
+        lastArgs: newArgs,
+        lastThis: this
+      };
+      return lastResult;
+    }
+    memoized.clear = function clear() {
+      cache = null;
+    };
+    return memoized;
+  }
+  module.exports = memoizeOne;
+},462,[],"../../node_modules/memoize-one/dist/memoize-one.cjs.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _Image = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Image/Image"));
+  var _createAnimatedComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../createAnimatedComponent"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[3], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = (0, _createAnimatedComponent.default)(_Image.default);
+},463,[1,355,418,73],"../../node_modules/react-native/Libraries/Animated/components/AnimatedImage.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _RefreshControl = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../Components/RefreshControl/RefreshControl"));
+  var _ScrollView = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../Components/ScrollView/ScrollView"));
+  var _flattenStyle = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../../StyleSheet/flattenStyle"));
+  var _splitLayoutProps2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../../StyleSheet/splitLayoutProps"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../../StyleSheet/StyleSheet"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../../Utilities/Platform"));
+  var _useMergeRefs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../../Utilities/useMergeRefs"));
+  var _createAnimatedComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "../createAnimatedComponent"));
+  var _useAnimatedProps5 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "../useAnimatedProps"));
+  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[11], "react"));
+  var React = _react;
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[12], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Animated/components/AnimatedScrollView.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var AnimatedScrollView = React.forwardRef(function AnimatedScrollViewWithOrWithoutInvertedRefreshControl(props, forwardedRef) {
+    if (_Platform.default.OS === 'android' && props.refreshControl != null && props.style != null) {
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(AnimatedScrollViewWithInvertedRefreshControl, Object.assign({
+        scrollEventThrottle: 0.0001
+      }, props, {
+        ref: forwardedRef,
+        refreshControl: props.refreshControl
+      }));
+    } else {
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(AnimatedScrollViewWithoutInvertedRefreshControl, Object.assign({
+        scrollEventThrottle: 0.0001
+      }, props, {
+        ref: forwardedRef
+      }));
+    }
+  });
+  var AnimatedScrollViewWithInvertedRefreshControl = React.forwardRef(function AnimatedScrollViewWithInvertedRefreshControl(props, forwardedRef) {
+    var _useMemo = (0, _react.useMemo)(function () {
+        var _splitLayoutProps = (0, _splitLayoutProps2.default)((0, _flattenStyle.default)(props.style)),
+          outer = _splitLayoutProps.outer,
+          inner = _splitLayoutProps.inner;
+        return {
+          intermediatePropsForRefreshControl: {
+            style: outer
+          },
+          intermediatePropsForScrollView: Object.assign({}, props, {
+            style: inner
+          })
+        };
+      }, [props]),
+      intermediatePropsForRefreshControl = _useMemo.intermediatePropsForRefreshControl,
+      intermediatePropsForScrollView = _useMemo.intermediatePropsForScrollView;
+    var _useAnimatedProps = (0, _useAnimatedProps5.default)(intermediatePropsForRefreshControl),
+      _useAnimatedProps2 = (0, _slicedToArray2.default)(_useAnimatedProps, 2),
+      refreshControlAnimatedProps = _useAnimatedProps2[0],
+      refreshControlRef = _useAnimatedProps2[1];
+    var refreshControl = React.cloneElement(props.refreshControl, Object.assign({}, refreshControlAnimatedProps, {
+      ref: refreshControlRef
+    }));
+    var _useAnimatedProps3 = (0, _useAnimatedProps5.default)(intermediatePropsForScrollView),
+      _useAnimatedProps4 = (0, _slicedToArray2.default)(_useAnimatedProps3, 2),
+      scrollViewAnimatedProps = _useAnimatedProps4[0],
+      scrollViewRef = _useAnimatedProps4[1];
+    var ref = (0, _useMergeRefs.default)(scrollViewRef, forwardedRef);
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_ScrollView.default, Object.assign({}, scrollViewAnimatedProps, {
+      ref: ref,
+      refreshControl: refreshControl,
+      style: _StyleSheet.default.compose(scrollViewAnimatedProps.style, refreshControlAnimatedProps.style)
+    }));
+  });
+  var AnimatedScrollViewWithoutInvertedRefreshControl = (0, _createAnimatedComponent.default)(_ScrollView.default);
+  var _default = exports.default = AnimatedScrollView;
+},464,[1,34,465,387,9,432,6,68,364,418,470,73,171],"../../node_modules/react-native/Libraries/Animated/components/AnimatedScrollView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _AndroidSwipeRefreshLayoutNativeComponent = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "./AndroidSwipeRefreshLayoutNativeComponent"));
+  var _PullToRefreshViewNativeComponent = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[8], "./PullToRefreshViewNativeComponent"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[9], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[10], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Components/RefreshControl/RefreshControl.js";
+  var _excluded = ["enabled", "colors", "progressBackgroundColor", "size"],
+    _excluded2 = ["tintColor", "titleColor", "title"];
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var RefreshControl = /*#__PURE__*/function (_React$Component) {
+    function RefreshControl() {
+      var _this;
+      (0, _classCallCheck2.default)(this, RefreshControl);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _callSuper(this, RefreshControl, [].concat(args));
+      _this._lastNativeRefreshing = false;
+      _this._onRefresh = function () {
+        _this._lastNativeRefreshing = true;
+        _this.props.onRefresh && _this.props.onRefresh();
+        _this.forceUpdate();
+      };
+      _this._setNativeRef = function (ref) {
+        _this._nativeRef = ref;
+      };
+      return _this;
+    }
+    (0, _inherits2.default)(RefreshControl, _React$Component);
+    return (0, _createClass2.default)(RefreshControl, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        this._lastNativeRefreshing = this.props.refreshing;
+      }
+    }, {
+      key: "componentDidUpdate",
+      value: function componentDidUpdate(prevProps) {
+        if (this.props.refreshing !== prevProps.refreshing) {
+          this._lastNativeRefreshing = this.props.refreshing;
+        } else if (this.props.refreshing !== this._lastNativeRefreshing && this._nativeRef) {
+          if ("ios" === 'android') {
+            _AndroidSwipeRefreshLayoutNativeComponent.Commands.setNativeRefreshing(this._nativeRef, this.props.refreshing);
+          } else {
+            _PullToRefreshViewNativeComponent.Commands.setNativeRefreshing(this._nativeRef, this.props.refreshing);
+          }
+          this._lastNativeRefreshing = this.props.refreshing;
+        }
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        if ("ios" === 'ios') {
+          var _this$props = this.props,
+            enabled = _this$props.enabled,
+            colors = _this$props.colors,
+            progressBackgroundColor = _this$props.progressBackgroundColor,
+            size = _this$props.size,
+            props = (0, _objectWithoutProperties2.default)(_this$props, _excluded);
+          return /*#__PURE__*/(0, _jsxRuntime.jsx)(_PullToRefreshViewNativeComponent.default, Object.assign({}, props, {
+            ref: this._setNativeRef,
+            onRefresh: this._onRefresh
+          }));
+        } else {
+          var _this$props2 = this.props,
+            tintColor = _this$props2.tintColor,
+            titleColor = _this$props2.titleColor,
+            title = _this$props2.title,
+            _props = (0, _objectWithoutProperties2.default)(_this$props2, _excluded2);
+          return /*#__PURE__*/(0, _jsxRuntime.jsx)(_AndroidSwipeRefreshLayoutNativeComponent.default, Object.assign({}, _props, {
+            ref: this._setNativeRef,
+            onRefresh: this._onRefresh
+          }));
+        }
+      }
+    }]);
+  }(React.Component);
+  var _default = exports.default = RefreshControl;
+},465,[1,4,11,12,18,20,23,466,468,73,171],"../../node_modules/react-native/Libraries/Components/RefreshControl/RefreshControl.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _AndroidSwipeRefreshLayoutNativeComponent = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../src/private/specs_DEPRECATED/components/AndroidSwipeRefreshLayoutNativeComponent"));
+  Object.keys(_AndroidSwipeRefreshLayoutNativeComponent).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _AndroidSwipeRefreshLayoutNativeComponent[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _AndroidSwipeRefreshLayoutNativeComponent[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _AndroidSwipeRefreshLayoutNativeComponent.default;
+},466,[467],"../../node_modules/react-native/Libraries/Components/RefreshControl/AndroidSwipeRefreshLayoutNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = exports.__INTERNAL_VIEW_CONFIG = exports.Commands = void 0;
+  var _codegenNativeCommands = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../../../Libraries/Utilities/codegenNativeCommands"));
+  var _codegenNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../../../Libraries/Utilities/codegenNativeComponent"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[3], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var nativeComponentName = 'AndroidSwipeRefreshLayout';
+  var __INTERNAL_VIEW_CONFIG = exports.__INTERNAL_VIEW_CONFIG = {
+    uiViewClassName: "AndroidSwipeRefreshLayout",
+    directEventTypes: {
+      topRefresh: {
+        registrationName: "onRefresh"
+      }
+    },
+    validAttributes: Object.assign({
+      enabled: true,
+      colors: {
+        process: function (req) {
+          return 'default' in req ? req.default : req;
+        }(_$$_REQUIRE(_dependencyMap[4], "react-native/Libraries/StyleSheet/processColorArray"))
+      },
+      progressBackgroundColor: {
+        process: _$$_REQUIRE(_dependencyMap[5], "react-native/Libraries/StyleSheet/processColor").default
+      },
+      size: true,
+      progressViewOffset: true,
+      refreshing: true
+    }, _$$_REQUIRE(_dependencyMap[6], "react-native/Libraries/NativeComponent/ViewConfigIgnore").ConditionallyIgnoredEventHandlers({
+      onRefresh: true
+    }))
+  };
+  var _default = exports.default = _$$_REQUIRE(_dependencyMap[7], "react-native/Libraries/NativeComponent/NativeComponentRegistry").get(nativeComponentName, function () {
+    return __INTERNAL_VIEW_CONFIG;
+  });
+  var Commands = exports.Commands = {
+    setNativeRefreshing: function setNativeRefreshing(ref, value) {
+      _$$_REQUIRE(_dependencyMap[8], "react-native/Libraries/ReactNative/RendererProxy").dispatchCommand(ref, "setNativeRefreshing", [value]);
+    }
+  };
+},467,[1,105,319,73,91,57,104,77,106],"../../node_modules/react-native/src/private/specs_DEPRECATED/components/AndroidSwipeRefreshLayoutNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _PullToRefreshViewNativeComponent = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../src/private/specs_DEPRECATED/components/PullToRefreshViewNativeComponent"));
+  Object.keys(_PullToRefreshViewNativeComponent).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _PullToRefreshViewNativeComponent[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _PullToRefreshViewNativeComponent[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _PullToRefreshViewNativeComponent.default;
+},468,[469],"../../node_modules/react-native/Libraries/Components/RefreshControl/PullToRefreshViewNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = exports.__INTERNAL_VIEW_CONFIG = exports.Commands = void 0;
+  var _codegenNativeCommands = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../../../Libraries/Utilities/codegenNativeCommands"));
+  var _codegenNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../../../Libraries/Utilities/codegenNativeComponent"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[3], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var nativeComponentName = 'RCTRefreshControl';
+  var __INTERNAL_VIEW_CONFIG = exports.__INTERNAL_VIEW_CONFIG = {
+    uiViewClassName: "RCTRefreshControl",
+    directEventTypes: {
+      topRefresh: {
+        registrationName: "onRefresh"
+      }
+    },
+    validAttributes: Object.assign({
+      tintColor: {
+        process: _$$_REQUIRE(_dependencyMap[4], "react-native/Libraries/StyleSheet/processColor").default
+      },
+      titleColor: {
+        process: _$$_REQUIRE(_dependencyMap[4], "react-native/Libraries/StyleSheet/processColor").default
+      },
+      title: true,
+      progressViewOffset: true,
+      refreshing: true
+    }, _$$_REQUIRE(_dependencyMap[5], "react-native/Libraries/NativeComponent/ViewConfigIgnore").ConditionallyIgnoredEventHandlers({
+      onRefresh: true
+    }))
+  };
+  var _default = exports.default = _$$_REQUIRE(_dependencyMap[6], "react-native/Libraries/NativeComponent/NativeComponentRegistry").get(nativeComponentName, function () {
+    return __INTERNAL_VIEW_CONFIG;
+  });
+  var Commands = exports.Commands = {
+    setNativeRefreshing: function setNativeRefreshing(ref, refreshing) {
+      _$$_REQUIRE(_dependencyMap[7], "react-native/Libraries/ReactNative/RendererProxy").dispatchCommand(ref, "setNativeRefreshing", [refreshing]);
+    }
+  };
+},469,[1,105,319,73,57,104,77,106],"../../node_modules/react-native/src/private/specs_DEPRECATED/components/PullToRefreshViewNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _createAnimatedPropsHook = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../src/private/animated/createAnimatedPropsHook"));
+  var _default = exports.default = (0, _createAnimatedPropsHook.default)(null);
+},470,[1,419],"../../node_modules/react-native/Libraries/Animated/useAnimatedProps.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _SectionList = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Lists/SectionList"));
+  var _createAnimatedComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../createAnimatedComponent"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[3], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = (0, _createAnimatedComponent.default)(_SectionList.default);
+},471,[1,472,418,73],"../../node_modules/react-native/Libraries/Animated/components/AnimatedSectionList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../Utilities/Platform"));
+  var _virtualizedLists = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@react-native/virtualized-lists"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[9], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[10], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Lists/SectionList.js";
+  var _excluded = ["stickySectionHeadersEnabled"];
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var VirtualizedSectionList = _virtualizedLists.default.VirtualizedSectionList;
+  var SectionList = exports.default = /*#__PURE__*/function (_React$PureComponent) {
+    function SectionList() {
+      var _this;
+      (0, _classCallCheck2.default)(this, SectionList);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _callSuper(this, SectionList, [].concat(args));
+      _this._captureRef = function (ref) {
+        _this._wrapperListRef = ref;
+      };
+      return _this;
+    }
+    (0, _inherits2.default)(SectionList, _React$PureComponent);
+    return (0, _createClass2.default)(SectionList, [{
+      key: "scrollToLocation",
+      value: function scrollToLocation(params) {
+        if (this._wrapperListRef != null) {
+          this._wrapperListRef.scrollToLocation(params);
+        }
+      }
+    }, {
+      key: "recordInteraction",
+      value: function recordInteraction() {
+        var listRef = this._wrapperListRef && this._wrapperListRef.getListRef();
+        listRef && listRef.recordInteraction();
+      }
+    }, {
+      key: "flashScrollIndicators",
+      value: function flashScrollIndicators() {
+        var listRef = this._wrapperListRef && this._wrapperListRef.getListRef();
+        listRef && listRef.flashScrollIndicators();
+      }
+    }, {
+      key: "getScrollResponder",
+      value: function getScrollResponder() {
+        var listRef = this._wrapperListRef && this._wrapperListRef.getListRef();
+        if (listRef) {
+          return listRef.getScrollResponder();
+        }
+      }
+    }, {
+      key: "getScrollableNode",
+      value: function getScrollableNode() {
+        var listRef = this._wrapperListRef && this._wrapperListRef.getListRef();
+        if (listRef) {
+          return listRef.getScrollableNode();
+        }
+      }
+    }, {
+      key: "setNativeProps",
+      value: function setNativeProps(props) {
+        var listRef = this._wrapperListRef && this._wrapperListRef.getListRef();
+        if (listRef) {
+          listRef.setNativeProps(props);
+        }
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props = this.props,
+          _stickySectionHeadersEnabled = _this$props.stickySectionHeadersEnabled,
+          restProps = (0, _objectWithoutProperties2.default)(_this$props, _excluded);
+        var stickySectionHeadersEnabled = _stickySectionHeadersEnabled != null ? _stickySectionHeadersEnabled : _Platform.default.OS === 'ios';
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(VirtualizedSectionList, Object.assign({}, restProps, {
+          stickySectionHeadersEnabled: stickySectionHeadersEnabled,
+          ref: this._captureRef,
+          getItemCount: function getItemCount(items) {
+            return items.length;
+          },
+          getItem: function getItem(items, index) {
+            return items[index];
+          }
+        }));
+      }
+    }]);
+  }(React.PureComponent);
+},472,[1,4,11,12,18,20,23,68,447,73,171],"../../node_modules/react-native/Libraries/Lists/SectionList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _Text = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Text/Text"));
+  var _createAnimatedComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../createAnimatedComponent"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[3], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = (0, _createAnimatedComponent.default)(_Text.default);
+},473,[1,352,418,73],"../../node_modules/react-native/Libraries/Animated/components/AnimatedText.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Components/View/View"));
+  var _createAnimatedComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../createAnimatedComponent"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[3], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = (0, _createAnimatedComponent.default)(_View.default);
+},474,[1,71,418,73],"../../node_modules/react-native/Libraries/Animated/components/AnimatedView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.HScrollViewNativeComponent = exports.HScrollContentViewNativeComponent = void 0;
+  var _AndroidHorizontalScrollViewNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../../../Libraries/Components/ScrollView/AndroidHorizontalScrollViewNativeComponent"));
+  var _ScrollContentViewNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../../../Libraries/Components/ScrollView/ScrollContentViewNativeComponent"));
+  var _ScrollViewNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../../../Libraries/Components/ScrollView/ScrollViewNativeComponent"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../../../../Libraries/Utilities/Platform"));
+  var _AndroidHorizontalScrollContentViewNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../../specs_DEPRECATED/components/AndroidHorizontalScrollContentViewNativeComponent"));
+  var HScrollViewNativeComponent = exports.HScrollViewNativeComponent = _Platform.default.OS === 'android' ? _AndroidHorizontalScrollViewNativeComponent.default : _ScrollViewNativeComponent.default;
+  var HScrollContentViewNativeComponent = exports.HScrollContentViewNativeComponent = _Platform.default.OS === 'android' ? _AndroidHorizontalScrollContentViewNativeComponent.default : _ScrollContentViewNativeComponent.default;
+},475,[1,476,477,478,68,479],"../../node_modules/react-native/src/private/components/scrollview/HScrollViewNativeComponents.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = exports.__INTERNAL_VIEW_CONFIG = void 0;
+  var NativeComponentRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../NativeComponent/NativeComponentRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var __INTERNAL_VIEW_CONFIG = exports.__INTERNAL_VIEW_CONFIG = {
+    uiViewClassName: 'AndroidHorizontalScrollView',
+    bubblingEventTypes: {},
+    directEventTypes: {},
+    validAttributes: {
+      decelerationRate: true,
+      disableIntervalMomentum: true,
+      maintainVisibleContentPosition: true,
+      endFillColor: {
+        process: _$$_REQUIRE(_dependencyMap[1], "../../StyleSheet/processColor").default
+      },
+      fadingEdgeLength: true,
+      nestedScrollEnabled: true,
+      overScrollMode: true,
+      pagingEnabled: true,
+      persistentScrollbar: true,
+      horizontal: true,
+      scrollEnabled: true,
+      scrollEventThrottle: true,
+      scrollPerfTag: true,
+      sendMomentumEvents: true,
+      showsHorizontalScrollIndicator: true,
+      snapToAlignment: true,
+      snapToEnd: true,
+      snapToInterval: true,
+      snapToStart: true,
+      snapToOffsets: true,
+      contentOffset: true,
+      borderBottomLeftRadius: true,
+      borderBottomRightRadius: true,
+      borderRadius: true,
+      borderStyle: true,
+      borderRightColor: {
+        process: _$$_REQUIRE(_dependencyMap[1], "../../StyleSheet/processColor").default
+      },
+      borderColor: {
+        process: _$$_REQUIRE(_dependencyMap[1], "../../StyleSheet/processColor").default
+      },
+      borderBottomColor: {
+        process: _$$_REQUIRE(_dependencyMap[1], "../../StyleSheet/processColor").default
+      },
+      borderTopLeftRadius: true,
+      borderTopColor: {
+        process: _$$_REQUIRE(_dependencyMap[1], "../../StyleSheet/processColor").default
+      },
+      removeClippedSubviews: true,
+      borderTopRightRadius: true,
+      borderLeftColor: {
+        process: _$$_REQUIRE(_dependencyMap[1], "../../StyleSheet/processColor").default
+      },
+      pointerEvents: true
+    }
+  };
+  var AndroidHorizontalScrollViewNativeComponent = NativeComponentRegistry.get('AndroidHorizontalScrollView', function () {
+    return __INTERNAL_VIEW_CONFIG;
+  });
+  var _default = exports.default = AndroidHorizontalScrollViewNativeComponent;
+},476,[77,57],"../../node_modules/react-native/Libraries/Components/ScrollView/AndroidHorizontalScrollViewNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = exports.__INTERNAL_VIEW_CONFIG = void 0;
+  var NativeComponentRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../NativeComponent/NativeComponentRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var __INTERNAL_VIEW_CONFIG = exports.__INTERNAL_VIEW_CONFIG = {
+    uiViewClassName: 'RCTScrollContentView',
+    bubblingEventTypes: {},
+    directEventTypes: {},
+    validAttributes: {}
+  };
+  var ScrollContentViewNativeComponent = NativeComponentRegistry.get('RCTScrollContentView', function () {
+    return __INTERNAL_VIEW_CONFIG;
+  });
+  var _default = exports.default = ScrollContentViewNativeComponent;
+},477,[77],"../../node_modules/react-native/Libraries/Components/ScrollView/ScrollContentViewNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = exports.__INTERNAL_VIEW_CONFIG = void 0;
+  var NativeComponentRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../NativeComponent/NativeComponentRegistry"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../Utilities/Platform"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var __INTERNAL_VIEW_CONFIG = exports.__INTERNAL_VIEW_CONFIG = _Platform.default.OS === 'android' ? {
+    uiViewClassName: 'RCTScrollView',
+    bubblingEventTypes: {},
+    directEventTypes: {
+      topMomentumScrollBegin: {
+        registrationName: 'onMomentumScrollBegin'
+      },
+      topMomentumScrollEnd: {
+        registrationName: 'onMomentumScrollEnd'
+      },
+      topScroll: {
+        registrationName: 'onScroll'
+      },
+      topScrollBeginDrag: {
+        registrationName: 'onScrollBeginDrag'
+      },
+      topScrollEndDrag: {
+        registrationName: 'onScrollEndDrag'
+      }
+    },
+    validAttributes: {
+      contentOffset: {
+        diff: _$$_REQUIRE(_dependencyMap[3], "../../Utilities/differ/pointsDiffer").default
+      },
+      decelerationRate: true,
+      disableIntervalMomentum: true,
+      maintainVisibleContentPosition: true,
+      pagingEnabled: true,
+      scrollEnabled: true,
+      showsVerticalScrollIndicator: true,
+      snapToAlignment: true,
+      snapToEnd: true,
+      snapToInterval: true,
+      snapToOffsets: true,
+      snapToStart: true,
+      borderBottomLeftRadius: true,
+      borderBottomRightRadius: true,
+      sendMomentumEvents: true,
+      borderRadius: true,
+      nestedScrollEnabled: true,
+      scrollEventThrottle: true,
+      borderStyle: true,
+      borderRightColor: {
+        process: _$$_REQUIRE(_dependencyMap[4], "../../StyleSheet/processColor").default
+      },
+      borderColor: {
+        process: _$$_REQUIRE(_dependencyMap[4], "../../StyleSheet/processColor").default
+      },
+      borderBottomColor: {
+        process: _$$_REQUIRE(_dependencyMap[4], "../../StyleSheet/processColor").default
+      },
+      persistentScrollbar: true,
+      horizontal: true,
+      endFillColor: {
+        process: _$$_REQUIRE(_dependencyMap[4], "../../StyleSheet/processColor").default
+      },
+      fadingEdgeLength: true,
+      overScrollMode: true,
+      borderTopLeftRadius: true,
+      scrollPerfTag: true,
+      borderTopColor: {
+        process: _$$_REQUIRE(_dependencyMap[4], "../../StyleSheet/processColor").default
+      },
+      removeClippedSubviews: true,
+      borderTopRightRadius: true,
+      borderLeftColor: {
+        process: _$$_REQUIRE(_dependencyMap[4], "../../StyleSheet/processColor").default
+      },
+      pointerEvents: true,
+      isInvertedVirtualizedList: true
+    }
+  } : {
+    uiViewClassName: 'RCTScrollView',
+    bubblingEventTypes: {},
+    directEventTypes: {
+      topMomentumScrollBegin: {
+        registrationName: 'onMomentumScrollBegin'
+      },
+      topMomentumScrollEnd: {
+        registrationName: 'onMomentumScrollEnd'
+      },
+      topScroll: {
+        registrationName: 'onScroll'
+      },
+      topScrollBeginDrag: {
+        registrationName: 'onScrollBeginDrag'
+      },
+      topScrollEndDrag: {
+        registrationName: 'onScrollEndDrag'
+      },
+      topScrollToTop: {
+        registrationName: 'onScrollToTop'
+      }
+    },
+    validAttributes: Object.assign({
+      alwaysBounceHorizontal: true,
+      alwaysBounceVertical: true,
+      automaticallyAdjustContentInsets: true,
+      automaticallyAdjustKeyboardInsets: true,
+      automaticallyAdjustsScrollIndicatorInsets: true,
+      bounces: true,
+      bouncesZoom: true,
+      canCancelContentTouches: true,
+      centerContent: true,
+      contentInset: {
+        diff: _$$_REQUIRE(_dependencyMap[5], "../../Utilities/differ/insetsDiffer").default
+      },
+      contentOffset: {
+        diff: _$$_REQUIRE(_dependencyMap[3], "../../Utilities/differ/pointsDiffer").default
+      },
+      contentInsetAdjustmentBehavior: true,
+      decelerationRate: true,
+      endDraggingSensitivityMultiplier: true,
+      directionalLockEnabled: true,
+      disableIntervalMomentum: true,
+      indicatorStyle: true,
+      inverted: true,
+      keyboardDismissMode: true,
+      maintainVisibleContentPosition: true,
+      maximumZoomScale: true,
+      minimumZoomScale: true,
+      pagingEnabled: true,
+      pinchGestureEnabled: true,
+      scrollEnabled: true,
+      scrollEventThrottle: true,
+      scrollIndicatorInsets: {
+        diff: _$$_REQUIRE(_dependencyMap[5], "../../Utilities/differ/insetsDiffer").default
+      },
+      scrollToOverflowEnabled: true,
+      scrollsToTop: true,
+      showsHorizontalScrollIndicator: true,
+      showsVerticalScrollIndicator: true,
+      snapToAlignment: true,
+      snapToEnd: true,
+      snapToInterval: true,
+      snapToOffsets: true,
+      snapToStart: true,
+      verticalScrollIndicatorInsets: {
+        diff: _$$_REQUIRE(_dependencyMap[5], "../../Utilities/differ/insetsDiffer").default
+      },
+      zoomScale: true
+    }, (0, _$$_REQUIRE(_dependencyMap[6], "../../NativeComponent/ViewConfigIgnore").ConditionallyIgnoredEventHandlers)({
+      onScrollBeginDrag: true,
+      onMomentumScrollEnd: true,
+      onScrollEndDrag: true,
+      onMomentumScrollBegin: true,
+      onScrollToTop: true,
+      onScroll: true
+    }))
+  };
+  var ScrollViewNativeComponent = NativeComponentRegistry.get('RCTScrollView', function () {
+    return __INTERNAL_VIEW_CONFIG;
+  });
+  var _default = exports.default = ScrollViewNativeComponent;
+},478,[1,77,68,89,57,90,104],"../../node_modules/react-native/Libraries/Components/ScrollView/ScrollViewNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = exports.__INTERNAL_VIEW_CONFIG = void 0;
+  var _codegenNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../../../Libraries/Utilities/codegenNativeComponent"));
+  var nativeComponentName = 'AndroidHorizontalScrollContentView';
+  var __INTERNAL_VIEW_CONFIG = exports.__INTERNAL_VIEW_CONFIG = {
+    uiViewClassName: "AndroidHorizontalScrollContentView",
+    validAttributes: {
+      removeClippedSubviews: true
+    }
+  };
+  var _default = exports.default = _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/NativeComponent/NativeComponentRegistry").get(nativeComponentName, function () {
+    return __INTERNAL_VIEW_CONFIG;
+  });
+},479,[1,319,77],"../../node_modules/react-native/src/private/specs_DEPRECATED/components/AndroidHorizontalScrollContentViewNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.VScrollViewNativeComponent = exports.VScrollContentViewNativeComponent = void 0;
+  var _ScrollContentViewNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../../../Libraries/Components/ScrollView/ScrollContentViewNativeComponent"));
+  var _ScrollViewNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../../../Libraries/Components/ScrollView/ScrollViewNativeComponent"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../../../Libraries/Components/View/View"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../../../../Libraries/Utilities/Platform"));
+  var VScrollViewNativeComponent = exports.VScrollViewNativeComponent = _ScrollViewNativeComponent.default;
+  var VScrollContentViewNativeComponent = exports.VScrollContentViewNativeComponent = _Platform.default.OS === 'android' ? _View.default : _ScrollContentViewNativeComponent.default;
+},480,[1,477,478,71,68],"../../node_modules/react-native/src/private/components/scrollview/VScrollViewNativeComponents.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[6], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[7], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/src/private/devsupport/devmenu/elementinspector/ElementProperties.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var ElementProperties = /*#__PURE__*/function (_React$Component) {
+    function ElementProperties() {
+      (0, _classCallCheck2.default)(this, ElementProperties);
+      return _callSuper(this, ElementProperties, arguments);
+    }
+    (0, _inherits2.default)(ElementProperties, _React$Component);
+    return (0, _createClass2.default)(ElementProperties, [{
+      key: "render",
+      value: function render() {
+        var _this = this;
+        var style = _$$_REQUIRE(_dependencyMap[8], "../../../../../Libraries/StyleSheet/flattenStyle").default(this.props.style);
+        var selection = this.props.selection;
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[9], "../../../../../Libraries/Components/Touchable/TouchableWithoutFeedback").default, {
+          children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_$$_REQUIRE(_dependencyMap[10], "../../../../../Libraries/Components/View/View").default, {
+            style: styles.info,
+            children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[10], "../../../../../Libraries/Components/View/View").default, {
+              style: styles.breadcrumb,
+              children: this.props.hierarchy != null && _$$_REQUIRE(_dependencyMap[11], "../../../../../Libraries/Utilities/mapWithSeparator").default(this.props.hierarchy, function (hierarchyItem, i) {
+                return /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[12], "../../../../../Libraries/Components/Touchable/TouchableHighlight").default, {
+                  style: [styles.breadItem, i === selection && styles.selected],
+                  onPress: function onPress() {
+                    return _this.props.setSelection(i);
+                  },
+                  children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[13], "../../../../../Libraries/Text/Text").default, {
+                    style: styles.breadItemText,
+                    children: hierarchyItem.name
+                  })
+                }, 'item-' + i);
+              }, function (i) {
+                return /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[13], "../../../../../Libraries/Text/Text").default, {
+                  style: styles.breadSep,
+                  children: "\u25B8"
+                }, 'sep-' + i);
+              })
+            }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(_$$_REQUIRE(_dependencyMap[10], "../../../../../Libraries/Components/View/View").default, {
+              style: styles.row,
+              children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[10], "../../../../../Libraries/Components/View/View").default, {
+                style: styles.col,
+                children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[14], "./StyleInspector").default, {
+                  style: style
+                })
+              }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[15], "./BoxInspector").default, {
+                style: style,
+                frame: this.props.frame
+              })]
+            })]
+          })
+        });
+      }
+    }]);
+  }(React.Component);
+  var styles = _$$_REQUIRE(_dependencyMap[16], "../../../../../Libraries/StyleSheet/StyleSheet").default.create({
+    breadSep: {
+      fontSize: 8,
+      color: 'white'
+    },
+    breadcrumb: {
+      flexDirection: 'row',
+      flexWrap: 'wrap',
+      alignItems: 'flex-start',
+      marginBottom: 5
+    },
+    selected: {
+      borderColor: 'white',
+      borderRadius: 5
+    },
+    breadItem: {
+      borderWidth: 1,
+      borderColor: 'transparent',
+      marginHorizontal: 2
+    },
+    breadItemText: {
+      fontSize: 10,
+      color: 'white',
+      marginHorizontal: 5
+    },
+    row: {
+      flexDirection: 'row',
+      alignItems: 'center',
+      justifyContent: 'space-between'
+    },
+    col: {
+      flex: 1
+    },
+    info: {
+      padding: 10
+    }
+  });
+  var _default = exports.default = ElementProperties;
+},481,[1,11,12,18,20,23,73,171,9,339,71,482,483,352,484,485,6],"../../node_modules/react-native/src/private/devsupport/devmenu/elementinspector/ElementProperties.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  function mapWithSeparator(items, itemRenderer, spacerRenderer) {
+    var mapped = [];
+    if (items.length > 0) {
+      mapped.push(itemRenderer(items[0], 0, items));
+      for (var ii = 1; ii < items.length; ii++) {
+        mapped.push(spacerRenderer(ii - 1), itemRenderer(items[ii], ii, items));
+      }
+    }
+    return mapped;
+  }
+  var _default = exports.default = mapWithSeparator;
+},482,[],"../../node_modules/react-native/Libraries/Utilities/mapWithSeparator.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../../Components/View/View"));
+  var _Pressability = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../../Pressability/Pressability"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "../../StyleSheet/StyleSheet"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "../../Utilities/Platform"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[11], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[12], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Components/Touchable/TouchableHighlight.js",
+    _this3 = this;
+  var _excluded = ["onBlur", "onFocus"];
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var TouchableHighlightImpl = /*#__PURE__*/function (_React$Component) {
+    function TouchableHighlightImpl() {
+      var _this;
+      (0, _classCallCheck2.default)(this, TouchableHighlightImpl);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _callSuper(this, TouchableHighlightImpl, [].concat(args));
+      _this._isMounted = false;
+      _this.state = {
+        pressability: new _Pressability.default(_this._createPressabilityConfig()),
+        extraStyles: _this.props.testOnly_pressed === true ? _this._createExtraStyles() : null
+      };
+      return _this;
+    }
+    (0, _inherits2.default)(TouchableHighlightImpl, _React$Component);
+    return (0, _createClass2.default)(TouchableHighlightImpl, [{
+      key: "_createPressabilityConfig",
+      value: function _createPressabilityConfig() {
+        var _this$props$accessibi,
+          _this2 = this;
+        return {
+          cancelable: !this.props.rejectResponderTermination,
+          disabled: this.props.disabled != null ? this.props.disabled : (_this$props$accessibi = this.props.accessibilityState) == null ? void 0 : _this$props$accessibi.disabled,
+          hitSlop: this.props.hitSlop,
+          delayLongPress: this.props.delayLongPress,
+          delayPressIn: this.props.delayPressIn,
+          delayPressOut: this.props.delayPressOut,
+          minPressDuration: 0,
+          pressRectOffset: this.props.pressRetentionOffset,
+          android_disableSound: this.props.touchSoundDisabled,
+          onBlur: function onBlur(event) {
+            if (_Platform.default.isTV) {
+              _this2._hideUnderlay();
+            }
+            if (_this2.props.onBlur != null) {
+              _this2.props.onBlur(event);
+            }
+          },
+          onFocus: function onFocus(event) {
+            if (_Platform.default.isTV) {
+              _this2._showUnderlay();
+            }
+            if (_this2.props.onFocus != null) {
+              _this2.props.onFocus(event);
+            }
+          },
+          onLongPress: this.props.onLongPress,
+          onPress: function onPress(event) {
+            if (_this2._hideTimeout != null) {
+              clearTimeout(_this2._hideTimeout);
+            }
+            if (!_Platform.default.isTV) {
+              var _this2$props$delayPre;
+              _this2._showUnderlay();
+              _this2._hideTimeout = setTimeout(function () {
+                _this2._hideUnderlay();
+              }, (_this2$props$delayPre = _this2.props.delayPressOut) != null ? _this2$props$delayPre : 0);
+            }
+            if (_this2.props.onPress != null) {
+              _this2.props.onPress(event);
+            }
+          },
+          onPressIn: function onPressIn(event) {
+            if (_this2._hideTimeout != null) {
+              clearTimeout(_this2._hideTimeout);
+              _this2._hideTimeout = null;
+            }
+            _this2._showUnderlay();
+            if (_this2.props.onPressIn != null) {
+              _this2.props.onPressIn(event);
+            }
+          },
+          onPressOut: function onPressOut(event) {
+            if (_this2._hideTimeout == null) {
+              _this2._hideUnderlay();
+            }
+            if (_this2.props.onPressOut != null) {
+              _this2.props.onPressOut(event);
+            }
+          }
+        };
+      }
+    }, {
+      key: "_createExtraStyles",
+      value: function _createExtraStyles() {
+        var _this$props$activeOpa;
+        return {
+          child: {
+            opacity: (_this$props$activeOpa = this.props.activeOpacity) != null ? _this$props$activeOpa : 0.85
+          },
+          underlay: {
+            backgroundColor: this.props.underlayColor === undefined ? 'black' : this.props.underlayColor
+          }
+        };
+      }
+    }, {
+      key: "_showUnderlay",
+      value: function _showUnderlay() {
+        if (!this._isMounted || !this._hasPressHandler()) {
+          return;
+        }
+        this.setState({
+          extraStyles: this._createExtraStyles()
+        });
+        if (this.props.onShowUnderlay != null) {
+          this.props.onShowUnderlay();
+        }
+      }
+    }, {
+      key: "_hideUnderlay",
+      value: function _hideUnderlay() {
+        if (this._hideTimeout != null) {
+          clearTimeout(this._hideTimeout);
+          this._hideTimeout = null;
+        }
+        if (this.props.testOnly_pressed === true) {
+          return;
+        }
+        if (this._hasPressHandler()) {
+          this.setState({
+            extraStyles: null
+          });
+          if (this.props.onHideUnderlay != null) {
+            this.props.onHideUnderlay();
+          }
+        }
+      }
+    }, {
+      key: "_hasPressHandler",
+      value: function _hasPressHandler() {
+        return this.props.onPress != null || this.props.onPressIn != null || this.props.onPressOut != null || this.props.onLongPress != null;
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props$ariaValu, _this$props$accessibi2, _this$props$ariaValu2, _this$props$accessibi3, _this$props$ariaValu3, _this$props$accessibi4, _this$props$ariaValu4, _this$props$accessibi5, _this$props$ariaLive, _this$props$ariaLabe, _this$props$ariaModa, _this$props$ariaHidd, _this$state$extraStyl, _this$props$id, _this$state$extraStyl2;
+        var child = React.Children.only(this.props.children);
+        var _this$state$pressabil = this.state.pressability.getEventHandlers(),
+          onBlur = _this$state$pressabil.onBlur,
+          onFocus = _this$state$pressabil.onFocus,
+          eventHandlersWithoutBlurAndFocus = (0, _objectWithoutProperties2.default)(_this$state$pressabil, _excluded);
+        var accessibilityState = this.props.disabled != null ? Object.assign({}, this.props.accessibilityState, {
+          disabled: this.props.disabled
+        }) : this.props.accessibilityState;
+        var accessibilityValue = {
+          max: (_this$props$ariaValu = this.props['aria-valuemax']) != null ? _this$props$ariaValu : (_this$props$accessibi2 = this.props.accessibilityValue) == null ? void 0 : _this$props$accessibi2.max,
+          min: (_this$props$ariaValu2 = this.props['aria-valuemin']) != null ? _this$props$ariaValu2 : (_this$props$accessibi3 = this.props.accessibilityValue) == null ? void 0 : _this$props$accessibi3.min,
+          now: (_this$props$ariaValu3 = this.props['aria-valuenow']) != null ? _this$props$ariaValu3 : (_this$props$accessibi4 = this.props.accessibilityValue) == null ? void 0 : _this$props$accessibi4.now,
+          text: (_this$props$ariaValu4 = this.props['aria-valuetext']) != null ? _this$props$ariaValu4 : (_this$props$accessibi5 = this.props.accessibilityValue) == null ? void 0 : _this$props$accessibi5.text
+        };
+        var accessibilityLiveRegion = this.props['aria-live'] === 'off' ? 'none' : (_this$props$ariaLive = this.props['aria-live']) != null ? _this$props$ariaLive : this.props.accessibilityLiveRegion;
+        var accessibilityLabel = (_this$props$ariaLabe = this.props['aria-label']) != null ? _this$props$ariaLabe : this.props.accessibilityLabel;
+        return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_View.default, Object.assign({
+          accessible: this.props.accessible !== false,
+          accessibilityLabel: accessibilityLabel,
+          accessibilityHint: this.props.accessibilityHint,
+          accessibilityLanguage: this.props.accessibilityLanguage,
+          accessibilityRole: this.props.accessibilityRole,
+          accessibilityState: accessibilityState,
+          accessibilityValue: accessibilityValue,
+          accessibilityActions: this.props.accessibilityActions,
+          onAccessibilityAction: this.props.onAccessibilityAction,
+          importantForAccessibility: this.props['aria-hidden'] === true ? 'no-hide-descendants' : this.props.importantForAccessibility,
+          accessibilityViewIsModal: (_this$props$ariaModa = this.props['aria-modal']) != null ? _this$props$ariaModa : this.props.accessibilityViewIsModal,
+          accessibilityLiveRegion: accessibilityLiveRegion,
+          accessibilityElementsHidden: (_this$props$ariaHidd = this.props['aria-hidden']) != null ? _this$props$ariaHidd : this.props.accessibilityElementsHidden,
+          style: _StyleSheet.default.compose(this.props.style, (_this$state$extraStyl = this.state.extraStyles) == null ? void 0 : _this$state$extraStyl.underlay),
+          onLayout: this.props.onLayout,
+          hitSlop: this.props.hitSlop,
+          hasTVPreferredFocus: this.props.hasTVPreferredFocus,
+          nextFocusDown: this.props.nextFocusDown,
+          nextFocusForward: this.props.nextFocusForward,
+          nextFocusLeft: this.props.nextFocusLeft,
+          nextFocusRight: this.props.nextFocusRight,
+          nextFocusUp: this.props.nextFocusUp,
+          focusable: this.props.focusable !== false && this.props.onPress !== undefined && !this.props.disabled,
+          nativeID: (_this$props$id = this.props.id) != null ? _this$props$id : this.props.nativeID,
+          testID: this.props.testID,
+          ref: this.props.hostRef
+        }, eventHandlersWithoutBlurAndFocus, {
+          children: [React.cloneElement(child, {
+            style: _StyleSheet.default.compose(child.props.style, (_this$state$extraStyl2 = this.state.extraStyles) == null ? void 0 : _this$state$extraStyl2.child)
+          }), __DEV__ ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[13], "../../Pressability/PressabilityDebug").PressabilityDebugView, {
+            color: "green",
+            hitSlop: this.props.hitSlop
+          }) : null]
+        }));
+      }
+    }, {
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        this._isMounted = true;
+        this.state.pressability.configure(this._createPressabilityConfig());
+      }
+    }, {
+      key: "componentDidUpdate",
+      value: function componentDidUpdate(prevProps, prevState) {
+        this.state.pressability.configure(this._createPressabilityConfig());
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        this._isMounted = false;
+        if (this._hideTimeout != null) {
+          clearTimeout(this._hideTimeout);
+        }
+        this.state.pressability.reset();
+      }
+    }]);
+  }(React.Component);
+  var TouchableHighlight = React.forwardRef(function (props, hostRef) {
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(TouchableHighlightImpl, Object.assign({}, props, {
+      hostRef: hostRef
+    }));
+  });
+  TouchableHighlight.displayName = 'TouchableHighlight';
+  var _default = exports.default = TouchableHighlight;
+},483,[1,4,11,12,18,20,23,71,341,6,68,73,171,349],"../../node_modules/react-native/Libraries/Components/Touchable/TouchableHighlight.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[1], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/src/private/devsupport/devmenu/elementinspector/StyleInspector.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function StyleInspector(_ref) {
+    var _this = this;
+    var style = _ref.style;
+    if (!style) {
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[2], "../../../../../Libraries/Text/Text").default, {
+        style: styles.noStyle,
+        children: "No style"
+      });
+    }
+    var names = Object.keys(style);
+    return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_$$_REQUIRE(_dependencyMap[3], "../../../../../Libraries/Components/View/View").default, {
+      style: styles.container,
+      children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[3], "../../../../../Libraries/Components/View/View").default, {
+        children: names.map(function (name) {
+          return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_$$_REQUIRE(_dependencyMap[2], "../../../../../Libraries/Text/Text").default, {
+            style: styles.attr,
+            children: [name, ":"]
+          }, name);
+        })
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[3], "../../../../../Libraries/Components/View/View").default, {
+        children: names.map(function (name) {
+          var value = style == null ? void 0 : style[name];
+          return /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[2], "../../../../../Libraries/Text/Text").default, {
+            style: styles.value,
+            children: typeof value !== 'string' && typeof value !== 'number' ? JSON.stringify(value) : value
+          }, name);
+        })
+      })]
+    });
+  }
+  var styles = _$$_REQUIRE(_dependencyMap[4], "../../../../../Libraries/StyleSheet/StyleSheet").default.create({
+    container: {
+      flexDirection: 'row'
+    },
+    attr: {
+      fontSize: 10,
+      color: '#ccc'
+    },
+    value: {
+      fontSize: 10,
+      color: 'white',
+      marginLeft: 10
+    },
+    noStyle: {
+      color: 'white',
+      fontSize: 10
+    }
+  });
+  var _default = exports.default = StyleInspector;
+},484,[73,171,352,71,6],"../../node_modules/react-native/src/private/devsupport/devmenu/elementinspector/StyleInspector.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[1], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/src/private/devsupport/devmenu/elementinspector/BoxInspector.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var blank = {
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0
+  };
+  function BoxInspector(_ref) {
+    var style = _ref.style,
+      frame = _ref.frame;
+    var margin = style && _$$_REQUIRE(_dependencyMap[2], "./resolveBoxStyle").default('margin', style) || blank;
+    var padding = style && _$$_REQUIRE(_dependencyMap[2], "./resolveBoxStyle").default('padding', style) || blank;
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(BoxContainer, {
+      title: "margin",
+      titleStyle: styles.marginLabel,
+      box: margin,
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)(BoxContainer, {
+        title: "padding",
+        box: padding,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_$$_REQUIRE(_dependencyMap[3], "../../../../../Libraries/Components/View/View").default, {
+          children: [/*#__PURE__*/(0, _jsxRuntime.jsxs)(_$$_REQUIRE(_dependencyMap[4], "../../../../../Libraries/Text/Text").default, {
+            style: styles.innerText,
+            children: ["(", ((frame == null ? void 0 : frame.left) || 0).toFixed(1), ", ", ((frame == null ? void 0 : frame.top) || 0).toFixed(1), ")"]
+          }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(_$$_REQUIRE(_dependencyMap[4], "../../../../../Libraries/Text/Text").default, {
+            style: styles.innerText,
+            children: [((frame == null ? void 0 : frame.width) || 0).toFixed(1), " \xD7", ' ', ((frame == null ? void 0 : frame.height) || 0).toFixed(1)]
+          })]
+        })
+      })
+    });
+  }
+  function BoxContainer(_ref2) {
+    var title = _ref2.title,
+      titleStyle = _ref2.titleStyle,
+      box = _ref2.box,
+      children = _ref2.children;
+    return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_$$_REQUIRE(_dependencyMap[3], "../../../../../Libraries/Components/View/View").default, {
+      style: styles.box,
+      children: [/*#__PURE__*/(0, _jsxRuntime.jsxs)(_$$_REQUIRE(_dependencyMap[3], "../../../../../Libraries/Components/View/View").default, {
+        style: styles.row,
+        children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[4], "../../../../../Libraries/Text/Text").default, {
+          style: [titleStyle, styles.label],
+          children: title
+        }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[4], "../../../../../Libraries/Text/Text").default, {
+          style: styles.boxText,
+          children: box.top
+        })]
+      }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(_$$_REQUIRE(_dependencyMap[3], "../../../../../Libraries/Components/View/View").default, {
+        style: styles.row,
+        children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[4], "../../../../../Libraries/Text/Text").default, {
+          style: styles.boxText,
+          children: box.left
+        }), children, /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[4], "../../../../../Libraries/Text/Text").default, {
+          style: styles.boxText,
+          children: box.right
+        })]
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[4], "../../../../../Libraries/Text/Text").default, {
+        style: styles.boxText,
+        children: box.bottom
+      })]
+    });
+  }
+  var styles = _$$_REQUIRE(_dependencyMap[5], "../../../../../Libraries/StyleSheet/StyleSheet").default.create({
+    row: {
+      flexDirection: 'row',
+      alignItems: 'center',
+      justifyContent: 'space-around'
+    },
+    marginLabel: {
+      width: 60
+    },
+    label: {
+      fontSize: 10,
+      color: 'rgb(255,100,0)',
+      marginLeft: 5,
+      flex: 1,
+      textAlign: 'left',
+      top: -3
+    },
+    innerText: {
+      color: 'yellow',
+      fontSize: 12,
+      textAlign: 'center',
+      width: 70
+    },
+    box: {
+      borderWidth: 1,
+      borderColor: 'grey'
+    },
+    boxText: {
+      color: 'white',
+      fontSize: 12,
+      marginHorizontal: 3,
+      marginVertical: 2,
+      textAlign: 'center'
+    }
+  });
+  var _default = exports.default = BoxInspector;
+},485,[73,171,379,71,352,6],"../../node_modules/react-native/src/private/devsupport/devmenu/elementinspector/BoxInspector.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[6], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[7], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/src/private/devsupport/devmenu/perfmonitor/PerformanceOverlay.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var PerformanceOverlay = /*#__PURE__*/function (_React$Component) {
+    function PerformanceOverlay() {
+      (0, _classCallCheck2.default)(this, PerformanceOverlay);
+      return _callSuper(this, PerformanceOverlay, arguments);
+    }
+    (0, _inherits2.default)(PerformanceOverlay, _React$Component);
+    return (0, _createClass2.default)(PerformanceOverlay, [{
+      key: "render",
+      value: function render() {
+        var perfLogs = _$$_REQUIRE(_dependencyMap[8], "../../../../../Libraries/Utilities/GlobalPerformanceLogger").default.getTimespans();
+        var items = [];
+        for (var key in perfLogs) {
+          var _perfLogs$key;
+          if ((_perfLogs$key = perfLogs[key]) != null && _perfLogs$key.totalTime) {
+            var unit = key === 'BundleSize' ? 'b' : 'ms';
+            items.push(/*#__PURE__*/(0, _jsxRuntime.jsxs)(_$$_REQUIRE(_dependencyMap[9], "../../../../../Libraries/Components/View/View").default, {
+              style: styles.row,
+              children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[10], "../../../../../Libraries/Text/Text").default, {
+                style: [styles.text, styles.label],
+                children: key
+              }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[10], "../../../../../Libraries/Text/Text").default, {
+                style: [styles.text, styles.totalTime],
+                children: perfLogs[key].totalTime + unit
+              })]
+            }, key));
+          }
+        }
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[9], "../../../../../Libraries/Components/View/View").default, {
+          style: styles.container,
+          children: items
+        });
+      }
+    }]);
+  }(React.Component);
+  var styles = _$$_REQUIRE(_dependencyMap[11], "../../../../../Libraries/StyleSheet/StyleSheet").default.create({
+    container: {
+      height: 100,
+      paddingTop: 10
+    },
+    label: {
+      flex: 1
+    },
+    row: {
+      flexDirection: 'row',
+      paddingHorizontal: 10
+    },
+    text: {
+      color: 'white',
+      fontSize: 12
+    },
+    totalTime: {
+      paddingRight: 100
+    }
+  });
+  var _default = exports.default = PerformanceOverlay;
+},486,[1,11,12,18,20,23,73,171,250,71,352,6],"../../node_modules/react-native/src/private/devsupport/devmenu/perfmonitor/PerformanceOverlay.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var _ScrollView = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../../../../../Libraries/Components/ScrollView/ScrollView"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[8], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/src/private/devsupport/devmenu/elementinspector/NetworkOverlay.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var LISTVIEW_CELL_HEIGHT = 15;
+  var nextXHRId = 0;
+  function getStringByValue(value) {
+    if (value === undefined) {
+      return 'undefined';
+    }
+    if (typeof value === 'object') {
+      return JSON.stringify(value);
+    }
+    if (typeof value === 'string' && value.length > 500) {
+      return String(value).slice(0, 500).concat('\n***TRUNCATED TO 500 CHARACTERS***');
+    }
+    return value;
+  }
+  function getTypeShortName(type) {
+    if (type === 'XMLHttpRequest') {
+      return 'XHR';
+    } else if (type === 'WebSocket') {
+      return 'WS';
+    }
+    return '';
+  }
+  function keyExtractor(request) {
+    return String(request.id);
+  }
+  var XHR_ID_KEY = Symbol('XHR_ID');
+  function getXHRId(xhr) {
+    return xhr[XHR_ID_KEY];
+  }
+  function setXHRId(xhr, id) {
+    xhr[XHR_ID_KEY] = id;
+  }
+  var NetworkOverlay = /*#__PURE__*/function (_React$Component) {
+    function NetworkOverlay() {
+      var _this;
+      (0, _classCallCheck2.default)(this, NetworkOverlay);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _callSuper(this, NetworkOverlay, [].concat(args));
+      _this._requestsListViewScrollMetrics = {
+        offset: 0,
+        visibleLength: 0,
+        contentLength: 0
+      };
+      _this._socketIdMap = {};
+      _this._xhrIdMap = {};
+      _this.state = {
+        detailRowId: null,
+        requests: []
+      };
+      _this._renderItem = function (_ref) {
+        var item = _ref.item,
+          index = _ref.index;
+        var tableRowViewStyle = [styles.tableRow, index % 2 === 1 ? styles.tableRowOdd : styles.tableRowEven, index === _this.state.detailRowId && styles.tableRowPressed];
+        var urlCellViewStyle = styles.urlCellView;
+        var methodCellViewStyle = styles.methodCellView;
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[9], "../../../../../Libraries/Components/Touchable/TouchableHighlight").default, {
+          onPress: function onPress() {
+            _this._pressRow(index);
+          },
+          children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[10], "../../../../../Libraries/Components/View/View").default, {
+            children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_$$_REQUIRE(_dependencyMap[10], "../../../../../Libraries/Components/View/View").default, {
+              style: tableRowViewStyle,
+              children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[10], "../../../../../Libraries/Components/View/View").default, {
+                style: urlCellViewStyle,
+                children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[11], "../../../../../Libraries/Text/Text").default, {
+                  style: styles.cellText,
+                  numberOfLines: 1,
+                  children: item.url
+                })
+              }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[10], "../../../../../Libraries/Components/View/View").default, {
+                style: methodCellViewStyle,
+                children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[11], "../../../../../Libraries/Text/Text").default, {
+                  style: styles.cellText,
+                  numberOfLines: 1,
+                  children: getTypeShortName(item.type)
+                })
+              })]
+            })
+          })
+        });
+      };
+      _this._indicateAdditionalRequests = function () {
+        if (_this._requestsListView) {
+          var distanceFromEndThreshold = LISTVIEW_CELL_HEIGHT * 2;
+          var _this$_requestsListVi = _this._requestsListViewScrollMetrics,
+            offset = _this$_requestsListVi.offset,
+            visibleLength = _this$_requestsListVi.visibleLength,
+            contentLength = _this$_requestsListVi.contentLength;
+          var distanceFromEnd = contentLength - visibleLength - offset;
+          var isCloseToEnd = distanceFromEnd <= distanceFromEndThreshold;
+          if (isCloseToEnd) {
+            _this._requestsListView.scrollToEnd();
+          } else {
+            _this._requestsListView.flashScrollIndicators();
+          }
+        }
+      };
+      _this._captureRequestsListView = function (listRef) {
+        _this._requestsListView = listRef;
+      };
+      _this._requestsListViewOnScroll = function (e) {
+        _this._requestsListViewScrollMetrics.offset = e.nativeEvent.contentOffset.y;
+        _this._requestsListViewScrollMetrics.visibleLength = e.nativeEvent.layoutMeasurement.height;
+        _this._requestsListViewScrollMetrics.contentLength = e.nativeEvent.contentSize.height;
+      };
+      _this._scrollDetailToTop = function () {
+        if (_this._detailScrollView) {
+          _this._detailScrollView.scrollTo({
+            y: 0,
+            animated: false
+          });
+        }
+      };
+      _this._closeButtonClicked = function () {
+        _this.setState({
+          detailRowId: null
+        });
+      };
+      return _this;
+    }
+    (0, _inherits2.default)(NetworkOverlay, _React$Component);
+    return (0, _createClass2.default)(NetworkOverlay, [{
+      key: "_enableXHRInterception",
+      value: function _enableXHRInterception() {
+        var _this2 = this;
+        if (_$$_REQUIRE(_dependencyMap[12], "./XHRInterceptor").default.isInterceptorEnabled()) {
+          return;
+        }
+        _$$_REQUIRE(_dependencyMap[12], "./XHRInterceptor").default.setOpenCallback(function (method, url, xhr) {
+          setXHRId(xhr, nextXHRId++);
+          var xhrIndex = _this2.state.requests.length;
+          _this2._xhrIdMap[getXHRId(xhr)] = xhrIndex;
+          var _xhr = {
+            id: xhrIndex,
+            type: 'XMLHttpRequest',
+            method: method,
+            url: url
+          };
+          _this2.setState({
+            requests: _this2.state.requests.concat(_xhr)
+          }, _this2._indicateAdditionalRequests);
+        });
+        _$$_REQUIRE(_dependencyMap[12], "./XHRInterceptor").default.setRequestHeaderCallback(function (header, value, xhr) {
+          var xhrIndex = _this2._getRequestIndexByXHRID(getXHRId(xhr));
+          if (xhrIndex === -1) {
+            return;
+          }
+          _this2.setState(function (_ref2) {
+            var requests = _ref2.requests;
+            var networkRequestInfo = requests[xhrIndex];
+            if (!networkRequestInfo.requestHeaders) {
+              networkRequestInfo.requestHeaders = {};
+            }
+            networkRequestInfo.requestHeaders[header] = value;
+            return {
+              requests: requests
+            };
+          });
+        });
+        _$$_REQUIRE(_dependencyMap[12], "./XHRInterceptor").default.setSendCallback(function (data, xhr) {
+          var xhrIndex = _this2._getRequestIndexByXHRID(getXHRId(xhr));
+          if (xhrIndex === -1) {
+            return;
+          }
+          _this2.setState(function (_ref3) {
+            var requests = _ref3.requests;
+            var networkRequestInfo = requests[xhrIndex];
+            networkRequestInfo.dataSent = data;
+            return {
+              requests: requests
+            };
+          });
+        });
+        _$$_REQUIRE(_dependencyMap[12], "./XHRInterceptor").default.setHeaderReceivedCallback(function (type, size, responseHeaders, xhr) {
+          var xhrIndex = _this2._getRequestIndexByXHRID(getXHRId(xhr));
+          if (xhrIndex === -1) {
+            return;
+          }
+          _this2.setState(function (_ref4) {
+            var requests = _ref4.requests;
+            var networkRequestInfo = requests[xhrIndex];
+            networkRequestInfo.responseContentType = type;
+            networkRequestInfo.responseSize = size;
+            networkRequestInfo.responseHeaders = responseHeaders;
+            return {
+              requests: requests
+            };
+          });
+        });
+        _$$_REQUIRE(_dependencyMap[12], "./XHRInterceptor").default.setResponseCallback(function (status, timeout, response, responseURL, responseType, xhr) {
+          var xhrIndex = _this2._getRequestIndexByXHRID(getXHRId(xhr));
+          if (xhrIndex === -1) {
+            return;
+          }
+          _this2.setState(function (_ref5) {
+            var requests = _ref5.requests;
+            var networkRequestInfo = requests[xhrIndex];
+            networkRequestInfo.status = status;
+            networkRequestInfo.timeout = timeout;
+            networkRequestInfo.response = response;
+            networkRequestInfo.responseURL = responseURL;
+            networkRequestInfo.responseType = responseType;
+            return {
+              requests: requests
+            };
+          });
+        });
+        _$$_REQUIRE(_dependencyMap[12], "./XHRInterceptor").default.enableInterception();
+      }
+    }, {
+      key: "_enableWebSocketInterception",
+      value: function _enableWebSocketInterception() {
+        var _this3 = this;
+        if (_$$_REQUIRE(_dependencyMap[13], "../../../../../Libraries/WebSocket/WebSocketInterceptor").default.isInterceptorEnabled()) {
+          return;
+        }
+        _$$_REQUIRE(_dependencyMap[13], "../../../../../Libraries/WebSocket/WebSocketInterceptor").default.setConnectCallback(function (url, protocols, options, socketId) {
+          var socketIndex = _this3.state.requests.length;
+          _this3._socketIdMap[socketId] = socketIndex;
+          var _webSocket = {
+            id: socketIndex,
+            type: 'WebSocket',
+            url: url,
+            protocols: protocols
+          };
+          _this3.setState({
+            requests: _this3.state.requests.concat(_webSocket)
+          }, _this3._indicateAdditionalRequests);
+        });
+        _$$_REQUIRE(_dependencyMap[13], "../../../../../Libraries/WebSocket/WebSocketInterceptor").default.setCloseCallback(function (statusCode, closeReason, socketId) {
+          var socketIndex = _this3._socketIdMap[socketId];
+          if (socketIndex === undefined) {
+            return;
+          }
+          if (statusCode !== null && closeReason !== null) {
+            _this3.setState(function (_ref6) {
+              var requests = _ref6.requests;
+              var networkRequestInfo = requests[socketIndex];
+              networkRequestInfo.status = statusCode;
+              networkRequestInfo.closeReason = closeReason;
+              return {
+                requests: requests
+              };
+            });
+          }
+        });
+        _$$_REQUIRE(_dependencyMap[13], "../../../../../Libraries/WebSocket/WebSocketInterceptor").default.setSendCallback(function (data, socketId) {
+          var socketIndex = _this3._socketIdMap[socketId];
+          if (socketIndex === undefined) {
+            return;
+          }
+          _this3.setState(function (_ref7) {
+            var requests = _ref7.requests;
+            var networkRequestInfo = requests[socketIndex];
+            if (!networkRequestInfo.messages) {
+              networkRequestInfo.messages = '';
+            }
+            networkRequestInfo.messages += 'Sent: ' + JSON.stringify(data) + '\n';
+            return {
+              requests: requests
+            };
+          });
+        });
+        _$$_REQUIRE(_dependencyMap[13], "../../../../../Libraries/WebSocket/WebSocketInterceptor").default.setOnMessageCallback(function (message, socketId) {
+          var socketIndex = _this3._socketIdMap[socketId];
+          if (socketIndex === undefined) {
+            return;
+          }
+          _this3.setState(function (_ref8) {
+            var requests = _ref8.requests;
+            var networkRequestInfo = requests[socketIndex];
+            if (!networkRequestInfo.messages) {
+              networkRequestInfo.messages = '';
+            }
+            networkRequestInfo.messages += 'Received: ' + JSON.stringify(message) + '\n';
+            return {
+              requests: requests
+            };
+          });
+        });
+        _$$_REQUIRE(_dependencyMap[13], "../../../../../Libraries/WebSocket/WebSocketInterceptor").default.setOnCloseCallback(function (message, socketId) {
+          var socketIndex = _this3._socketIdMap[socketId];
+          if (socketIndex === undefined) {
+            return;
+          }
+          _this3.setState(function (_ref9) {
+            var requests = _ref9.requests;
+            var networkRequestInfo = requests[socketIndex];
+            networkRequestInfo.serverClose = message;
+            return {
+              requests: requests
+            };
+          });
+        });
+        _$$_REQUIRE(_dependencyMap[13], "../../../../../Libraries/WebSocket/WebSocketInterceptor").default.setOnErrorCallback(function (message, socketId) {
+          var socketIndex = _this3._socketIdMap[socketId];
+          if (socketIndex === undefined) {
+            return;
+          }
+          _this3.setState(function (_ref0) {
+            var requests = _ref0.requests;
+            var networkRequestInfo = requests[socketIndex];
+            networkRequestInfo.serverError = message;
+            return {
+              requests: requests
+            };
+          });
+        });
+        _$$_REQUIRE(_dependencyMap[13], "../../../../../Libraries/WebSocket/WebSocketInterceptor").default.enableInterception();
+      }
+    }, {
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        this._enableXHRInterception();
+        this._enableWebSocketInterception();
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        _$$_REQUIRE(_dependencyMap[12], "./XHRInterceptor").default.disableInterception();
+        _$$_REQUIRE(_dependencyMap[13], "../../../../../Libraries/WebSocket/WebSocketInterceptor").default.disableInterception();
+      }
+    }, {
+      key: "_renderItemDetail",
+      value: function _renderItemDetail(id) {
+        var _this4 = this;
+        var requestItem = this.state.requests[id];
+        var details = Object.keys(requestItem).map(function (key) {
+          if (key === 'id') {
+            return;
+          }
+          return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_$$_REQUIRE(_dependencyMap[10], "../../../../../Libraries/Components/View/View").default, {
+            style: styles.detailViewRow,
+            children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[11], "../../../../../Libraries/Text/Text").default, {
+              style: [styles.detailViewText, styles.detailKeyCellView],
+              children: key
+            }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[11], "../../../../../Libraries/Text/Text").default, {
+              style: [styles.detailViewText, styles.detailValueCellView],
+              children: getStringByValue(requestItem[key])
+            })]
+          }, key);
+        });
+        return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_$$_REQUIRE(_dependencyMap[10], "../../../../../Libraries/Components/View/View").default, {
+          children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[9], "../../../../../Libraries/Components/Touchable/TouchableHighlight").default, {
+            style: styles.closeButton,
+            onPress: this._closeButtonClicked,
+            children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[10], "../../../../../Libraries/Components/View/View").default, {
+              children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[11], "../../../../../Libraries/Text/Text").default, {
+                style: styles.closeButtonText,
+                children: "v"
+              })
+            })
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_ScrollView.default, {
+            style: styles.detailScrollView,
+            ref: function ref(scrollRef) {
+              return _this4._detailScrollView = scrollRef;
+            },
+            children: details
+          })]
+        });
+      }
+    }, {
+      key: "_pressRow",
+      value: function _pressRow(rowId) {
+        this.setState({
+          detailRowId: rowId
+        }, this._scrollDetailToTop);
+      }
+    }, {
+      key: "_getRequestIndexByXHRID",
+      value: function _getRequestIndexByXHRID(index) {
+        if (index === undefined) {
+          return -1;
+        }
+        var xhrIndex = this._xhrIdMap[index];
+        if (xhrIndex === undefined) {
+          return -1;
+        } else {
+          return xhrIndex;
+        }
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$state = this.state,
+          requests = _this$state.requests,
+          detailRowId = _this$state.detailRowId;
+        return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_$$_REQUIRE(_dependencyMap[10], "../../../../../Libraries/Components/View/View").default, {
+          style: styles.container,
+          children: [detailRowId != null && this._renderItemDetail(detailRowId), /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[10], "../../../../../Libraries/Components/View/View").default, {
+            style: styles.listViewTitle,
+            children: requests.length > 0 && /*#__PURE__*/(0, _jsxRuntime.jsxs)(_$$_REQUIRE(_dependencyMap[10], "../../../../../Libraries/Components/View/View").default, {
+              style: styles.tableRow,
+              children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[10], "../../../../../Libraries/Components/View/View").default, {
+                style: styles.urlTitleCellView,
+                children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[11], "../../../../../Libraries/Text/Text").default, {
+                  style: styles.cellText,
+                  numberOfLines: 1,
+                  children: "URL"
+                })
+              }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[10], "../../../../../Libraries/Components/View/View").default, {
+                style: styles.methodTitleCellView,
+                children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[11], "../../../../../Libraries/Text/Text").default, {
+                  style: styles.cellText,
+                  numberOfLines: 1,
+                  children: "Type"
+                })
+              })]
+            })
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[14], "../../../../../Libraries/Lists/FlatList").default, {
+            ref: this._captureRequestsListView,
+            onScroll: this._requestsListViewOnScroll,
+            style: styles.listView,
+            data: requests,
+            renderItem: this._renderItem,
+            keyExtractor: keyExtractor,
+            extraData: this.state
+          })]
+        });
+      }
+    }]);
+  }(React.Component);
+  var styles = _$$_REQUIRE(_dependencyMap[15], "../../../../../Libraries/StyleSheet/StyleSheet").default.create({
+    container: {
+      paddingTop: 10,
+      paddingBottom: 10,
+      paddingLeft: 5,
+      paddingRight: 5
+    },
+    listViewTitle: {
+      height: 20
+    },
+    listView: {
+      flex: 1,
+      height: 60
+    },
+    tableRow: {
+      flexDirection: 'row',
+      flex: 1,
+      height: LISTVIEW_CELL_HEIGHT
+    },
+    tableRowEven: {
+      backgroundColor: '#555'
+    },
+    tableRowOdd: {
+      backgroundColor: '#000'
+    },
+    tableRowPressed: {
+      backgroundColor: '#3B5998'
+    },
+    cellText: {
+      color: 'white',
+      fontSize: 12
+    },
+    methodTitleCellView: {
+      height: 18,
+      borderColor: '#DCD7CD',
+      borderTopWidth: 1,
+      borderBottomWidth: 1,
+      borderRightWidth: 1,
+      alignItems: 'center',
+      justifyContent: 'center',
+      backgroundColor: '#444',
+      flex: 1
+    },
+    urlTitleCellView: {
+      height: 18,
+      borderColor: '#DCD7CD',
+      borderTopWidth: 1,
+      borderBottomWidth: 1,
+      borderLeftWidth: 1,
+      borderRightWidth: 1,
+      justifyContent: 'center',
+      backgroundColor: '#444',
+      flex: 5,
+      paddingLeft: 3
+    },
+    methodCellView: {
+      height: 15,
+      borderColor: '#DCD7CD',
+      borderRightWidth: 1,
+      alignItems: 'center',
+      justifyContent: 'center',
+      flex: 1
+    },
+    urlCellView: {
+      height: 15,
+      borderColor: '#DCD7CD',
+      borderLeftWidth: 1,
+      borderRightWidth: 1,
+      justifyContent: 'center',
+      flex: 5,
+      paddingLeft: 3
+    },
+    detailScrollView: {
+      flex: 1,
+      height: 180,
+      marginTop: 5,
+      marginBottom: 5
+    },
+    detailKeyCellView: {
+      flex: 1.3
+    },
+    detailValueCellView: {
+      flex: 2
+    },
+    detailViewRow: {
+      flexDirection: 'row',
+      paddingHorizontal: 3
+    },
+    detailViewText: {
+      color: 'white',
+      fontSize: 11
+    },
+    closeButtonText: {
+      color: 'white',
+      fontSize: 10
+    },
+    closeButton: {
+      marginTop: 5,
+      backgroundColor: '#888',
+      justifyContent: 'center',
+      alignItems: 'center'
+    }
+  });
+  var _default = exports.default = NetworkOverlay;
+},487,[1,11,12,18,20,23,387,73,171,483,71,352,488,489,446,6],"../../node_modules/react-native/src/private/devsupport/devmenu/elementinspector/NetworkOverlay.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var originalXHROpen = _$$_REQUIRE(_dependencyMap[0], "../../../../../Libraries/Network/XMLHttpRequest").default.prototype.open;
+  var originalXHRSend = _$$_REQUIRE(_dependencyMap[0], "../../../../../Libraries/Network/XMLHttpRequest").default.prototype.send;
+  var originalXHRSetRequestHeader = _$$_REQUIRE(_dependencyMap[0], "../../../../../Libraries/Network/XMLHttpRequest").default.prototype.setRequestHeader;
+  var openCallback;
+  var sendCallback;
+  var requestHeaderCallback;
+  var headerReceivedCallback;
+  var responseCallback;
+  var _isInterceptorEnabled = false;
+  var XHRInterceptor = {
+    setOpenCallback: function setOpenCallback(callback) {
+      openCallback = callback;
+    },
+    setSendCallback: function setSendCallback(callback) {
+      sendCallback = callback;
+    },
+    setHeaderReceivedCallback: function setHeaderReceivedCallback(callback) {
+      headerReceivedCallback = callback;
+    },
+    setResponseCallback: function setResponseCallback(callback) {
+      responseCallback = callback;
+    },
+    setRequestHeaderCallback: function setRequestHeaderCallback(callback) {
+      requestHeaderCallback = callback;
+    },
+    isInterceptorEnabled: function isInterceptorEnabled() {
+      return _isInterceptorEnabled;
+    },
+    enableInterception: function enableInterception() {
+      if (_isInterceptorEnabled) {
+        return;
+      }
+      _$$_REQUIRE(_dependencyMap[0], "../../../../../Libraries/Network/XMLHttpRequest").default.prototype.open = function (method, url) {
+        if (openCallback) {
+          openCallback(method, url, this);
+        }
+        originalXHROpen.apply(this, arguments);
+      };
+      _$$_REQUIRE(_dependencyMap[0], "../../../../../Libraries/Network/XMLHttpRequest").default.prototype.setRequestHeader = function (header, value) {
+        if (requestHeaderCallback) {
+          requestHeaderCallback(header, value, this);
+        }
+        originalXHRSetRequestHeader.apply(this, arguments);
+      };
+      _$$_REQUIRE(_dependencyMap[0], "../../../../../Libraries/Network/XMLHttpRequest").default.prototype.send = function (data) {
+        var _this = this;
+        if (sendCallback) {
+          sendCallback(data, this);
+        }
+        if (this.addEventListener) {
+          this.addEventListener('readystatechange', function () {
+            if (!_isInterceptorEnabled) {
+              return;
+            }
+            if (_this.readyState === _this.HEADERS_RECEIVED) {
+              var contentTypeString = _this.getResponseHeader('Content-Type');
+              var contentLengthString = _this.getResponseHeader('Content-Length');
+              var _responseContentType, _responseSize;
+              if (contentTypeString) {
+                _responseContentType = contentTypeString.split(';')[0];
+              }
+              if (contentLengthString) {
+                _responseSize = parseInt(contentLengthString, 10);
+              }
+              if (headerReceivedCallback) {
+                headerReceivedCallback(_responseContentType, _responseSize, _this.getAllResponseHeaders(), _this);
+              }
+            }
+            if (_this.readyState === _this.DONE) {
+              if (responseCallback) {
+                responseCallback(_this.status, _this.timeout, _this.response, _this.responseURL, _this.responseType, _this);
+              }
+            }
+          }, false);
+        }
+        originalXHRSend.apply(this, arguments);
+      };
+      _isInterceptorEnabled = true;
+    },
+    disableInterception: function disableInterception() {
+      if (!_isInterceptorEnabled) {
+        return;
+      }
+      _isInterceptorEnabled = false;
+      _$$_REQUIRE(_dependencyMap[0], "../../../../../Libraries/Network/XMLHttpRequest").default.prototype.send = originalXHRSend;
+      _$$_REQUIRE(_dependencyMap[0], "../../../../../Libraries/Network/XMLHttpRequest").default.prototype.open = originalXHROpen;
+      _$$_REQUIRE(_dependencyMap[0], "../../../../../Libraries/Network/XMLHttpRequest").default.prototype.setRequestHeader = originalXHRSetRequestHeader;
+      responseCallback = null;
+      openCallback = null;
+      sendCallback = null;
+      headerReceivedCallback = null;
+      requestHeaderCallback = null;
+    }
+  };
+  var _default = exports.default = XHRInterceptor;
+},488,[248],"../../node_modules/react-native/src/private/devsupport/devmenu/elementinspector/XHRInterceptor.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _NativeEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../EventEmitter/NativeEventEmitter"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../Utilities/Platform"));
+  var _NativeWebSocketModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./NativeWebSocketModule"));
+  var _base64Js = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "base64-js"));
+  var originalRCTWebSocketConnect = _NativeWebSocketModule.default.connect;
+  var originalRCTWebSocketSend = _NativeWebSocketModule.default.send;
+  var originalRCTWebSocketSendBinary = _NativeWebSocketModule.default.sendBinary;
+  var originalRCTWebSocketClose = _NativeWebSocketModule.default.close;
+  var eventEmitter;
+  var subscriptions;
+  var closeCallback;
+  var sendCallback;
+  var connectCallback;
+  var onOpenCallback;
+  var onMessageCallback;
+  var onErrorCallback;
+  var onCloseCallback;
+  var _isInterceptorEnabled = false;
+  var WebSocketInterceptor = {
+    setCloseCallback: function setCloseCallback(callback) {
+      closeCallback = callback;
+    },
+    setSendCallback: function setSendCallback(callback) {
+      sendCallback = callback;
+    },
+    setConnectCallback: function setConnectCallback(callback) {
+      connectCallback = callback;
+    },
+    setOnOpenCallback: function setOnOpenCallback(callback) {
+      onOpenCallback = callback;
+    },
+    setOnMessageCallback: function setOnMessageCallback(callback) {
+      onMessageCallback = callback;
+    },
+    setOnErrorCallback: function setOnErrorCallback(callback) {
+      onErrorCallback = callback;
+    },
+    setOnCloseCallback: function setOnCloseCallback(callback) {
+      onCloseCallback = callback;
+    },
+    isInterceptorEnabled: function isInterceptorEnabled() {
+      return _isInterceptorEnabled;
+    },
+    _unregisterEvents: function _unregisterEvents() {
+      subscriptions.forEach(function (e) {
+        return e.remove();
+      });
+      subscriptions = [];
+    },
+    _registerEvents: function _registerEvents() {
+      subscriptions = [eventEmitter.addListener('websocketMessage', function (ev) {
+        if (onMessageCallback) {
+          onMessageCallback(ev.type === 'binary' ? WebSocketInterceptor._arrayBufferToString(ev.data) : ev.data, ev.id);
+        }
+      }), eventEmitter.addListener('websocketOpen', function (ev) {
+        if (onOpenCallback) {
+          onOpenCallback(ev.id);
+        }
+      }), eventEmitter.addListener('websocketClosed', function (ev) {
+        if (onCloseCallback) {
+          onCloseCallback({
+            code: ev.code,
+            reason: ev.reason
+          }, ev.id);
+        }
+      }), eventEmitter.addListener('websocketFailed', function (ev) {
+        if (onErrorCallback) {
+          onErrorCallback({
+            message: ev.message
+          }, ev.id);
+        }
+      })];
+    },
+    enableInterception: function enableInterception() {
+      if (_isInterceptorEnabled) {
+        return;
+      }
+      eventEmitter = new _NativeEventEmitter.default(_Platform.default.OS !== 'ios' ? null : _NativeWebSocketModule.default);
+      WebSocketInterceptor._registerEvents();
+      _NativeWebSocketModule.default.connect = function (url, protocols, options, socketId) {
+        if (connectCallback) {
+          connectCallback(url, protocols, options, socketId);
+        }
+        originalRCTWebSocketConnect.apply(this, arguments);
+      };
+      _NativeWebSocketModule.default.send = function (data, socketId) {
+        if (sendCallback) {
+          sendCallback(data, socketId);
+        }
+        originalRCTWebSocketSend.apply(this, arguments);
+      };
+      _NativeWebSocketModule.default.sendBinary = function (data, socketId) {
+        if (sendCallback) {
+          sendCallback(WebSocketInterceptor._arrayBufferToString(data), socketId);
+        }
+        originalRCTWebSocketSendBinary.apply(this, arguments);
+      };
+      _NativeWebSocketModule.default.close = function () {
+        if (closeCallback) {
+          if (arguments.length === 3) {
+            closeCallback(arguments[0], arguments[1], arguments[2]);
+          } else {
+            closeCallback(null, null, arguments[0]);
+          }
+        }
+        originalRCTWebSocketClose.apply(this, arguments);
+      };
+      _isInterceptorEnabled = true;
+    },
+    _arrayBufferToString: function _arrayBufferToString(data) {
+      var value = _base64Js.default.toByteArray(data).buffer;
+      if (value === undefined || value === null) {
+        return '(no value)';
+      }
+      if (typeof ArrayBuffer !== 'undefined' && typeof Uint8Array !== 'undefined' && value instanceof ArrayBuffer) {
+        return `ArrayBuffer {${String(Array.from(new Uint8Array(value)))}}`;
+      }
+      return value;
+    },
+    disableInterception: function disableInterception() {
+      if (!_isInterceptorEnabled) {
+        return;
+      }
+      _isInterceptorEnabled = false;
+      _NativeWebSocketModule.default.send = originalRCTWebSocketSend;
+      _NativeWebSocketModule.default.sendBinary = originalRCTWebSocketSendBinary;
+      _NativeWebSocketModule.default.close = originalRCTWebSocketClose;
+      _NativeWebSocketModule.default.connect = originalRCTWebSocketConnect;
+      connectCallback = null;
+      closeCallback = null;
+      sendCallback = null;
+      onOpenCallback = null;
+      onMessageCallback = null;
+      onCloseCallback = null;
+      onErrorCallback = null;
+      WebSocketInterceptor._unregisterEvents();
+    }
+  };
+  var _default = exports.default = WebSocketInterceptor;
+},489,[1,221,68,239,238],"../../node_modules/react-native/Libraries/WebSocket/WebSocketInterceptor.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = ReactDevToolsOverlay;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../../../../Libraries/Components/View/View"));
+  var _ReactNativeFeatureFlags = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../../../../Libraries/ReactNative/ReactNativeFeatureFlags"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../../../../../Libraries/StyleSheet/StyleSheet"));
+  var _ElementBox = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./ElementBox"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[6], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[7], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/src/private/devsupport/devmenu/elementinspector/ReactDevToolsOverlay.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var useEffect = React.useEffect,
+    useState = React.useState,
+    useCallback = React.useCallback;
+  function ReactDevToolsOverlay(_ref) {
+    var inspectedViewRef = _ref.inspectedViewRef,
+      reactDevToolsAgent = _ref.reactDevToolsAgent;
+    var _useState = useState(null),
+      _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+      inspected = _useState2[0],
+      setInspected = _useState2[1];
+    var _useState3 = useState(false),
+      _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
+      isInspecting = _useState4[0],
+      setIsInspecting = _useState4[1];
+    useEffect(function () {
+      function cleanup() {
+        reactDevToolsAgent.removeListener('shutdown', cleanup);
+        reactDevToolsAgent.removeListener('startInspectingNative', onStartInspectingNative);
+        reactDevToolsAgent.removeListener('stopInspectingNative', onStopInspectingNative);
+      }
+      function onStartInspectingNative() {
+        setIsInspecting(true);
+      }
+      function onStopInspectingNative() {
+        setIsInspecting(false);
+      }
+      reactDevToolsAgent.addListener('shutdown', cleanup);
+      reactDevToolsAgent.addListener('startInspectingNative', onStartInspectingNative);
+      reactDevToolsAgent.addListener('stopInspectingNative', onStopInspectingNative);
+      return cleanup;
+    }, [reactDevToolsAgent]);
+    var findViewForLocation = useCallback(function (x, y) {
+      _$$_REQUIRE(_dependencyMap[8], "./getInspectorDataForViewAtPoint").default(inspectedViewRef.current, x, y, function (viewData) {
+        var frame = viewData.frame,
+          closestPublicInstance = viewData.closestPublicInstance;
+        if (closestPublicInstance == null) {
+          return false;
+        }
+        reactDevToolsAgent.selectNode(closestPublicInstance);
+        setInspected({
+          frame: frame
+        });
+        return true;
+      });
+    }, [inspectedViewRef, reactDevToolsAgent]);
+    var stopInspecting = useCallback(function () {
+      reactDevToolsAgent.stopInspectingNative(true);
+      setIsInspecting(false);
+      setInspected(null);
+    }, [reactDevToolsAgent]);
+    var onPointerMove = useCallback(function (e) {
+      findViewForLocation(e.nativeEvent.x, e.nativeEvent.y);
+    }, [findViewForLocation]);
+    var onResponderMove = useCallback(function (e) {
+      findViewForLocation(e.nativeEvent.touches[0].locationX, e.nativeEvent.touches[0].locationY);
+    }, [findViewForLocation]);
+    var shouldSetResponder = useCallback(function (e) {
+      onResponderMove(e);
+      return true;
+    }, [onResponderMove]);
+    var highlight = inspected ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_ElementBox.default, {
+      frame: inspected.frame
+    }) : null;
+    if (isInspecting) {
+      var events = _ReactNativeFeatureFlags.default.shouldEmitW3CPointerEvents() ? {
+        onPointerMove: onPointerMove,
+        onPointerDown: onPointerMove,
+        onPointerUp: stopInspecting
+      } : {
+        onStartShouldSetResponder: shouldSetResponder,
+        onResponderMove: onResponderMove,
+        onResponderRelease: stopInspecting
+      };
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, Object.assign({
+        nativeID: "devToolsInspectorOverlay",
+        style: styles.inspector
+      }, events, {
+        children: highlight
+      }));
+    }
+    return highlight;
+  }
+  var styles = _StyleSheet.default.create({
+    inspector: {
+      backgroundColor: 'transparent',
+      position: 'absolute',
+      left: 0,
+      top: 0,
+      right: 0,
+      bottom: 0
+    }
+  });
+},490,[1,34,71,345,6,378,73,171,376],"../../node_modules/react-native/src/private/devsupport/devmenu/elementinspector/ReactDevToolsOverlay.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../Components/View/View"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../StyleSheet/StyleSheet"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[3], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[4], "react/jsx-runtime");
+  var _this = this,
+    _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/ReactNative/AppContainer-prod.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var AppContainer = function AppContainer(_ref) {
+    var children = _ref.children,
+      fabric = _ref.fabric,
+      initialProps = _ref.initialProps,
+      rootTag = _ref.rootTag,
+      WrapperComponent = _ref.WrapperComponent,
+      rootViewStyle = _ref.rootViewStyle;
+    var innerView = children;
+    if (WrapperComponent != null) {
+      innerView = /*#__PURE__*/(0, _jsxRuntime.jsx)(WrapperComponent, {
+        initialProps: initialProps,
+        fabric: fabric === true,
+        children: innerView
+      });
+    }
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[5], "./RootTag").RootTagContext.Provider, {
+      value: (0, _$$_REQUIRE(_dependencyMap[5], "./RootTag").createRootTag)(rootTag),
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+        style: rootViewStyle || styles.root,
+        pointerEvents: "box-none",
+        children: innerView
+      })
+    });
+  };
+  var styles = _StyleSheet.default.create({
+    root: {
+      flex: 1
+    }
+  });
+  var _default = exports.default = AppContainer;
+},491,[1,71,6,73,171,360],"../../node_modules/react-native/Libraries/ReactNative/AppContainer-prod.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.coerceDisplayMode = coerceDisplayMode;
+  exports.default = void 0;
+  var DisplayMode = Object.freeze({
+    VISIBLE: 1,
+    SUSPENDED: 2,
+    HIDDEN: 3
+  });
+  function coerceDisplayMode(value) {
+    switch (value) {
+      case DisplayMode.SUSPENDED:
+        return DisplayMode.SUSPENDED;
+      case DisplayMode.HIDDEN:
+        return DisplayMode.HIDDEN;
+      default:
+        return DisplayMode.VISIBLE;
+    }
+  }
+  var _default = exports.default = DisplayMode;
+},492,[],"../../node_modules/react-native/Libraries/ReactNative/DisplayMode.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = getCachedComponentWithDisplayName;
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var cache = new Map();
+  function getCachedComponentWithDisplayName(displayName) {
+    var ComponentWithDisplayName = cache.get(displayName);
+    if (!ComponentWithDisplayName) {
+      ComponentWithDisplayName = function ComponentWithDisplayName(_ref) {
+        var children = _ref.children;
+        return children;
+      };
+      ComponentWithDisplayName.displayName = displayName;
+      cache.set(displayName, ComponentWithDisplayName);
+    }
+    return ComponentWithDisplayName;
+  }
+},493,[73],"../../node_modules/react-native/Libraries/ReactNative/getCachedComponentWithDebugName.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  function emptyFunction() {}
+  var BackHandler = {
+    exitApp: emptyFunction,
+    addEventListener: function addEventListener(_eventName, _handler) {
+      return {
+        remove: emptyFunction
+      };
+    }
+  };
+  var _default = exports.default = BackHandler;
+},494,[],"../../node_modules/react-native/Libraries/Utilities/BackHandler.ios.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = exports._LogBoxInspectorContainer = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../Components/View/View"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../StyleSheet/StyleSheet"));
+  var LogBoxData = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[8], "./Data/LogBoxData"));
+  var _LogBoxInspector = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./UI/LogBoxInspector"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[10], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[11], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/LogBox/LogBoxInspectorContainer.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var _LogBoxInspectorContainer = exports._LogBoxInspectorContainer = /*#__PURE__*/function (_React$Component) {
+    function _LogBoxInspectorContainer() {
+      var _this;
+      (0, _classCallCheck2.default)(this, _LogBoxInspectorContainer);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _callSuper(this, _LogBoxInspectorContainer, [].concat(args));
+      _this._handleDismiss = function () {
+        var _this$props = _this.props,
+          selectedLogIndex = _this$props.selectedLogIndex,
+          logs = _this$props.logs;
+        var logsArray = Array.from(logs);
+        if (selectedLogIndex != null) {
+          if (logsArray.length - 1 <= 0) {
+            LogBoxData.setSelectedLog(-1);
+          } else if (selectedLogIndex >= logsArray.length - 1) {
+            LogBoxData.setSelectedLog(selectedLogIndex - 1);
+          }
+          LogBoxData.dismiss(logsArray[selectedLogIndex]);
+        }
+      };
+      _this._handleMinimize = function () {
+        LogBoxData.setSelectedLog(-1);
+      };
+      _this._handleSetSelectedLog = function (index) {
+        LogBoxData.setSelectedLog(index);
+      };
+      return _this;
+    }
+    (0, _inherits2.default)(_LogBoxInspectorContainer, _React$Component);
+    return (0, _createClass2.default)(_LogBoxInspectorContainer, [{
+      key: "render",
+      value: function render() {
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+          style: _StyleSheet.default.absoluteFill,
+          children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxInspector.default, {
+            onDismiss: this._handleDismiss,
+            onMinimize: this._handleMinimize,
+            onChangeSelectedIndex: this._handleSetSelectedLog,
+            logs: this.props.logs,
+            selectedIndex: this.props.selectedLogIndex
+          })
+        });
+      }
+    }]);
+  }(React.Component);
+  var _default = exports.default = LogBoxData.withSubscription(_LogBoxInspectorContainer);
+},495,[1,11,12,18,20,23,71,6,155,496,73,171],"../../node_modules/react-native/Libraries/LogBox/LogBoxInspectorContainer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = LogBoxInspector;
+  var _Keyboard = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Components/Keyboard/Keyboard"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../Components/View/View"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/StyleSheet"));
+  var LogBoxData = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[4], "../Data/LogBoxData"));
+  var _LogBoxLog = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../Data/LogBoxLog"));
+  var _LogBoxInspectorBody = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./LogBoxInspectorBody"));
+  var _LogBoxInspectorFooter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./LogBoxInspectorFooter"));
+  var _LogBoxInspectorHeader = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./LogBoxInspectorHeader"));
+  var LogBoxStyle = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[9], "./LogBoxStyle"));
+  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[10], "react"));
+  var React = _react;
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[11], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/LogBox/UI/LogBoxInspector.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function LogBoxInspector(props) {
+    var logs = props.logs,
+      selectedIndex = props.selectedIndex;
+    var log = logs[selectedIndex];
+    (0, _react.useEffect)(function () {
+      if (log) {
+        LogBoxData.symbolicateLogNow(log);
+      }
+    }, [log]);
+    (0, _react.useEffect)(function () {
+      if (logs.length > 1) {
+        var selected = selectedIndex;
+        var lastIndex = logs.length - 1;
+        var prevIndex = selected - 1 < 0 ? lastIndex : selected - 1;
+        var nextIndex = selected + 1 > lastIndex ? 0 : selected + 1;
+        LogBoxData.symbolicateLogLazy(logs[prevIndex]);
+        LogBoxData.symbolicateLogLazy(logs[nextIndex]);
+      }
+    }, [logs, selectedIndex]);
+    (0, _react.useEffect)(function () {
+      _Keyboard.default.dismiss();
+    }, []);
+    function _handleRetry() {
+      LogBoxData.retrySymbolicateLogNow(log);
+    }
+    if (log == null) {
+      return null;
+    }
+    return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_View.default, {
+      id: "logbox_inspector",
+      style: styles.root,
+      children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxInspectorHeader.default, {
+        onSelectIndex: props.onChangeSelectedIndex,
+        selectedIndex: selectedIndex,
+        total: logs.length,
+        level: log.level
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxInspectorBody.default, {
+        log: log,
+        onRetry: _handleRetry
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxInspectorFooter.default, {
+        onDismiss: props.onDismiss,
+        onMinimize: props.onMinimize,
+        level: log.level
+      })]
+    });
+  }
+  var styles = _StyleSheet.default.create({
+    root: {
+      flex: 1,
+      backgroundColor: LogBoxStyle.getTextColor()
+    }
+  });
+},496,[1,434,71,6,155,164,497,510,512,350,73,171],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxInspector.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = LogBoxInspectorBody;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _ScrollView = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../Components/ScrollView/ScrollView"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/StyleSheet"));
+  var _LogBoxLog = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../Data/LogBoxLog"));
+  var _LogBoxInspectorCodeFrame = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./LogBoxInspectorCodeFrame"));
+  var _LogBoxInspectorMessageHeader = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./LogBoxInspectorMessageHeader"));
+  var _LogBoxInspectorReactFrames = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./LogBoxInspectorReactFrames"));
+  var _LogBoxInspectorStackFrames = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./LogBoxInspectorStackFrames"));
+  var LogBoxStyle = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[9], "./LogBoxStyle"));
+  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[10], "react"));
+  var React = _react;
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[11], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/LogBox/UI/LogBoxInspectorBody.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var headerTitleMap = {
+    warn: 'Console Warning',
+    error: 'Console Error',
+    fatal: 'Uncaught Error',
+    syntax: 'Syntax Error',
+    component: 'Render Error'
+  };
+  function LogBoxInspectorBody(props) {
+    var _props$log$type;
+    var _useState = (0, _react.useState)(true),
+      _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+      collapsed = _useState2[0],
+      setCollapsed = _useState2[1];
+    (0, _react.useEffect)(function () {
+      setCollapsed(true);
+    }, [props.log]);
+    var headerTitle = (_props$log$type = props.log.type) != null ? _props$log$type : headerTitleMap[props.log.isComponentError ? 'component' : props.log.level];
+    if (collapsed) {
+      return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_jsxRuntime.Fragment, {
+        children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxInspectorMessageHeader.default, {
+          collapsed: collapsed,
+          onPress: function onPress() {
+            return setCollapsed(!collapsed);
+          },
+          message: props.log.message,
+          level: props.log.level,
+          title: headerTitle
+        }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(_ScrollView.default, {
+          style: styles.scrollBody,
+          children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxInspectorCodeFrame.default, {
+            codeFrame: props.log.codeFrame,
+            componentCodeFrame: props.log.componentCodeFrame
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxInspectorReactFrames.default, {
+            log: props.log
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxInspectorStackFrames.default, {
+            log: props.log,
+            onRetry: props.onRetry
+          })]
+        })]
+      });
+    }
+    return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_ScrollView.default, {
+      style: styles.scrollBody,
+      children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxInspectorMessageHeader.default, {
+        collapsed: collapsed,
+        onPress: function onPress() {
+          return setCollapsed(!collapsed);
+        },
+        message: props.log.message,
+        level: props.log.level,
+        title: headerTitle
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxInspectorCodeFrame.default, {
+        codeFrame: props.log.codeFrame,
+        componentCodeFrame: props.log.componentCodeFrame
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxInspectorReactFrames.default, {
+        log: props.log
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxInspectorStackFrames.default, {
+        log: props.log,
+        onRetry: props.onRetry
+      })]
+    });
+  }
+  var styles = _StyleSheet.default.create({
+    root: {
+      flex: 1,
+      backgroundColor: LogBoxStyle.getTextColor()
+    },
+    scrollBody: {
+      backgroundColor: LogBoxStyle.getBackgroundColor(0.9),
+      flex: 1
+    }
+  });
+},497,[1,34,387,6,164,498,503,504,505,350,73,171],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxInspectorBody.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _ScrollView = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Components/ScrollView/ScrollView"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../Components/View/View"));
+  var _openFileInEditor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../Core/Devtools/openFileInEditor"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../../StyleSheet/StyleSheet"));
+  var _Text = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../../Text/Text"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../../Utilities/Platform"));
+  var LogBoxData = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "../Data/LogBoxData"));
+  var _AnsiHighlight = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./AnsiHighlight"));
+  var _LogBoxButton = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./LogBoxButton"));
+  var _LogBoxInspectorSection = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./LogBoxInspectorSection"));
+  var LogBoxStyle = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[11], "./LogBoxStyle"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[12], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[13], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/LogBox/UI/LogBoxInspectorCodeFrame.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function CodeFrameDisplay(_ref) {
+    var codeFrame = _ref.codeFrame;
+    function getFileName() {
+      var matches = /[^/]*$/.exec(codeFrame.fileName);
+      if (matches && matches.length > 0) {
+        return matches[0];
+      }
+      return codeFrame.fileName;
+    }
+    function getLocation() {
+      var location = codeFrame.location;
+      if (location != null) {
+        return ` (${location.row}:${location.column + 1})`;
+      }
+      return null;
+    }
+    return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_View.default, {
+      style: styles.box,
+      children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+        style: styles.frame,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_ScrollView.default, {
+          horizontal: true,
+          contentContainerStyle: styles.contentContainer,
+          children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_AnsiHighlight.default, {
+            style: styles.content,
+            text: codeFrame.content
+          })
+        })
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxButton.default, {
+        backgroundColor: {
+          default: 'transparent',
+          pressed: LogBoxStyle.getBackgroundDarkColor(1)
+        },
+        style: styles.button,
+        onPress: function onPress() {
+          var _codeFrame$location$r, _codeFrame$location;
+          (0, _openFileInEditor.default)(codeFrame.fileName, (_codeFrame$location$r = (_codeFrame$location = codeFrame.location) == null ? void 0 : _codeFrame$location.row) != null ? _codeFrame$location$r : 0);
+        },
+        children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_Text.default, {
+          style: styles.fileText,
+          children: [getFileName(), getLocation()]
+        })
+      })]
+    });
+  }
+  function LogBoxInspectorCodeFrame(props) {
+    var _this = this;
+    var codeFrame = props.codeFrame,
+      componentCodeFrame = props.componentCodeFrame;
+    var sources = [];
+    if (codeFrame != null) {
+      sources.push(codeFrame);
+    }
+    if (componentCodeFrame != null && (componentCodeFrame == null ? void 0 : componentCodeFrame.content) !== (codeFrame == null ? void 0 : codeFrame.content)) {
+      sources.push(componentCodeFrame);
+    }
+    if (sources.length === 0) {
+      return null;
+    }
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxInspectorSection.default, {
+      heading: sources.length > 1 ? 'Sources' : 'Source',
+      action: /*#__PURE__*/(0, _jsxRuntime.jsx)(AppInfo, {}),
+      children: sources.map(function (frame, index) {
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(CodeFrameDisplay, {
+          codeFrame: frame
+        }, index);
+      })
+    });
+  }
+  function AppInfo() {
+    var appInfo = LogBoxData.getAppInfo();
+    if (appInfo == null) {
+      return null;
+    }
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxButton.default, {
+      backgroundColor: {
+        default: 'transparent',
+        pressed: appInfo.onPress ? LogBoxStyle.getBackgroundColor(1) : 'transparent'
+      },
+      style: appInfoStyles.buildButton,
+      onPress: appInfo.onPress,
+      children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_Text.default, {
+        style: appInfoStyles.text,
+        children: [appInfo.appVersion, " (", appInfo.engine, ")"]
+      })
+    });
+  }
+  var appInfoStyles = _StyleSheet.default.create({
+    text: {
+      color: LogBoxStyle.getTextColor(0.4),
+      fontSize: 12,
+      lineHeight: 12
+    },
+    buildButton: {
+      flex: 0,
+      flexGrow: 0,
+      paddingVertical: 4,
+      paddingHorizontal: 5,
+      borderRadius: 5,
+      marginRight: -8
+    }
+  });
+  var styles = _StyleSheet.default.create({
+    box: {
+      backgroundColor: LogBoxStyle.getBackgroundColor(),
+      marginLeft: 10,
+      marginRight: 10,
+      marginTop: 5,
+      borderRadius: 3
+    },
+    frame: {
+      padding: 10,
+      borderBottomColor: LogBoxStyle.getTextColor(0.1),
+      borderBottomWidth: 1
+    },
+    button: {
+      paddingTop: 10,
+      paddingBottom: 10
+    },
+    contentContainer: {
+      minWidth: '100%'
+    },
+    content: {
+      color: LogBoxStyle.getTextColor(1),
+      fontSize: 12,
+      includeFontPadding: false,
+      lineHeight: 20,
+      fontFamily: _Platform.default.select({
+        android: 'monospace',
+        ios: 'Menlo'
+      })
+    },
+    fileText: {
+      color: LogBoxStyle.getTextColor(0.5),
+      textAlign: 'center',
+      flex: 1,
+      fontSize: 12,
+      includeFontPadding: false,
+      lineHeight: 16,
+      fontFamily: _Platform.default.select({
+        android: 'monospace',
+        ios: 'Menlo'
+      })
+    }
+  });
+  var _default = exports.default = LogBoxInspectorCodeFrame;
+},498,[1,387,71,499,6,352,68,155,500,338,502,350,73,171],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxInspectorCodeFrame.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = openFileInEditor;
+  function openFileInEditor(file, lineNumber) {
+    fetch(_$$_REQUIRE(_dependencyMap[0], "./getDevServer").default().url + 'open-stack-frame', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        file: file,
+        lineNumber: lineNumber
+      })
+    });
+  }
+},499,[168],"../../node_modules/react-native/Libraries/Core/Devtools/openFileInEditor.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = Ansi;
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Components/View/View"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../StyleSheet/StyleSheet"));
+  var _Text = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../Text/Text"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[4], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[5], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/LogBox/UI/AnsiHighlight.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var COLORS = {
+    'ansi-black': 'rgb(27, 27, 27)',
+    'ansi-red': 'rgb(187, 86, 83)',
+    'ansi-green': 'rgb(144, 157, 98)',
+    'ansi-yellow': 'rgb(234, 193, 121)',
+    'ansi-blue': 'rgb(125, 169, 199)',
+    'ansi-magenta': 'rgb(176, 101, 151)',
+    'ansi-cyan': 'rgb(140, 220, 216)',
+    'ansi-bright-black': 'rgb(98, 98, 98)',
+    'ansi-bright-red': 'rgb(187, 86, 83)',
+    'ansi-bright-green': 'rgb(144, 157, 98)',
+    'ansi-bright-yellow': 'rgb(234, 193, 121)',
+    'ansi-bright-blue': 'rgb(125, 169, 199)',
+    'ansi-bright-magenta': 'rgb(176, 101, 151)',
+    'ansi-bright-cyan': 'rgb(140, 220, 216)',
+    'ansi-bright-white': 'rgb(247, 247, 247)'
+  };
+  var LRM = "\u200E";
+  function Ansi(_ref) {
+    var _this = this;
+    var text = _ref.text,
+      style = _ref.style;
+    var commonWhitespaceLength = Infinity;
+    var parsedLines = text.split(/\n/).map(function (line) {
+      return (0, _$$_REQUIRE(_dependencyMap[6], "anser").ansiToJson)(line, {
+        json: true,
+        remove_empty: true,
+        use_classes: true
+      });
+    });
+    parsedLines.map(function (lines) {
+      var _lines$, _match$;
+      var match = lines[2] && ((_lines$ = lines[2]) == null || (_lines$ = _lines$.content) == null ? void 0 : _lines$.match(/^ +/));
+      var whitespaceLength = match && ((_match$ = match[0]) == null ? void 0 : _match$.length) || 0;
+      if (whitespaceLength < commonWhitespaceLength) {
+        commonWhitespaceLength = whitespaceLength;
+      }
+    });
+    var getText = function getText(content, key) {
+      if (key === 0) {
+        return LRM + content;
+      } else if (key === 1) {
+        return content.replace(/\| $/, ' ');
+      } else if (key === 2 && commonWhitespaceLength < Infinity) {
+        return content.slice(commonWhitespaceLength);
+      } else {
+        return content;
+      }
+    };
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+      style: styles.container,
+      children: parsedLines.map(function (items, i) {
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+          style: styles.line,
+          children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+            children: items.map(function (bundle, key) {
+              var textStyle = bundle.fg && COLORS[bundle.fg] ? {
+                backgroundColor: bundle.bg && COLORS[bundle.bg],
+                color: bundle.fg && COLORS[bundle.fg]
+              } : {
+                backgroundColor: bundle.bg && COLORS[bundle.bg]
+              };
+              return /*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+                id: "logbox_codeframe_contents_text",
+                style: [style, textStyle],
+                children: getText(bundle.content, key)
+              }, key);
+            })
+          })
+        }, i);
+      })
+    });
+  }
+  var styles = _StyleSheet.default.create({
+    container: {
+      minWidth: '100%',
+      direction: 'ltr'
+    },
+    line: {
+      flexDirection: 'row'
+    }
+  });
+},500,[1,71,6,352,73,171,501],"../../node_modules/react-native/Libraries/LogBox/UI/AnsiHighlight.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  "use strict";
+
+  // This file was originally written by @drudru (https://github.com/drudru/ansi_up), MIT, 2011
+  var _createClass = function () {
+    function defineProperties(target, props) {
+      for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+      }
+    }
+    return function (Constructor, protoProps, staticProps) {
+      if (protoProps) defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) defineProperties(Constructor, staticProps);
+      return Constructor;
+    };
+  }();
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+  var ANSI_COLORS = [[{
+    color: "0, 0, 0",
+    "class": "ansi-black"
+  }, {
+    color: "187, 0, 0",
+    "class": "ansi-red"
+  }, {
+    color: "0, 187, 0",
+    "class": "ansi-green"
+  }, {
+    color: "187, 187, 0",
+    "class": "ansi-yellow"
+  }, {
+    color: "0, 0, 187",
+    "class": "ansi-blue"
+  }, {
+    color: "187, 0, 187",
+    "class": "ansi-magenta"
+  }, {
+    color: "0, 187, 187",
+    "class": "ansi-cyan"
+  }, {
+    color: "255,255,255",
+    "class": "ansi-white"
+  }], [{
+    color: "85, 85, 85",
+    "class": "ansi-bright-black"
+  }, {
+    color: "255, 85, 85",
+    "class": "ansi-bright-red"
+  }, {
+    color: "0, 255, 0",
+    "class": "ansi-bright-green"
+  }, {
+    color: "255, 255, 85",
+    "class": "ansi-bright-yellow"
+  }, {
+    color: "85, 85, 255",
+    "class": "ansi-bright-blue"
+  }, {
+    color: "255, 85, 255",
+    "class": "ansi-bright-magenta"
+  }, {
+    color: "85, 255, 255",
+    "class": "ansi-bright-cyan"
+  }, {
+    color: "255, 255, 255",
+    "class": "ansi-bright-white"
+  }]];
+  var Anser = function () {
+    _createClass(Anser, null, [{
+      key: "escapeForHtml",
+      /**
+       * Anser.escapeForHtml
+       * Escape the input HTML.
+       *
+       * This does the minimum escaping of text to make it compliant with HTML.
+       * In particular, the '&','<', and '>' characters are escaped. This should
+       * be run prior to `ansiToHtml`.
+       *
+       * @name Anser.escapeForHtml
+       * @function
+       * @param {String} txt The input text (containing the ANSI snippets).
+       * @returns {String} The escaped html.
+       */
+      value: function escapeForHtml(txt) {
+        return new Anser().escapeForHtml(txt);
+      }
+
+      /**
+       * Anser.linkify
+       * Adds the links in the HTML.
+       *
+       * This replaces any links in the text with anchor tags that display the
+       * link. The links should have at least one whitespace character
+       * surrounding it. Also, you should apply this after you have run
+       * `ansiToHtml` on the text.
+       *
+       * @name Anser.linkify
+       * @function
+       * @param {String} txt The input text.
+       * @returns {String} The HTML containing the <a> tags (unescaped).
+       */
+    }, {
+      key: "linkify",
+      value: function linkify(txt) {
+        return new Anser().linkify(txt);
+      }
+
+      /**
+       * Anser.ansiToHtml
+       * This replaces ANSI terminal escape codes with SPAN tags that wrap the
+       * content.
+       *
+       * This function only interprets ANSI SGR (Select Graphic Rendition) codes
+       * that can be represented in HTML.
+       * For example, cursor movement codes are ignored and hidden from output.
+       * The default style uses colors that are very close to the prescribed
+       * standard. The standard assumes that the text will have a black
+       * background. These colors are set as inline styles on the SPAN tags.
+       *
+       * Another option is to set `use_classes: true` in the options argument.
+       * This will instead set classes on the spans so the colors can be set via
+       * CSS. The class names used are of the format `ansi-*-fg/bg` and
+       * `ansi-bright-*-fg/bg` where `*` is the color name,
+       * i.e black/red/green/yellow/blue/magenta/cyan/white.
+       *
+       * @name Anser.ansiToHtml
+       * @function
+       * @param {String} txt The input text.
+       * @param {Object} options The options passed to the ansiToHTML method.
+       * @returns {String} The HTML output.
+       */
+    }, {
+      key: "ansiToHtml",
+      value: function ansiToHtml(txt, options) {
+        return new Anser().ansiToHtml(txt, options);
+      }
+
+      /**
+       * Anser.ansiToJson
+       * Converts ANSI input into JSON output.
+       *
+       * @name Anser.ansiToJson
+       * @function
+       * @param {String} txt The input text.
+       * @param {Object} options The options passed to the ansiToHTML method.
+       * @returns {String} The HTML output.
+       */
+    }, {
+      key: "ansiToJson",
+      value: function ansiToJson(txt, options) {
+        return new Anser().ansiToJson(txt, options);
+      }
+
+      /**
+       * Anser.ansiToText
+       * Converts ANSI input into text output.
+       *
+       * @name Anser.ansiToText
+       * @function
+       * @param {String} txt The input text.
+       * @returns {String} The text output.
+       */
+    }, {
+      key: "ansiToText",
+      value: function ansiToText(txt) {
+        return new Anser().ansiToText(txt);
+      }
+
+      /**
+       * Anser
+       * The `Anser` class.
+       *
+       * @name Anser
+       * @function
+       * @returns {Anser}
+       */
+    }]);
+    function Anser() {
+      _classCallCheck(this, Anser);
+      this.fg = this.bg = this.fg_truecolor = this.bg_truecolor = null;
+      this.bright = 0;
+    }
+
+    /**
+     * setupPalette
+     * Sets up the palette.
+     *
+     * @name setupPalette
+     * @function
+     */
+
+    _createClass(Anser, [{
+      key: "setupPalette",
+      value: function setupPalette() {
+        this.PALETTE_COLORS = [];
+
+        // Index 0..15 : System color
+        for (var i = 0; i < 2; ++i) {
+          for (var j = 0; j < 8; ++j) {
+            this.PALETTE_COLORS.push(ANSI_COLORS[i][j].color);
+          }
+        }
+
+        // Index 16..231 : RGB 6x6x6
+        // https://gist.github.com/jasonm23/2868981#file-xterm-256color-yaml
+        var levels = [0, 95, 135, 175, 215, 255];
+        var format = function format(r, g, b) {
+          return levels[r] + ", " + levels[g] + ", " + levels[b];
+        };
+        var r = void 0,
+          g = void 0,
+          b = void 0;
+        for (var _r = 0; _r < 6; ++_r) {
+          for (var _g = 0; _g < 6; ++_g) {
+            for (var _b = 0; _b < 6; ++_b) {
+              this.PALETTE_COLORS.push(format(_r, _g, _b));
+            }
+          }
+        }
+
+        // Index 232..255 : Grayscale
+        var level = 8;
+        for (var _i = 0; _i < 24; ++_i, level += 10) {
+          this.PALETTE_COLORS.push(format(level, level, level));
+        }
+      }
+
+      /**
+       * escapeForHtml
+       * Escapes the input text.
+       *
+       * @name escapeForHtml
+       * @function
+       * @param {String} txt The input text.
+       * @returns {String} The escpaed HTML output.
+       */
+    }, {
+      key: "escapeForHtml",
+      value: function escapeForHtml(txt) {
+        return txt.replace(/[&<>]/gm, function (str) {
+          return str == "&" ? "&amp;" : str == "<" ? "&lt;" : str == ">" ? "&gt;" : "";
+        });
+      }
+
+      /**
+       * linkify
+       * Adds HTML link elements.
+       *
+       * @name linkify
+       * @function
+       * @param {String} txt The input text.
+       * @returns {String} The HTML output containing link elements.
+       */
+    }, {
+      key: "linkify",
+      value: function linkify(txt) {
+        return txt.replace(/(https?:\/\/[^\s]+)/gm, function (str) {
+          return "<a href=\"" + str + "\">" + str + "</a>";
+        });
+      }
+
+      /**
+       * ansiToHtml
+       * Converts ANSI input into HTML output.
+       *
+       * @name ansiToHtml
+       * @function
+       * @param {String} txt The input text.
+       * @param {Object} options The options passed ot the `process` method.
+       * @returns {String} The HTML output.
+       */
+    }, {
+      key: "ansiToHtml",
+      value: function ansiToHtml(txt, options) {
+        return this.process(txt, options, true);
+      }
+
+      /**
+       * ansiToJson
+       * Converts ANSI input into HTML output.
+       *
+       * @name ansiToJson
+       * @function
+       * @param {String} txt The input text.
+       * @param {Object} options The options passed ot the `process` method.
+       * @returns {String} The JSON output.
+       */
+    }, {
+      key: "ansiToJson",
+      value: function ansiToJson(txt, options) {
+        options = options || {};
+        options.json = true;
+        options.clearLine = false;
+        return this.process(txt, options, true);
+      }
+
+      /**
+       * ansiToText
+       * Converts ANSI input into HTML output.
+       *
+       * @name ansiToText
+       * @function
+       * @param {String} txt The input text.
+       * @returns {String} The text output.
+       */
+    }, {
+      key: "ansiToText",
+      value: function ansiToText(txt) {
+        return this.process(txt, {}, false);
+      }
+
+      /**
+       * process
+       * Processes the input.
+       *
+       * @name process
+       * @function
+       * @param {String} txt The input text.
+       * @param {Object} options An object passed to `processChunk` method, extended with:
+       *
+       *  - `json` (Boolean): If `true`, the result will be an object.
+       *  - `use_classes` (Boolean): If `true`, HTML classes will be appended to the HTML output.
+       *
+       * @param {Boolean} markup
+       */
+    }, {
+      key: "process",
+      value: function process(txt, options, markup) {
+        var _this = this;
+        var self = this;
+        var raw_text_chunks = txt.split(/\033\[/);
+        var first_chunk = raw_text_chunks.shift(); // the first chunk is not the result of the split
+
+        if (options === undefined || options === null) {
+          options = {};
+        }
+        options.clearLine = /\r/.test(txt); // check for Carriage Return
+        var color_chunks = raw_text_chunks.map(function (chunk) {
+          return _this.processChunk(chunk, options, markup);
+        });
+        if (options && options.json) {
+          var first = self.processChunkJson("");
+          first.content = first_chunk;
+          first.clearLine = options.clearLine;
+          color_chunks.unshift(first);
+          if (options.remove_empty) {
+            color_chunks = color_chunks.filter(function (c) {
+              return !c.isEmpty();
+            });
+          }
+          return color_chunks;
+        } else {
+          color_chunks.unshift(first_chunk);
+        }
+        return color_chunks.join("");
+      }
+
+      /**
+       * processChunkJson
+       * Processes the current chunk into json output.
+       *
+       * @name processChunkJson
+       * @function
+       * @param {String} text The input text.
+       * @param {Object} options An object containing the following fields:
+       *
+       *  - `json` (Boolean): If `true`, the result will be an object.
+       *  - `use_classes` (Boolean): If `true`, HTML classes will be appended to the HTML output.
+       *
+       * @param {Boolean} markup If false, the colors will not be parsed.
+       * @return {Object} The result object:
+       *
+       *  - `content` (String): The text.
+       *  - `fg` (String|null): The foreground color.
+       *  - `bg` (String|null): The background color.
+       *  - `fg_truecolor` (String|null): The foreground true color (if 16m color is enabled).
+       *  - `bg_truecolor` (String|null): The background true color (if 16m color is enabled).
+       *  - `clearLine` (Boolean): `true` if a carriageReturn \r was fount at end of line.
+       *  - `was_processed` (Bolean): `true` if the colors were processed, `false` otherwise.
+       *  - `isEmpty` (Function): A function returning `true` if the content is empty, or `false` otherwise.
+       *
+       */
+    }, {
+      key: "processChunkJson",
+      value: function processChunkJson(text, options, markup) {
+        // Are we using classes or styles?
+        options = typeof options == "undefined" ? {} : options;
+        var use_classes = options.use_classes = typeof options.use_classes != "undefined" && options.use_classes;
+        var key = options.key = use_classes ? "class" : "color";
+        var result = {
+          content: text,
+          fg: null,
+          bg: null,
+          fg_truecolor: null,
+          bg_truecolor: null,
+          clearLine: options.clearLine,
+          decoration: null,
+          was_processed: false,
+          isEmpty: function isEmpty() {
+            return !result.content;
+          }
+        };
+
+        // Each "chunk" is the text after the CSI (ESC + "[") and before the next CSI/EOF.
+        //
+        // This regex matches four groups within a chunk.
+        //
+        // The first and third groups match code type.
+        // We supported only SGR command. It has empty first group and "m" in third.
+        //
+        // The second group matches all of the number+semicolon command sequences
+        // before the "m" (or other trailing) character.
+        // These are the graphics or SGR commands.
+        //
+        // The last group is the text (including newlines) that is colored by
+        // the other group"s commands.
+        var matches = text.match(/^([!\x3c-\x3f]*)([\d;]*)([\x20-\x2c]*[\x40-\x7e])([\s\S]*)/m);
+        if (!matches) return result;
+        var orig_txt = result.content = matches[4];
+        var nums = matches[2].split(";");
+
+        // We currently support only "SGR" (Select Graphic Rendition)
+        // Simply ignore if not a SGR command.
+        if (matches[1] !== "" || matches[3] !== "m") {
+          return result;
+        }
+        if (!markup) {
+          return result;
+        }
+        var self = this;
+        self.decoration = null;
+        while (nums.length > 0) {
+          var num_str = nums.shift();
+          var num = parseInt(num_str);
+          if (isNaN(num) || num === 0) {
+            self.fg = self.bg = self.decoration = null;
+          } else if (num === 1) {
+            self.decoration = "bold";
+          } else if (num === 2) {
+            self.decoration = "dim";
+            // Enable code 2 to get string
+          } else if (num == 3) {
+            self.decoration = "italic";
+          } else if (num == 4) {
+            self.decoration = "underline";
+          } else if (num == 5) {
+            self.decoration = "blink";
+          } else if (num === 7) {
+            self.decoration = "reverse";
+          } else if (num === 8) {
+            self.decoration = "hidden";
+            // Enable code 9 to get strikethrough
+          } else if (num === 9) {
+            self.decoration = "strikethrough";
+          } else if (num == 39) {
+            self.fg = null;
+          } else if (num == 49) {
+            self.bg = null;
+            // Foreground color
+          } else if (num >= 30 && num < 38) {
+            self.fg = ANSI_COLORS[0][num % 10][key];
+            // Foreground bright color
+          } else if (num >= 90 && num < 98) {
+            self.fg = ANSI_COLORS[1][num % 10][key];
+            // Background color
+          } else if (num >= 40 && num < 48) {
+            self.bg = ANSI_COLORS[0][num % 10][key];
+            // Background bright color
+          } else if (num >= 100 && num < 108) {
+            self.bg = ANSI_COLORS[1][num % 10][key];
+          } else if (num === 38 || num === 48) {
+            // extend color (38=fg, 48=bg)
+            var is_foreground = num === 38;
+            if (nums.length >= 1) {
+              var mode = nums.shift();
+              if (mode === "5" && nums.length >= 1) {
+                // palette color
+                var palette_index = parseInt(nums.shift());
+                if (palette_index >= 0 && palette_index <= 255) {
+                  if (!use_classes) {
+                    if (!this.PALETTE_COLORS) {
+                      self.setupPalette();
+                    }
+                    if (is_foreground) {
+                      self.fg = this.PALETTE_COLORS[palette_index];
+                    } else {
+                      self.bg = this.PALETTE_COLORS[palette_index];
+                    }
+                  } else {
+                    var klass = palette_index >= 16 ? "ansi-palette-" + palette_index : ANSI_COLORS[palette_index > 7 ? 1 : 0][palette_index % 8]["class"];
+                    if (is_foreground) {
+                      self.fg = klass;
+                    } else {
+                      self.bg = klass;
+                    }
+                  }
+                }
+              } else if (mode === "2" && nums.length >= 3) {
+                // true color
+                var r = parseInt(nums.shift());
+                var g = parseInt(nums.shift());
+                var b = parseInt(nums.shift());
+                if (r >= 0 && r <= 255 && g >= 0 && g <= 255 && b >= 0 && b <= 255) {
+                  var color = r + ", " + g + ", " + b;
+                  if (!use_classes) {
+                    if (is_foreground) {
+                      self.fg = color;
+                    } else {
+                      self.bg = color;
+                    }
+                  } else {
+                    if (is_foreground) {
+                      self.fg = "ansi-truecolor";
+                      self.fg_truecolor = color;
+                    } else {
+                      self.bg = "ansi-truecolor";
+                      self.bg_truecolor = color;
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+        if (self.fg === null && self.bg === null && self.decoration === null) {
+          return result;
+        } else {
+          var styles = [];
+          var classes = [];
+          var data = {};
+          result.fg = self.fg;
+          result.bg = self.bg;
+          result.fg_truecolor = self.fg_truecolor;
+          result.bg_truecolor = self.bg_truecolor;
+          result.decoration = self.decoration;
+          result.was_processed = true;
+          return result;
+        }
+      }
+
+      /**
+       * processChunk
+       * Processes the current chunk of text.
+       *
+       * @name processChunk
+       * @function
+       * @param {String} text The input text.
+       * @param {Object} options An object containing the following fields:
+       *
+       *  - `json` (Boolean): If `true`, the result will be an object.
+       *  - `use_classes` (Boolean): If `true`, HTML classes will be appended to the HTML output.
+       *
+       * @param {Boolean} markup If false, the colors will not be parsed.
+       * @return {Object|String} The result (object if `json` is wanted back or string otherwise).
+       */
+    }, {
+      key: "processChunk",
+      value: function processChunk(text, options, markup) {
+        var _this2 = this;
+        var self = this;
+        options = options || {};
+        var jsonChunk = this.processChunkJson(text, options, markup);
+        if (options.json) {
+          return jsonChunk;
+        }
+        if (jsonChunk.isEmpty()) {
+          return "";
+        }
+        if (!jsonChunk.was_processed) {
+          return jsonChunk.content;
+        }
+        var use_classes = options.use_classes;
+        var styles = [];
+        var classes = [];
+        var data = {};
+        var render_data = function render_data(data) {
+          var fragments = [];
+          var key = void 0;
+          for (key in data) {
+            if (data.hasOwnProperty(key)) {
+              fragments.push("data-" + key + "=\"" + _this2.escapeForHtml(data[key]) + "\"");
+            }
+          }
+          return fragments.length > 0 ? " " + fragments.join(" ") : "";
+        };
+        if (jsonChunk.fg) {
+          if (use_classes) {
+            classes.push(jsonChunk.fg + "-fg");
+            if (jsonChunk.fg_truecolor !== null) {
+              data["ansi-truecolor-fg"] = jsonChunk.fg_truecolor;
+              jsonChunk.fg_truecolor = null;
+            }
+          } else {
+            styles.push("color:rgb(" + jsonChunk.fg + ")");
+          }
+        }
+        if (jsonChunk.bg) {
+          if (use_classes) {
+            classes.push(jsonChunk.bg + "-bg");
+            if (jsonChunk.bg_truecolor !== null) {
+              data["ansi-truecolor-bg"] = jsonChunk.bg_truecolor;
+              jsonChunk.bg_truecolor = null;
+            }
+          } else {
+            styles.push("background-color:rgb(" + jsonChunk.bg + ")");
+          }
+        }
+        if (jsonChunk.decoration) {
+          if (use_classes) {
+            classes.push("ansi-" + jsonChunk.decoration);
+          } else if (jsonChunk.decoration === "bold") {
+            styles.push("font-weight:bold");
+          } else if (jsonChunk.decoration === "dim") {
+            styles.push("opacity:0.5");
+          } else if (jsonChunk.decoration === "italic") {
+            styles.push("font-style:italic");
+            // underline and blink are treated bellow
+          } else if (jsonChunk.decoration === "reverse") {
+            styles.push("filter:invert(100%)");
+          } else if (jsonChunk.decoration === "hidden") {
+            styles.push("visibility:hidden");
+          } else if (jsonChunk.decoration === "strikethrough") {
+            styles.push("text-decoration:line-through");
+          } else {
+            styles.push("text-decoration:" + jsonChunk.decoration);
+          }
+        }
+        if (use_classes) {
+          return "<span class=\"" + classes.join(" ") + "\"" + render_data(data) + ">" + jsonChunk.content + "</span>";
+        } else {
+          return "<span style=\"" + styles.join(";") + "\"" + render_data(data) + ">" + jsonChunk.content + "</span>";
+        }
+      }
+    }]);
+    return Anser;
+  }();
+  ;
+  module.exports = Anser;
+},501,[],"../../node_modules/anser/lib/index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Components/View/View"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../StyleSheet/StyleSheet"));
+  var _Text = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../Text/Text"));
+  var LogBoxStyle = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[4], "./LogBoxStyle"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[5], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[6], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/LogBox/UI/LogBoxInspectorSection.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function LogBoxInspectorSection(props) {
+    return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_View.default, {
+      style: styles.section,
+      children: [/*#__PURE__*/(0, _jsxRuntime.jsxs)(_View.default, {
+        style: styles.heading,
+        children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+          style: styles.headingText,
+          children: props.heading
+        }), props.action]
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+        style: styles.body,
+        children: props.children
+      })]
+    });
+  }
+  var styles = _StyleSheet.default.create({
+    section: {
+      marginTop: 15
+    },
+    heading: {
+      alignItems: 'center',
+      flexDirection: 'row',
+      paddingHorizontal: 12,
+      marginBottom: 10
+    },
+    headingText: {
+      color: LogBoxStyle.getTextColor(1),
+      flex: 1,
+      fontSize: 18,
+      fontWeight: '600',
+      includeFontPadding: false,
+      lineHeight: 20
+    },
+    body: {
+      paddingBottom: 10
+    }
+  });
+  var _default = exports.default = LogBoxInspectorSection;
+},502,[1,71,6,352,350,73,171],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxInspectorSection.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Components/View/View"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../StyleSheet/StyleSheet"));
+  var _Text = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../Text/Text"));
+  var _LogBoxMessage = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./LogBoxMessage"));
+  var LogBoxStyle = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[5], "./LogBoxStyle"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[6], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[7], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/LogBox/UI/LogBoxInspectorMessageHeader.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var SHOW_MORE_MESSAGE_LENGTH = 300;
+  function LogBoxInspectorMessageHeader(props) {
+    function renderShowMore() {
+      if (props.message.content.length < SHOW_MORE_MESSAGE_LENGTH || !props.collapsed) {
+        return null;
+      }
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+        style: messageStyles.collapse,
+        onPress: function onPress() {
+          return props.onPress();
+        },
+        children: "... See More"
+      });
+    }
+    return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_View.default, {
+      style: messageStyles.body,
+      children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+        style: messageStyles.heading,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+          style: [messageStyles.headingText, messageStyles[props.level]],
+          id: "logbox_message_title_text",
+          children: props.title
+        })
+      }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(_Text.default, {
+        style: messageStyles.bodyText,
+        id: "logbox_message_contents_text",
+        children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxMessage.default, {
+          maxLength: props.collapsed ? SHOW_MORE_MESSAGE_LENGTH : Infinity,
+          message: props.message,
+          style: messageStyles.messageText
+        }), renderShowMore()]
+      })]
+    });
+  }
+  var messageStyles = _StyleSheet.default.create({
+    body: {
+      backgroundColor: LogBoxStyle.getBackgroundColor(1),
+      shadowColor: '#000',
+      shadowOffset: {
+        width: 0,
+        height: 2
+      },
+      shadowRadius: 2,
+      shadowOpacity: 0.5,
+      flex: 0
+    },
+    bodyText: {
+      color: LogBoxStyle.getTextColor(1),
+      fontSize: 14,
+      includeFontPadding: false,
+      lineHeight: 20,
+      fontWeight: '500',
+      paddingHorizontal: 12,
+      paddingBottom: 10
+    },
+    heading: {
+      alignItems: 'center',
+      flexDirection: 'row',
+      paddingHorizontal: 12,
+      marginTop: 10,
+      marginBottom: 5
+    },
+    headingText: {
+      flex: 1,
+      fontSize: 20,
+      fontWeight: '600',
+      includeFontPadding: false,
+      lineHeight: 28
+    },
+    warn: {
+      color: LogBoxStyle.getWarningColor(1)
+    },
+    error: {
+      color: LogBoxStyle.getErrorColor(1)
+    },
+    fatal: {
+      color: LogBoxStyle.getFatalColor(1)
+    },
+    syntax: {
+      color: LogBoxStyle.getFatalColor(1)
+    },
+    messageText: {
+      color: LogBoxStyle.getTextColor(0.6)
+    },
+    collapse: {
+      color: LogBoxStyle.getTextColor(0.7),
+      fontSize: 14,
+      fontWeight: '300',
+      lineHeight: 12
+    },
+    button: {
+      paddingVertical: 5,
+      paddingHorizontal: 10,
+      borderRadius: 3
+    }
+  });
+  var _default = exports.default = LogBoxInspectorMessageHeader;
+},503,[1,71,6,352,369,350,73,171],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxInspectorMessageHeader.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../Components/View/View"));
+  var _openFileInEditor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../Core/Devtools/openFileInEditor"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../../StyleSheet/StyleSheet"));
+  var _Text = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../../Text/Text"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../../Utilities/Platform"));
+  var _LogBoxButton = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./LogBoxButton"));
+  var _LogBoxInspectorSection = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./LogBoxInspectorSection"));
+  var LogBoxStyle = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[9], "./LogBoxStyle"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[10], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[11], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/LogBox/UI/LogBoxInspectorReactFrames.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var BEFORE_SLASH_RE = /^(.*)[\\/]/;
+  function getPrettyFileName(path) {
+    var fileName = path.replace(BEFORE_SLASH_RE, '');
+    if (/^index\./.test(fileName)) {
+      var match = path.match(BEFORE_SLASH_RE);
+      if (match) {
+        var pathBeforeSlash = match[1];
+        if (pathBeforeSlash) {
+          var folderName = pathBeforeSlash.replace(BEFORE_SLASH_RE, '');
+          fileName = folderName + '/​' + fileName;
+        }
+      }
+    }
+    return fileName;
+  }
+  function LogBoxInspectorReactFrames(props) {
+    var _this = this;
+    var _React$useState = React.useState(true),
+      _React$useState2 = (0, _slicedToArray2.default)(_React$useState, 2),
+      collapsed = _React$useState2[0],
+      setCollapsed = _React$useState2[1];
+    if (props.log.getAvailableComponentStack() == null || props.log.getAvailableComponentStack().length < 1) {
+      return null;
+    }
+    function getStackList() {
+      if (collapsed) {
+        return props.log.getAvailableComponentStack().slice(0, 3);
+      } else {
+        return props.log.getAvailableComponentStack();
+      }
+    }
+    function getCollapseMessage() {
+      if (props.log.getAvailableComponentStack().length <= 3) {
+        return;
+      }
+      var count = props.log.getAvailableComponentStack().length - 3;
+      if (collapsed) {
+        return `See ${count} more components`;
+      } else {
+        return `Collapse ${count} components`;
+      }
+    }
+    return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_LogBoxInspectorSection.default, {
+      heading: "Component Stack",
+      children: [getStackList().map(function (frame, index) {
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+          style: componentStyles.frameContainer,
+          children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_LogBoxButton.default, {
+            backgroundColor: {
+              default: 'transparent',
+              pressed: LogBoxStyle.getBackgroundColor(1)
+            },
+            onPress: frame.fileName.startsWith('/') ? function () {
+              var _frame$location$row, _frame$location;
+              return (0, _openFileInEditor.default)(frame.fileName, (_frame$location$row = (_frame$location = frame.location) == null ? void 0 : _frame$location.row) != null ? _frame$location$row : 1);
+            } : null,
+            style: componentStyles.frame,
+            children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+              style: componentStyles.component,
+              children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_Text.default, {
+                id: "logbox_component_stack_frame_text",
+                style: componentStyles.frameName,
+                children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+                  style: componentStyles.bracket,
+                  children: '<'
+                }), frame.content, /*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+                  style: componentStyles.bracket,
+                  children: ' />'
+                })]
+              })
+            }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(_Text.default, {
+              style: componentStyles.frameLocation,
+              children: [getPrettyFileName(frame.fileName), frame.location ? `:${frame.location.row}` : '']
+            })]
+          })
+        }, index);
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+        style: componentStyles.collapseContainer,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxButton.default, {
+          backgroundColor: {
+            default: 'transparent',
+            pressed: LogBoxStyle.getBackgroundColor(1)
+          },
+          onPress: function onPress() {
+            return setCollapsed(!collapsed);
+          },
+          style: componentStyles.collapseButton,
+          children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+            style: componentStyles.collapse,
+            children: getCollapseMessage()
+          })
+        })
+      })]
+    });
+  }
+  var componentStyles = _StyleSheet.default.create({
+    collapseContainer: {
+      marginLeft: 15,
+      flexDirection: 'row'
+    },
+    collapseButton: {
+      borderRadius: 5
+    },
+    collapse: {
+      color: LogBoxStyle.getTextColor(0.7),
+      fontSize: 12,
+      fontWeight: '300',
+      lineHeight: 20,
+      marginTop: 0,
+      paddingVertical: 5,
+      paddingHorizontal: 10
+    },
+    frameContainer: {
+      flexDirection: 'row',
+      paddingHorizontal: 15
+    },
+    frame: {
+      flex: 1,
+      paddingVertical: 4,
+      paddingHorizontal: 10,
+      borderRadius: 5
+    },
+    component: {
+      flexDirection: 'row',
+      paddingRight: 10
+    },
+    frameName: {
+      fontFamily: _Platform.default.select({
+        android: 'monospace',
+        ios: 'Menlo'
+      }),
+      color: LogBoxStyle.getTextColor(1),
+      fontSize: 14,
+      includeFontPadding: false,
+      lineHeight: 18
+    },
+    bracket: {
+      fontFamily: _Platform.default.select({
+        android: 'monospace',
+        ios: 'Menlo'
+      }),
+      color: LogBoxStyle.getTextColor(0.4),
+      fontSize: 14,
+      fontWeight: '500',
+      includeFontPadding: false,
+      lineHeight: 18
+    },
+    frameLocation: {
+      color: LogBoxStyle.getTextColor(0.7),
+      fontSize: 12,
+      fontWeight: '300',
+      includeFontPadding: false,
+      lineHeight: 16,
+      paddingLeft: 10
+    }
+  });
+  var _default = exports.default = LogBoxInspectorReactFrames;
+},504,[1,34,71,499,6,352,68,338,502,350,73,171],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxInspectorReactFrames.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  exports.getCollapseMessage = getCollapseMessage;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../Components/View/View"));
+  var _openFileInEditor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../Core/Devtools/openFileInEditor"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../../StyleSheet/StyleSheet"));
+  var _Text = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../../Text/Text"));
+  var _LogBoxButton = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./LogBoxButton"));
+  var _LogBoxInspectorSection = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./LogBoxInspectorSection"));
+  var _LogBoxInspectorSourceMapStatus = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./LogBoxInspectorSourceMapStatus"));
+  var _LogBoxInspectorStackFrame = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./LogBoxInspectorStackFrame"));
+  var LogBoxStyle = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[10], "./LogBoxStyle"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[11], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[12], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/LogBox/UI/LogBoxInspectorStackFrames.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function getCollapseMessage(stackFrames, collapsed) {
+    if (stackFrames.length === 0) {
+      return 'No frames to show';
+    }
+    var collapsedCount = stackFrames.reduce(function (count, _ref) {
+      var collapse = _ref.collapse;
+      if (collapse === true) {
+        return count + 1;
+      }
+      return count;
+    }, 0);
+    if (collapsedCount === 0) {
+      return 'Showing all frames';
+    }
+    var framePlural = `frame${collapsedCount > 1 ? 's' : ''}`;
+    if (collapsedCount === stackFrames.length) {
+      return collapsed ? `See${collapsedCount > 1 ? ' all ' : ' '}${collapsedCount} collapsed ${framePlural}` : `Collapse${collapsedCount > 1 ? ' all ' : ' '}${collapsedCount} ${framePlural}`;
+    } else {
+      return collapsed ? `See ${collapsedCount} more ${framePlural}` : `Collapse ${collapsedCount} ${framePlural}`;
+    }
+  }
+  function LogBoxInspectorStackFrames(props) {
+    var _React$useState = React.useState(function () {
+        return props.log.getAvailableStack().some(function (_ref2) {
+          var collapse = _ref2.collapse;
+          return !collapse;
+        });
+      }),
+      _React$useState2 = (0, _slicedToArray2.default)(_React$useState, 2),
+      collapsed = _React$useState2[0],
+      setCollapsed = _React$useState2[1];
+    function getStackList() {
+      if (collapsed === true) {
+        return props.log.getAvailableStack().filter(function (_ref3) {
+          var collapse = _ref3.collapse;
+          return !collapse;
+        });
+      } else {
+        return props.log.getAvailableStack();
+      }
+    }
+    if (props.log.getAvailableStack().length === 0) {
+      return null;
+    }
+    return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_LogBoxInspectorSection.default, {
+      heading: "Call Stack",
+      action: /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxInspectorSourceMapStatus.default, {
+        onPress: props.log.symbolicated.status === 'FAILED' ? props.onRetry : null,
+        status: props.log.symbolicated.status
+      }),
+      children: [props.log.symbolicated.status !== 'COMPLETE' && /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+        style: stackStyles.hintBox,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+          style: stackStyles.hintText,
+          children: "This call stack is not symbolicated. Some features are unavailable such as viewing the function name or tapping to open files."
+        })
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(StackFrameList, {
+        list: getStackList(),
+        status: props.log.symbolicated.status
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(StackFrameFooter, {
+        onPress: function onPress() {
+          return setCollapsed(!collapsed);
+        },
+        message: getCollapseMessage(props.log.getAvailableStack(), collapsed)
+      })]
+    });
+  }
+  function StackFrameList(props) {
+    var _this = this;
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_jsxRuntime.Fragment, {
+      children: props.list.map(function (frame, index) {
+        var file = frame.file,
+          lineNumber = frame.lineNumber;
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxInspectorStackFrame.default, {
+          frame: frame,
+          onPress: props.status === 'COMPLETE' && file != null && lineNumber != null ? function () {
+            return (0, _openFileInEditor.default)(file, lineNumber);
+          } : null
+        }, index);
+      })
+    });
+  }
+  function StackFrameFooter(props) {
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+      style: stackStyles.collapseContainer,
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxButton.default, {
+        backgroundColor: {
+          default: 'transparent',
+          pressed: LogBoxStyle.getBackgroundColor(1)
+        },
+        onPress: props.onPress,
+        style: stackStyles.collapseButton,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+          style: stackStyles.collapse,
+          children: props.message
+        })
+      })
+    });
+  }
+  var stackStyles = _StyleSheet.default.create({
+    section: {
+      marginTop: 15
+    },
+    heading: {
+      alignItems: 'center',
+      flexDirection: 'row',
+      paddingHorizontal: 12,
+      marginBottom: 10
+    },
+    headingText: {
+      color: LogBoxStyle.getTextColor(1),
+      flex: 1,
+      fontSize: 20,
+      fontWeight: '600',
+      includeFontPadding: false,
+      lineHeight: 20
+    },
+    body: {
+      paddingBottom: 10
+    },
+    bodyText: {
+      color: LogBoxStyle.getTextColor(1),
+      fontSize: 14,
+      includeFontPadding: false,
+      lineHeight: 18,
+      fontWeight: '500',
+      paddingHorizontal: 27
+    },
+    hintText: {
+      color: LogBoxStyle.getTextColor(0.7),
+      fontSize: 13,
+      includeFontPadding: false,
+      lineHeight: 18,
+      fontWeight: '400',
+      marginHorizontal: 10
+    },
+    hintBox: {
+      backgroundColor: LogBoxStyle.getBackgroundColor(),
+      marginHorizontal: 10,
+      paddingHorizontal: 5,
+      paddingVertical: 10,
+      borderRadius: 5,
+      marginBottom: 5
+    },
+    collapseContainer: {
+      marginLeft: 15,
+      flexDirection: 'row'
+    },
+    collapseButton: {
+      borderRadius: 5
+    },
+    collapse: {
+      color: LogBoxStyle.getTextColor(0.7),
+      fontSize: 12,
+      fontWeight: '300',
+      lineHeight: 20,
+      marginTop: 0,
+      paddingHorizontal: 10,
+      paddingVertical: 5
+    }
+  });
+  var _default = exports.default = LogBoxInspectorStackFrames;
+},505,[1,34,71,499,6,352,338,502,506,509,350,73,171],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxInspectorStackFrames.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _Animated = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../Animated/Animated"));
+  var _Easing = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../Animated/Easing"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../../StyleSheet/StyleSheet"));
+  var _Text = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../../Text/Text"));
+  var _LogBoxButton = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./LogBoxButton"));
+  var LogBoxStyle = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "./LogBoxStyle"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[8], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[9], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/LogBox/UI/LogBoxInspectorSourceMapStatus.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function LogBoxInspectorSourceMapStatus(props) {
+    var _React$useState = React.useState({
+        animation: null,
+        rotate: null
+      }),
+      _React$useState2 = (0, _slicedToArray2.default)(_React$useState, 2),
+      state = _React$useState2[0],
+      setState = _React$useState2[1];
+    React.useEffect(function () {
+      if (props.status === 'PENDING') {
+        if (state.animation == null) {
+          var animated = new _Animated.default.Value(0);
+          var animation = _Animated.default.loop(_Animated.default.timing(animated, {
+            duration: 2000,
+            easing: _Easing.default.linear,
+            toValue: 1,
+            useNativeDriver: true
+          }));
+          setState({
+            animation: animation,
+            rotate: animated.interpolate({
+              inputRange: [0, 1],
+              outputRange: ['0deg', '360deg']
+            })
+          });
+          animation.start();
+        }
+      } else {
+        if (state.animation != null) {
+          state.animation.stop();
+          setState({
+            animation: null,
+            rotate: null
+          });
+        }
+      }
+      return function () {
+        if (state.animation != null) {
+          state.animation.stop();
+        }
+      };
+    }, [props.status, state.animation]);
+    var image;
+    var color;
+    switch (props.status) {
+      case 'FAILED':
+        image = _$$_REQUIRE(_dependencyMap[10], "./LogBoxImages/alert-triangle.png");
+        color = LogBoxStyle.getErrorColor(1);
+        break;
+      case 'PENDING':
+        image = _$$_REQUIRE(_dependencyMap[11], "./LogBoxImages/loader.png");
+        color = LogBoxStyle.getWarningColor(1);
+        break;
+    }
+    if (props.status === 'COMPLETE' || image == null) {
+      return null;
+    }
+    return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_LogBoxButton.default, {
+      backgroundColor: {
+        default: 'transparent',
+        pressed: LogBoxStyle.getBackgroundColor(1)
+      },
+      hitSlop: {
+        bottom: 8,
+        left: 8,
+        right: 8,
+        top: 8
+      },
+      onPress: props.onPress,
+      style: styles.root,
+      children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_Animated.default.Image, {
+        source: image,
+        style: [styles.image, {
+          tintColor: color
+        }, state.rotate == null || props.status !== 'PENDING' ? null : {
+          transform: [{
+            rotate: state.rotate
+          }]
+        }]
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+        style: [styles.text, {
+          color: color
+        }],
+        children: "Source Map"
+      })]
+    });
+  }
+  var styles = _StyleSheet.default.create({
+    root: {
+      alignItems: 'center',
+      borderRadius: 12,
+      flexDirection: 'row',
+      height: 24,
+      paddingHorizontal: 8
+    },
+    image: {
+      height: 14,
+      width: 16,
+      marginEnd: 4,
+      tintColor: LogBoxStyle.getTextColor(0.4)
+    },
+    text: {
+      fontSize: 12,
+      includeFontPadding: false,
+      lineHeight: 16
+    }
+  });
+  var _default = exports.default = LogBoxInspectorSourceMapStatus;
+},506,[1,34,442,411,6,352,338,350,73,171,507,508],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxInspectorSourceMapStatus.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  module.exports = _$$_REQUIRE(_dependencyMap[0], "react-native/Libraries/Image/AssetRegistry").registerAsset({
+    "__packager_asset": true,
+    "httpServerLocation": "/assets/../../node_modules/react-native/Libraries/LogBox/UI/LogBoxImages",
+    "width": 48,
+    "height": 42,
+    "scales": [1],
+    "hash": "4f355ba1efca4b9c0e7a6271af047f61",
+    "name": "alert-triangle",
+    "type": "png"
+  });
+},507,[367],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxImages/alert-triangle.png");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  module.exports = _$$_REQUIRE(_dependencyMap[0], "react-native/Libraries/Image/AssetRegistry").registerAsset({
+    "__packager_asset": true,
+    "httpServerLocation": "/assets/../../node_modules/react-native/Libraries/LogBox/UI/LogBoxImages",
+    "width": 44,
+    "height": 44,
+    "scales": [1],
+    "hash": "817aca47ff3cea63020753d336e628a4",
+    "name": "loader",
+    "type": "png"
+  });
+},508,[367],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxImages/loader.png");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Components/View/View"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../StyleSheet/StyleSheet"));
+  var _Text = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../Text/Text"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../../Utilities/Platform"));
+  var _LogBoxButton = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./LogBoxButton"));
+  var LogBoxStyle = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[6], "./LogBoxStyle"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[8], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/LogBox/UI/LogBoxInspectorStackFrame.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function LogBoxInspectorStackFrame(props) {
+    var frame = props.frame,
+      onPress = props.onPress;
+    var column = frame.column != null && parseInt(frame.column, 10);
+    var location = getFileName(frame.file) + (frame.lineNumber != null ? ':' + frame.lineNumber + (column && !isNaN(column) ? ':' + (column + 1) : '') : '');
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+      style: styles.frameContainer,
+      children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_LogBoxButton.default, {
+        backgroundColor: {
+          default: 'transparent',
+          pressed: onPress ? LogBoxStyle.getBackgroundColor(1) : 'transparent'
+        },
+        onPress: onPress,
+        style: styles.frame,
+        children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+          id: "logbox_stack_frame_text",
+          style: [styles.name, frame.collapse === true && styles.dim],
+          children: frame.methodName
+        }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+          ellipsizeMode: "middle",
+          numberOfLines: 1,
+          style: [styles.location, frame.collapse === true && styles.dim],
+          children: location
+        })]
+      })
+    });
+  }
+  function getFileName(file) {
+    if (file == null) {
+      return '<unknown>';
+    }
+    var queryIndex = file.indexOf('?');
+    return file.substring(file.lastIndexOf('/') + 1, queryIndex === -1 ? file.length : queryIndex);
+  }
+  var styles = _StyleSheet.default.create({
+    frameContainer: {
+      flexDirection: 'row',
+      paddingHorizontal: 15
+    },
+    frame: {
+      flex: 1,
+      paddingVertical: 4,
+      paddingHorizontal: 10,
+      borderRadius: 5
+    },
+    lineLocation: {
+      flexDirection: 'row'
+    },
+    name: {
+      color: LogBoxStyle.getTextColor(1),
+      fontSize: 14,
+      includeFontPadding: false,
+      lineHeight: 18,
+      fontWeight: '400',
+      fontFamily: _Platform.default.select({
+        android: 'monospace',
+        ios: 'Menlo'
+      })
+    },
+    location: {
+      color: LogBoxStyle.getTextColor(0.8),
+      fontSize: 12,
+      fontWeight: '300',
+      includeFontPadding: false,
+      lineHeight: 16,
+      paddingLeft: 10
+    },
+    dim: {
+      color: LogBoxStyle.getTextColor(0.4),
+      fontWeight: '300'
+    },
+    line: {
+      color: LogBoxStyle.getTextColor(0.8),
+      fontSize: 12,
+      fontWeight: '300',
+      includeFontPadding: false,
+      lineHeight: 16
+    }
+  });
+  var _default = exports.default = LogBoxInspectorStackFrame;
+},509,[1,71,6,352,68,338,350,73,171],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxInspectorStackFrame.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = LogBoxInspectorFooter;
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Components/View/View"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../StyleSheet/StyleSheet"));
+  var _Text = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../Text/Text"));
+  var _LogBoxInspectorFooterButton = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./LogBoxInspectorFooterButton"));
+  var LogBoxStyle = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[5], "./LogBoxStyle"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[6], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[7], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/LogBox/UI/LogBoxInspectorFooter.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function LogBoxInspectorFooter(props) {
+    if (props.level === 'syntax') {
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+        style: styles.root,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+          style: styles.button,
+          children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+            id: "logbox_dismissable_text",
+            style: styles.syntaxErrorText,
+            children: "This error cannot be dismissed."
+          })
+        })
+      });
+    }
+    return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_View.default, {
+      style: styles.root,
+      children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxInspectorFooterButton.default, {
+        id: "logbox_footer_button_dismiss",
+        text: "Dismiss",
+        onPress: props.onDismiss
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxInspectorFooterButton.default, {
+        id: "logbox_footer_button_minimize",
+        text: "Minimize",
+        onPress: props.onMinimize
+      })]
+    });
+  }
+  var styles = _StyleSheet.default.create({
+    root: {
+      backgroundColor: LogBoxStyle.getBackgroundColor(1),
+      shadowColor: '#000',
+      shadowOffset: {
+        width: 0,
+        height: -2
+      },
+      shadowRadius: 2,
+      shadowOpacity: 0.5,
+      flexDirection: 'row'
+    },
+    button: {
+      flex: 1
+    },
+    syntaxErrorText: {
+      textAlign: 'center',
+      width: '100%',
+      height: 48,
+      fontSize: 14,
+      lineHeight: 20,
+      paddingTop: 20,
+      paddingBottom: 50,
+      fontStyle: 'italic',
+      color: LogBoxStyle.getTextColor(0.6)
+    }
+  });
+},510,[1,71,6,352,511,350,73,171],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxInspectorFooter.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = LogBoxInspectorFooterButton;
+  var _SafeAreaView = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Components/SafeAreaView/SafeAreaView"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../Components/View/View"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/StyleSheet"));
+  var _Text = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../../Text/Text"));
+  var _LogBoxButton = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./LogBoxButton"));
+  var LogBoxStyle = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[6], "./LogBoxStyle"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[8], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/LogBox/UI/LogBoxInspectorFooterButton.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function LogBoxInspectorFooterButton(props) {
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_SafeAreaView.default, {
+      style: styles.button,
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxButton.default, {
+        id: props.id,
+        backgroundColor: {
+          default: 'transparent',
+          pressed: LogBoxStyle.getBackgroundDarkColor()
+        },
+        onPress: props.onPress,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+          style: styles.buttonContent,
+          children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+            style: styles.buttonLabel,
+            children: props.text
+          })
+        })
+      })
+    });
+  }
+  var styles = _StyleSheet.default.create({
+    button: {
+      flex: 1
+    },
+    buttonContent: {
+      alignItems: 'center',
+      height: 48,
+      justifyContent: 'center'
+    },
+    buttonLabel: {
+      color: LogBoxStyle.getTextColor(1),
+      fontSize: 14,
+      includeFontPadding: false,
+      lineHeight: 20
+    }
+  });
+},511,[1,385,71,6,352,338,350,73,171],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxInspectorFooterButton.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = LogBoxInspectorHeader;
+  var _SafeAreaView = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Components/SafeAreaView/SafeAreaView"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../Components/View/View"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/StyleSheet"));
+  var _Text = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../../Text/Text"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../../Utilities/Platform"));
+  var _LogBoxInspectorHeaderButton = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./LogBoxInspectorHeaderButton"));
+  var LogBoxStyle = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "./LogBoxStyle"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[8], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[9], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/LogBox/UI/LogBoxInspectorHeader.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var LogBoxInspectorHeaderSafeArea = _Platform.default.OS === 'android' ? _View.default : _SafeAreaView.default;
+  function LogBoxInspectorHeader(props) {
+    if (props.level === 'syntax') {
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(LogBoxInspectorHeaderSafeArea, {
+        style: styles[props.level],
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+          style: styles.header,
+          children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+            style: styles.title,
+            children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+              style: styles.titleText,
+              id: "logbox_header_title_text",
+              children: "Failed to compile"
+            })
+          })
+        })
+      });
+    }
+    var prevIndex = props.selectedIndex - 1 < 0 ? props.total - 1 : props.selectedIndex - 1;
+    var nextIndex = props.selectedIndex + 1 > props.total - 1 ? 0 : props.selectedIndex + 1;
+    var titleText = `Log ${props.selectedIndex + 1} of ${props.total}`;
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(LogBoxInspectorHeaderSafeArea, {
+      style: styles[props.level],
+      children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_View.default, {
+        style: styles.header,
+        children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxInspectorHeaderButton.default, {
+          id: "logbox_header_button_prev",
+          disabled: props.total <= 1,
+          level: props.level,
+          image: _$$_REQUIRE(_dependencyMap[10], "./LogBoxImages/chevron-left.png"),
+          onPress: function onPress() {
+            return props.onSelectIndex(prevIndex);
+          }
+        }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+          style: styles.title,
+          children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+            style: styles.titleText,
+            id: "logbox_header_title_text",
+            children: titleText
+          })
+        }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxInspectorHeaderButton.default, {
+          id: "logbox_header_button_next",
+          disabled: props.total <= 1,
+          level: props.level,
+          image: _$$_REQUIRE(_dependencyMap[11], "./LogBoxImages/chevron-right.png"),
+          onPress: function onPress() {
+            return props.onSelectIndex(nextIndex);
+          }
+        })]
+      })
+    });
+  }
+  var styles = _StyleSheet.default.create({
+    syntax: {
+      backgroundColor: LogBoxStyle.getFatalColor()
+    },
+    fatal: {
+      backgroundColor: LogBoxStyle.getFatalColor()
+    },
+    warn: {
+      backgroundColor: LogBoxStyle.getWarningColor()
+    },
+    error: {
+      backgroundColor: LogBoxStyle.getErrorColor()
+    },
+    header: {
+      flexDirection: 'row',
+      height: _Platform.default.select({
+        android: 48,
+        ios: 44
+      })
+    },
+    title: {
+      alignItems: 'center',
+      flex: 1,
+      justifyContent: 'center'
+    },
+    titleText: {
+      color: LogBoxStyle.getTextColor(),
+      fontSize: 16,
+      fontWeight: '600',
+      includeFontPadding: false,
+      lineHeight: 20
+    }
+  });
+},512,[1,385,71,6,352,68,513,350,73,171,514,515],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxInspectorHeader.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = LogBoxInspectorHeaderButton;
+  var _Image = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Image/Image"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../StyleSheet/StyleSheet"));
+  var _LogBoxButton = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./LogBoxButton"));
+  var LogBoxStyle = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[4], "./LogBoxStyle"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[5], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[6], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/LogBox/UI/LogBoxInspectorHeaderButton.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var backgroundForLevel = function backgroundForLevel(level) {
+    return {
+      warn: {
+        default: 'transparent',
+        pressed: LogBoxStyle.getWarningDarkColor()
+      },
+      error: {
+        default: 'transparent',
+        pressed: LogBoxStyle.getErrorDarkColor()
+      },
+      fatal: {
+        default: 'transparent',
+        pressed: LogBoxStyle.getFatalDarkColor()
+      },
+      syntax: {
+        default: 'transparent',
+        pressed: LogBoxStyle.getFatalDarkColor()
+      }
+    }[level];
+  };
+  function LogBoxInspectorHeaderButton(props) {
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_LogBoxButton.default, {
+      id: props.id,
+      backgroundColor: backgroundForLevel(props.level),
+      onPress: props.disabled ? null : props.onPress,
+      style: styles.button,
+      children: props.disabled ? null : /*#__PURE__*/(0, _jsxRuntime.jsx)(_Image.default, {
+        source: props.image,
+        style: styles.buttonImage
+      })
+    });
+  }
+  var styles = _StyleSheet.default.create({
+    button: {
+      alignItems: 'center',
+      aspectRatio: 1,
+      justifyContent: 'center',
+      marginTop: 5,
+      marginRight: 6,
+      marginLeft: 6,
+      marginBottom: -8,
+      borderRadius: 3
+    },
+    buttonImage: {
+      height: 14,
+      width: 8,
+      tintColor: LogBoxStyle.getTextColor()
+    }
+  });
+},513,[1,355,6,338,350,73,171],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxInspectorHeaderButton.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  module.exports = _$$_REQUIRE(_dependencyMap[0], "react-native/Libraries/Image/AssetRegistry").registerAsset({
+    "__packager_asset": true,
+    "httpServerLocation": "/assets/../../node_modules/react-native/Libraries/LogBox/UI/LogBoxImages",
+    "width": 16,
+    "height": 28,
+    "scales": [1],
+    "hash": "5b50965d3dfbc518fe50ce36c314a6ec",
+    "name": "chevron-left",
+    "type": "png"
+  });
+},514,[367],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxImages/chevron-left.png");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  module.exports = _$$_REQUIRE(_dependencyMap[0], "react-native/Libraries/Image/AssetRegistry").registerAsset({
+    "__packager_asset": true,
+    "httpServerLocation": "/assets/../../node_modules/react-native/Libraries/LogBox/UI/LogBoxImages",
+    "width": 16,
+    "height": 28,
+    "scales": [1],
+    "hash": "e62addcde857ebdb7342e6b9f1095e97",
+    "name": "chevron-right",
+    "type": "png"
+  });
+},515,[367],"../../node_modules/react-native/Libraries/LogBox/UI/LogBoxImages/chevron-right.png");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  if (process.env.NODE_ENV === 'production') {
+    module.exports = _$$_REQUIRE(_dependencyMap[0], "./cjs/scheduler.native.production.js");
+  } else {
+    module.exports = _$$_REQUIRE(_dependencyMap[1], "./cjs/scheduler.native.development.js");
+  }
+},516,[517,518],"../../node_modules/scheduler/index.native.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  /**
+   * @license React
+   * scheduler.native.production.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 push(heap, node) {
+    var index = heap.length;
+    heap.push(node);
+    a: for (; 0 < index;) {
+      var parentIndex = index - 1 >>> 1,
+        parent = heap[parentIndex];
+      if (0 < compare(parent, node)) heap[parentIndex] = node, heap[index] = parent, index = parentIndex;else break a;
+    }
+  }
+  function peek(heap) {
+    return 0 === heap.length ? null : heap[0];
+  }
+  function pop(heap) {
+    if (0 === heap.length) return null;
+    var first = heap[0],
+      last = heap.pop();
+    if (last !== first) {
+      heap[0] = last;
+      a: for (var index = 0, length = heap.length, halfLength = length >>> 1; index < halfLength;) {
+        var leftIndex = 2 * (index + 1) - 1,
+          left = heap[leftIndex],
+          rightIndex = leftIndex + 1,
+          right = heap[rightIndex];
+        if (0 > compare(left, last)) rightIndex < length && 0 > compare(right, left) ? (heap[index] = right, heap[rightIndex] = last, index = rightIndex) : (heap[index] = left, heap[leftIndex] = last, index = leftIndex);else if (rightIndex < length && 0 > compare(right, last)) heap[index] = right, heap[rightIndex] = last, index = rightIndex;else break a;
+      }
+    }
+    return first;
+  }
+  function compare(a, b) {
+    var diff = a.sortIndex - b.sortIndex;
+    return 0 !== diff ? diff : a.id - b.id;
+  }
+  var getCurrentTime;
+  if ("object" === typeof performance && "function" === typeof performance.now) {
+    var localPerformance = performance;
+    getCurrentTime = function getCurrentTime() {
+      return localPerformance.now();
+    };
+  } else {
+    var localDate = Date,
+      initialTime = localDate.now();
+    getCurrentTime = function getCurrentTime() {
+      return localDate.now() - initialTime;
+    };
+  }
+  var taskQueue = [],
+    timerQueue = [],
+    taskIdCounter = 1,
+    currentTask = null,
+    currentPriorityLevel = 3,
+    isPerformingWork = !1,
+    isHostCallbackScheduled = !1,
+    isHostTimeoutScheduled = !1,
+    needsPaint = !1,
+    localSetTimeout = "function" === typeof setTimeout ? setTimeout : null,
+    localClearTimeout = "function" === typeof clearTimeout ? clearTimeout : null,
+    localSetImmediate = "undefined" !== typeof setImmediate ? setImmediate : null;
+  function advanceTimers(currentTime) {
+    for (var timer = peek(timerQueue); null !== timer;) {
+      if (null === timer.callback) pop(timerQueue);else if (timer.startTime <= currentTime) pop(timerQueue), timer.sortIndex = timer.expirationTime, push(taskQueue, timer);else break;
+      timer = peek(timerQueue);
+    }
+  }
+  function handleTimeout(currentTime) {
+    isHostTimeoutScheduled = !1;
+    advanceTimers(currentTime);
+    if (!isHostCallbackScheduled) if (null !== peek(taskQueue)) isHostCallbackScheduled = !0, isMessageLoopRunning || (isMessageLoopRunning = !0, schedulePerformWorkUntilDeadline());else {
+      var firstTimer = peek(timerQueue);
+      null !== firstTimer && requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
+    }
+  }
+  function unstable_scheduleCallback$1(priorityLevel, callback, options) {
+    var currentTime = getCurrentTime();
+    "object" === typeof options && null !== options ? (options = options.delay, options = "number" === typeof options && 0 < options ? currentTime + options : currentTime) : options = currentTime;
+    switch (priorityLevel) {
+      case 1:
+        var timeout = -1;
+        break;
+      case 2:
+        timeout = 250;
+        break;
+      case 5:
+        timeout = 1073741823;
+        break;
+      case 4:
+        timeout = 1e4;
+        break;
+      default:
+        timeout = 5e3;
+    }
+    timeout = options + timeout;
+    priorityLevel = {
+      id: taskIdCounter++,
+      callback: callback,
+      priorityLevel: priorityLevel,
+      startTime: options,
+      expirationTime: timeout,
+      sortIndex: -1
+    };
+    options > currentTime ? (priorityLevel.sortIndex = options, push(timerQueue, priorityLevel), null === peek(taskQueue) && priorityLevel === peek(timerQueue) && (isHostTimeoutScheduled ? (localClearTimeout(taskTimeoutID), taskTimeoutID = -1) : isHostTimeoutScheduled = !0, requestHostTimeout(handleTimeout, options - currentTime))) : (priorityLevel.sortIndex = timeout, push(taskQueue, priorityLevel), isHostCallbackScheduled || isPerformingWork || (isHostCallbackScheduled = !0, isMessageLoopRunning || (isMessageLoopRunning = !0, schedulePerformWorkUntilDeadline())));
+    return priorityLevel;
+  }
+  function unstable_cancelCallback$1(task) {
+    task.callback = null;
+  }
+  function unstable_getCurrentPriorityLevel$1() {
+    return currentPriorityLevel;
+  }
+  var isMessageLoopRunning = !1,
+    taskTimeoutID = -1,
+    startTime = -1;
+  function shouldYieldToHost() {
+    return needsPaint ? !0 : 5 > getCurrentTime() - startTime ? !1 : !0;
+  }
+  function requestPaint() {
+    needsPaint = !0;
+  }
+  function performWorkUntilDeadline() {
+    needsPaint = !1;
+    if (isMessageLoopRunning) {
+      var currentTime = getCurrentTime();
+      startTime = currentTime;
+      var hasMoreWork = !0;
+      try {
+        a: {
+          isHostCallbackScheduled = !1;
+          isHostTimeoutScheduled && (isHostTimeoutScheduled = !1, localClearTimeout(taskTimeoutID), taskTimeoutID = -1);
+          isPerformingWork = !0;
+          var previousPriorityLevel = currentPriorityLevel;
+          try {
+            b: {
+              advanceTimers(currentTime);
+              for (currentTask = peek(taskQueue); null !== currentTask && !(currentTask.expirationTime > currentTime && shouldYieldToHost());) {
+                var callback = currentTask.callback;
+                if ("function" === typeof callback) {
+                  currentTask.callback = null;
+                  currentPriorityLevel = currentTask.priorityLevel;
+                  var continuationCallback = callback(currentTask.expirationTime <= currentTime);
+                  currentTime = getCurrentTime();
+                  if ("function" === typeof continuationCallback) {
+                    currentTask.callback = continuationCallback;
+                    advanceTimers(currentTime);
+                    hasMoreWork = !0;
+                    break b;
+                  }
+                  currentTask === peek(taskQueue) && pop(taskQueue);
+                  advanceTimers(currentTime);
+                } else pop(taskQueue);
+                currentTask = peek(taskQueue);
+              }
+              if (null !== currentTask) hasMoreWork = !0;else {
+                var firstTimer = peek(timerQueue);
+                null !== firstTimer && requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
+                hasMoreWork = !1;
+              }
+            }
+            break a;
+          } finally {
+            currentTask = null, currentPriorityLevel = previousPriorityLevel, isPerformingWork = !1;
+          }
+          hasMoreWork = void 0;
+        }
+      } finally {
+        hasMoreWork ? schedulePerformWorkUntilDeadline() : isMessageLoopRunning = !1;
+      }
+    }
+  }
+  var schedulePerformWorkUntilDeadline;
+  if ("function" === typeof localSetImmediate) schedulePerformWorkUntilDeadline = function schedulePerformWorkUntilDeadline() {
+    localSetImmediate(performWorkUntilDeadline);
+  };else if ("undefined" !== typeof MessageChannel) {
+    var channel = new MessageChannel(),
+      port = channel.port2;
+    channel.port1.onmessage = performWorkUntilDeadline;
+    schedulePerformWorkUntilDeadline = function schedulePerformWorkUntilDeadline() {
+      port.postMessage(null);
+    };
+  } else schedulePerformWorkUntilDeadline = function schedulePerformWorkUntilDeadline() {
+    localSetTimeout(performWorkUntilDeadline, 0);
+  };
+  function requestHostTimeout(callback, ms) {
+    taskTimeoutID = localSetTimeout(function () {
+      callback(getCurrentTime());
+    }, ms);
+  }
+  var unstable_UserBlockingPriority = "undefined" !== typeof nativeRuntimeScheduler ? nativeRuntimeScheduler.unstable_UserBlockingPriority : 2,
+    unstable_NormalPriority = "undefined" !== typeof nativeRuntimeScheduler ? nativeRuntimeScheduler.unstable_NormalPriority : 3,
+    unstable_LowPriority = "undefined" !== typeof nativeRuntimeScheduler ? nativeRuntimeScheduler.unstable_LowPriority : 4,
+    unstable_ImmediatePriority = "undefined" !== typeof nativeRuntimeScheduler ? nativeRuntimeScheduler.unstable_ImmediatePriority : 1,
+    unstable_scheduleCallback = "undefined" !== typeof nativeRuntimeScheduler ? nativeRuntimeScheduler.unstable_scheduleCallback : unstable_scheduleCallback$1,
+    unstable_cancelCallback = "undefined" !== typeof nativeRuntimeScheduler ? nativeRuntimeScheduler.unstable_cancelCallback : unstable_cancelCallback$1,
+    unstable_getCurrentPriorityLevel = "undefined" !== typeof nativeRuntimeScheduler ? nativeRuntimeScheduler.unstable_getCurrentPriorityLevel : unstable_getCurrentPriorityLevel$1,
+    unstable_shouldYield = "undefined" !== typeof nativeRuntimeScheduler ? nativeRuntimeScheduler.unstable_shouldYield : shouldYieldToHost,
+    unstable_requestPaint = "undefined" !== typeof nativeRuntimeScheduler ? nativeRuntimeScheduler.unstable_requestPaint : requestPaint,
+    unstable_now = "undefined" !== typeof nativeRuntimeScheduler ? nativeRuntimeScheduler.unstable_now : getCurrentTime;
+  function throwNotImplemented() {
+    throw Error("Not implemented.");
+  }
+  exports.unstable_IdlePriority = "undefined" !== typeof nativeRuntimeScheduler ? nativeRuntimeScheduler.unstable_IdlePriority : 5;
+  exports.unstable_ImmediatePriority = unstable_ImmediatePriority;
+  exports.unstable_LowPriority = unstable_LowPriority;
+  exports.unstable_NormalPriority = unstable_NormalPriority;
+  exports.unstable_Profiling = null;
+  exports.unstable_UserBlockingPriority = unstable_UserBlockingPriority;
+  exports.unstable_cancelCallback = unstable_cancelCallback;
+  exports.unstable_forceFrameRate = throwNotImplemented;
+  exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
+  exports.unstable_next = throwNotImplemented;
+  exports.unstable_now = unstable_now;
+  exports.unstable_requestPaint = unstable_requestPaint;
+  exports.unstable_runWithPriority = throwNotImplemented;
+  exports.unstable_scheduleCallback = unstable_scheduleCallback;
+  exports.unstable_shouldYield = unstable_shouldYield;
+  exports.unstable_wrapCallback = throwNotImplemented;
+},517,[],"../../node_modules/scheduler/cjs/scheduler.native.production.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  /**
+   * @license React
+   * scheduler.native.development.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";
+
+  "production" !== process.env.NODE_ENV && function () {
+    function performWorkUntilDeadline() {
+      needsPaint = !1;
+      if (isMessageLoopRunning) {
+        var currentTime = getCurrentTime();
+        startTime = currentTime;
+        var hasMoreWork = !0;
+        try {
+          a: {
+            isHostCallbackScheduled = !1;
+            isHostTimeoutScheduled && (isHostTimeoutScheduled = !1, localClearTimeout(taskTimeoutID), taskTimeoutID = -1);
+            isPerformingWork = !0;
+            var previousPriorityLevel = currentPriorityLevel;
+            try {
+              b: {
+                advanceTimers(currentTime);
+                for (currentTask = peek(taskQueue); null !== currentTask && !(currentTask.expirationTime > currentTime && shouldYieldToHost());) {
+                  var callback = currentTask.callback;
+                  if ("function" === typeof callback) {
+                    currentTask.callback = null;
+                    currentPriorityLevel = currentTask.priorityLevel;
+                    var continuationCallback = callback(currentTask.expirationTime <= currentTime);
+                    currentTime = getCurrentTime();
+                    if ("function" === typeof continuationCallback) {
+                      currentTask.callback = continuationCallback;
+                      advanceTimers(currentTime);
+                      hasMoreWork = !0;
+                      break b;
+                    }
+                    currentTask === peek(taskQueue) && pop(taskQueue);
+                    advanceTimers(currentTime);
+                  } else pop(taskQueue);
+                  currentTask = peek(taskQueue);
+                }
+                if (null !== currentTask) hasMoreWork = !0;else {
+                  var firstTimer = peek(timerQueue);
+                  null !== firstTimer && requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
+                  hasMoreWork = !1;
+                }
+              }
+              break a;
+            } finally {
+              currentTask = null, currentPriorityLevel = previousPriorityLevel, isPerformingWork = !1;
+            }
+            hasMoreWork = void 0;
+          }
+        } finally {
+          hasMoreWork ? schedulePerformWorkUntilDeadline() : isMessageLoopRunning = !1;
+        }
+      }
+    }
+    function push(heap, node) {
+      var index = heap.length;
+      heap.push(node);
+      a: for (; 0 < index;) {
+        var parentIndex = index - 1 >>> 1,
+          parent = heap[parentIndex];
+        if (0 < compare(parent, node)) heap[parentIndex] = node, heap[index] = parent, index = parentIndex;else break a;
+      }
+    }
+    function peek(heap) {
+      return 0 === heap.length ? null : heap[0];
+    }
+    function pop(heap) {
+      if (0 === heap.length) return null;
+      var first = heap[0],
+        last = heap.pop();
+      if (last !== first) {
+        heap[0] = last;
+        a: for (var index = 0, length = heap.length, halfLength = length >>> 1; index < halfLength;) {
+          var leftIndex = 2 * (index + 1) - 1,
+            left = heap[leftIndex],
+            rightIndex = leftIndex + 1,
+            right = heap[rightIndex];
+          if (0 > compare(left, last)) rightIndex < length && 0 > compare(right, left) ? (heap[index] = right, heap[rightIndex] = last, index = rightIndex) : (heap[index] = left, heap[leftIndex] = last, index = leftIndex);else if (rightIndex < length && 0 > compare(right, last)) heap[index] = right, heap[rightIndex] = last, index = rightIndex;else break a;
+        }
+      }
+      return first;
+    }
+    function compare(a, b) {
+      var diff = a.sortIndex - b.sortIndex;
+      return 0 !== diff ? diff : a.id - b.id;
+    }
+    function advanceTimers(currentTime) {
+      for (var timer = peek(timerQueue); null !== timer;) {
+        if (null === timer.callback) pop(timerQueue);else if (timer.startTime <= currentTime) pop(timerQueue), timer.sortIndex = timer.expirationTime, push(taskQueue, timer);else break;
+        timer = peek(timerQueue);
+      }
+    }
+    function handleTimeout(currentTime) {
+      isHostTimeoutScheduled = !1;
+      advanceTimers(currentTime);
+      if (!isHostCallbackScheduled) if (null !== peek(taskQueue)) isHostCallbackScheduled = !0, isMessageLoopRunning || (isMessageLoopRunning = !0, schedulePerformWorkUntilDeadline());else {
+        var firstTimer = peek(timerQueue);
+        null !== firstTimer && requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
+      }
+    }
+    function unstable_scheduleCallback$1(priorityLevel, callback, options) {
+      var currentTime = getCurrentTime();
+      "object" === typeof options && null !== options ? (options = options.delay, options = "number" === typeof options && 0 < options ? currentTime + options : currentTime) : options = currentTime;
+      switch (priorityLevel) {
+        case 1:
+          var timeout = -1;
+          break;
+        case 2:
+          timeout = 250;
+          break;
+        case 5:
+          timeout = 1073741823;
+          break;
+        case 4:
+          timeout = 1e4;
+          break;
+        default:
+          timeout = 5e3;
+      }
+      timeout = options + timeout;
+      priorityLevel = {
+        id: taskIdCounter++,
+        callback: callback,
+        priorityLevel: priorityLevel,
+        startTime: options,
+        expirationTime: timeout,
+        sortIndex: -1
+      };
+      options > currentTime ? (priorityLevel.sortIndex = options, push(timerQueue, priorityLevel), null === peek(taskQueue) && priorityLevel === peek(timerQueue) && (isHostTimeoutScheduled ? (localClearTimeout(taskTimeoutID), taskTimeoutID = -1) : isHostTimeoutScheduled = !0, requestHostTimeout(handleTimeout, options - currentTime))) : (priorityLevel.sortIndex = timeout, push(taskQueue, priorityLevel), isHostCallbackScheduled || isPerformingWork || (isHostCallbackScheduled = !0, isMessageLoopRunning || (isMessageLoopRunning = !0, schedulePerformWorkUntilDeadline())));
+      return priorityLevel;
+    }
+    function unstable_cancelCallback$1(task) {
+      task.callback = null;
+    }
+    function unstable_getCurrentPriorityLevel$1() {
+      return currentPriorityLevel;
+    }
+    function shouldYieldToHost() {
+      return needsPaint ? !0 : getCurrentTime() - startTime < frameInterval ? !1 : !0;
+    }
+    function requestPaint() {
+      needsPaint = !0;
+    }
+    function requestHostTimeout(callback, ms) {
+      taskTimeoutID = localSetTimeout(function () {
+        callback(getCurrentTime());
+      }, ms);
+    }
+    function throwNotImplemented() {
+      throw Error("Not implemented.");
+    }
+    if ("object" === typeof performance && "function" === typeof performance.now) {
+      var localPerformance = performance;
+      var getCurrentTime = function getCurrentTime() {
+        return localPerformance.now();
+      };
+    } else {
+      var localDate = Date,
+        initialTime = localDate.now();
+      getCurrentTime = function getCurrentTime() {
+        return localDate.now() - initialTime;
+      };
+    }
+    var taskQueue = [],
+      timerQueue = [],
+      taskIdCounter = 1,
+      currentTask = null,
+      currentPriorityLevel = 3,
+      isPerformingWork = !1,
+      isHostCallbackScheduled = !1,
+      isHostTimeoutScheduled = !1,
+      needsPaint = !1,
+      localSetTimeout = "function" === typeof setTimeout ? setTimeout : null,
+      localClearTimeout = "function" === typeof clearTimeout ? clearTimeout : null,
+      localSetImmediate = "undefined" !== typeof setImmediate ? setImmediate : null,
+      isMessageLoopRunning = !1,
+      taskTimeoutID = -1,
+      frameInterval = 5,
+      startTime = -1;
+    if ("function" === typeof localSetImmediate) var schedulePerformWorkUntilDeadline = function schedulePerformWorkUntilDeadline() {
+      localSetImmediate(performWorkUntilDeadline);
+    };else if ("undefined" !== typeof MessageChannel) {
+      var channel = new MessageChannel(),
+        port = channel.port2;
+      channel.port1.onmessage = performWorkUntilDeadline;
+      schedulePerformWorkUntilDeadline = function schedulePerformWorkUntilDeadline() {
+        port.postMessage(null);
+      };
+    } else schedulePerformWorkUntilDeadline = function schedulePerformWorkUntilDeadline() {
+      localSetTimeout(performWorkUntilDeadline, 0);
+    };
+    channel = "undefined" !== typeof nativeRuntimeScheduler ? nativeRuntimeScheduler.unstable_UserBlockingPriority : 2;
+    var unstable_NormalPriority = "undefined" !== typeof nativeRuntimeScheduler ? nativeRuntimeScheduler.unstable_NormalPriority : 3,
+      unstable_LowPriority = "undefined" !== typeof nativeRuntimeScheduler ? nativeRuntimeScheduler.unstable_LowPriority : 4,
+      unstable_ImmediatePriority = "undefined" !== typeof nativeRuntimeScheduler ? nativeRuntimeScheduler.unstable_ImmediatePriority : 1,
+      unstable_scheduleCallback = "undefined" !== typeof nativeRuntimeScheduler ? nativeRuntimeScheduler.unstable_scheduleCallback : unstable_scheduleCallback$1,
+      unstable_cancelCallback = "undefined" !== typeof nativeRuntimeScheduler ? nativeRuntimeScheduler.unstable_cancelCallback : unstable_cancelCallback$1,
+      unstable_getCurrentPriorityLevel = "undefined" !== typeof nativeRuntimeScheduler ? nativeRuntimeScheduler.unstable_getCurrentPriorityLevel : unstable_getCurrentPriorityLevel$1,
+      unstable_shouldYield = "undefined" !== typeof nativeRuntimeScheduler ? nativeRuntimeScheduler.unstable_shouldYield : shouldYieldToHost,
+      unstable_requestPaint = "undefined" !== typeof nativeRuntimeScheduler ? nativeRuntimeScheduler.unstable_requestPaint : requestPaint,
+      unstable_now = "undefined" !== typeof nativeRuntimeScheduler ? nativeRuntimeScheduler.unstable_now : getCurrentTime;
+    exports.unstable_IdlePriority = "undefined" !== typeof nativeRuntimeScheduler ? nativeRuntimeScheduler.unstable_IdlePriority : 5;
+    exports.unstable_ImmediatePriority = unstable_ImmediatePriority;
+    exports.unstable_LowPriority = unstable_LowPriority;
+    exports.unstable_NormalPriority = unstable_NormalPriority;
+    exports.unstable_Profiling = null;
+    exports.unstable_UserBlockingPriority = channel;
+    exports.unstable_cancelCallback = unstable_cancelCallback;
+    exports.unstable_forceFrameRate = throwNotImplemented;
+    exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
+    exports.unstable_next = throwNotImplemented;
+    exports.unstable_now = unstable_now;
+    exports.unstable_requestPaint = unstable_requestPaint;
+    exports.unstable_runWithPriority = throwNotImplemented;
+    exports.unstable_scheduleCallback = unstable_scheduleCallback;
+    exports.unstable_shouldYield = unstable_shouldYield;
+    exports.unstable_wrapCallback = throwNotImplemented;
+  }();
+},518,[],"../../node_modules/scheduler/cjs/scheduler.native.development.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  /**
+   * 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.
+   *
+   * 
+   * @nolint
+   * @preventMunge
+   * @generated SignedSource<<8c6274bec0d166bb311325a3c6c468b5>>
+   *
+   * This file was sync'd from the facebook/react repository.
+   */
+
+  "use strict";
+
+  _$$_REQUIRE(_dependencyMap[0], "react-native/Libraries/ReactPrivate/ReactNativePrivateInitializeCore");
+  var React = _$$_REQUIRE(_dependencyMap[1], "react"),
+    isArrayImpl = Array.isArray,
+    ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,
+    assign = Object.assign,
+    prefix,
+    suffix;
+  function describeBuiltInComponentFrame(name) {
+    if (void 0 === prefix) try {
+      throw Error();
+    } catch (x) {
+      var match = x.stack.trim().match(/\n( *(at )?)/);
+      prefix = match && match[1] || "";
+      suffix = -1 < x.stack.indexOf("\n    at") ? " (<anonymous>)" : -1 < x.stack.indexOf("@") ? "@unknown:0:0" : "";
+    }
+    return "\n" + prefix + name + suffix;
+  }
+  var reentry = !1;
+  function describeNativeComponentFrame(fn, construct) {
+    if (!fn || reentry) return "";
+    reentry = !0;
+    var previousPrepareStackTrace = Error.prepareStackTrace;
+    Error.prepareStackTrace = void 0;
+    try {
+      var RunInRootFrame = {
+        DetermineComponentFrameRoot: function DetermineComponentFrameRoot() {
+          try {
+            if (construct) {
+              var Fake = function Fake() {
+                throw Error();
+              };
+              Object.defineProperty(Fake.prototype, "props", {
+                set: function set() {
+                  throw Error();
+                }
+              });
+              if ("object" === typeof Reflect && Reflect.construct) {
+                try {
+                  Reflect.construct(Fake, []);
+                } catch (x) {
+                  var control = x;
+                }
+                Reflect.construct(fn, [], Fake);
+              } else {
+                try {
+                  Fake.call();
+                } catch (x$1) {
+                  control = x$1;
+                }
+                fn.call(Fake.prototype);
+              }
+            } else {
+              try {
+                throw Error();
+              } catch (x$2) {
+                control = x$2;
+              }
+              (Fake = fn()) && "function" === typeof Fake.catch && Fake.catch(function () {});
+            }
+          } catch (sample) {
+            if (sample && control && "string" === typeof sample.stack) return [sample.stack, control.stack];
+          }
+          return [null, null];
+        }
+      };
+      RunInRootFrame.DetermineComponentFrameRoot.displayName = "DetermineComponentFrameRoot";
+      var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, "name");
+      namePropDescriptor && namePropDescriptor.configurable && Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, "name", {
+        value: "DetermineComponentFrameRoot"
+      });
+      var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+        sampleStack = _RunInRootFrame$Deter[0],
+        controlStack = _RunInRootFrame$Deter[1];
+      if (sampleStack && controlStack) {
+        var sampleLines = sampleStack.split("\n"),
+          controlLines = controlStack.split("\n");
+        for (namePropDescriptor = RunInRootFrame = 0; RunInRootFrame < sampleLines.length && !sampleLines[RunInRootFrame].includes("DetermineComponentFrameRoot");) RunInRootFrame++;
+        for (; namePropDescriptor < controlLines.length && !controlLines[namePropDescriptor].includes("DetermineComponentFrameRoot");) namePropDescriptor++;
+        if (RunInRootFrame === sampleLines.length || namePropDescriptor === controlLines.length) for (RunInRootFrame = sampleLines.length - 1, namePropDescriptor = controlLines.length - 1; 1 <= RunInRootFrame && 0 <= namePropDescriptor && sampleLines[RunInRootFrame] !== controlLines[namePropDescriptor];) namePropDescriptor--;
+        for (; 1 <= RunInRootFrame && 0 <= namePropDescriptor; RunInRootFrame--, namePropDescriptor--) if (sampleLines[RunInRootFrame] !== controlLines[namePropDescriptor]) {
+          if (1 !== RunInRootFrame || 1 !== namePropDescriptor) {
+            do if (RunInRootFrame--, namePropDescriptor--, 0 > namePropDescriptor || sampleLines[RunInRootFrame] !== controlLines[namePropDescriptor]) {
+              var frame = "\n" + sampleLines[RunInRootFrame].replace(" at new ", " at ");
+              fn.displayName && frame.includes("<anonymous>") && (frame = frame.replace("<anonymous>", fn.displayName));
+              return frame;
+            } while (1 <= RunInRootFrame && 0 <= namePropDescriptor);
+          }
+          break;
+        }
+      }
+    } finally {
+      reentry = !1, Error.prepareStackTrace = previousPrepareStackTrace;
+    }
+    return (previousPrepareStackTrace = fn ? fn.displayName || fn.name : "") ? describeBuiltInComponentFrame(previousPrepareStackTrace) : "";
+  }
+  function describeFiber(fiber) {
+    switch (fiber.tag) {
+      case 26:
+      case 27:
+      case 5:
+        return describeBuiltInComponentFrame(fiber.type);
+      case 16:
+        return describeBuiltInComponentFrame("Lazy");
+      case 13:
+        return describeBuiltInComponentFrame("Suspense");
+      case 19:
+        return describeBuiltInComponentFrame("SuspenseList");
+      case 0:
+      case 15:
+        return describeNativeComponentFrame(fiber.type, !1);
+      case 11:
+        return describeNativeComponentFrame(fiber.type.render, !1);
+      case 1:
+        return describeNativeComponentFrame(fiber.type, !0);
+      case 31:
+        return describeBuiltInComponentFrame("Activity");
+      default:
+        return "";
+    }
+  }
+  function getStackByFiberInDevAndProd(workInProgress) {
+    try {
+      var info = "";
+      do info += describeFiber(workInProgress), workInProgress = workInProgress.return; while (workInProgress);
+      return info;
+    } catch (x) {
+      return "\nError generating stack: " + x.message + "\n" + x.stack;
+    }
+  }
+  var REACT_LEGACY_ELEMENT_TYPE = Symbol.for("react.element"),
+    REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
+    REACT_PORTAL_TYPE = Symbol.for("react.portal"),
+    REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
+    REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
+    REACT_PROFILER_TYPE = Symbol.for("react.profiler"),
+    REACT_PROVIDER_TYPE = Symbol.for("react.provider"),
+    REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
+    REACT_CONTEXT_TYPE = Symbol.for("react.context"),
+    REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
+    REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
+    REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
+    REACT_MEMO_TYPE = Symbol.for("react.memo"),
+    REACT_LAZY_TYPE = Symbol.for("react.lazy");
+  Symbol.for("react.scope");
+  var REACT_ACTIVITY_TYPE = Symbol.for("react.activity");
+  Symbol.for("react.legacy_hidden");
+  Symbol.for("react.tracing_marker");
+  var REACT_MEMO_CACHE_SENTINEL = Symbol.for("react.memo_cache_sentinel");
+  Symbol.for("react.view_transition");
+  var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+  function getIteratorFn(maybeIterable) {
+    if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
+    maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
+    return "function" === typeof maybeIterable ? maybeIterable : null;
+  }
+  var REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
+  function getComponentNameFromType(type) {
+    if (null == type) return null;
+    if ("function" === typeof type) return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+    if ("string" === typeof type) return type;
+    switch (type) {
+      case REACT_FRAGMENT_TYPE:
+        return "Fragment";
+      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_ACTIVITY_TYPE:
+        return "Activity";
+    }
+    if ("object" === typeof type) switch (type.$$typeof) {
+      case REACT_PORTAL_TYPE:
+        return "Portal";
+      case REACT_CONTEXT_TYPE:
+        return (type.displayName || "Context") + ".Provider";
+      case REACT_CONSUMER_TYPE:
+        return (type._context.displayName || "Context") + ".Consumer";
+      case REACT_FORWARD_REF_TYPE:
+        var innerType = type.render;
+        type = type.displayName;
+        type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
+        return type;
+      case REACT_MEMO_TYPE:
+        return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
+      case REACT_LAZY_TYPE:
+        innerType = type._payload;
+        type = type._init;
+        try {
+          return getComponentNameFromType(type(innerType));
+        } catch (x) {}
+    }
+    return null;
+  }
+  var hasError = !1,
+    caughtError = null,
+    getFiberCurrentPropsFromNode$1 = null,
+    getInstanceFromNode$1 = null,
+    getNodeFromInstance$1 = null;
+  function executeDispatch(event, listener, inst) {
+    event.currentTarget = getNodeFromInstance$1(inst);
+    try {
+      listener(event);
+    } catch (error) {
+      hasError || (hasError = !0, caughtError = error);
+    }
+    event.currentTarget = null;
+  }
+  function executeDirectDispatch(event) {
+    var dispatchListener = event._dispatchListeners,
+      dispatchInstance = event._dispatchInstances;
+    if (isArrayImpl(dispatchListener)) throw Error("Invalid `event`.");
+    event.currentTarget = dispatchListener ? getNodeFromInstance$1(dispatchInstance) : null;
+    dispatchListener = dispatchListener ? dispatchListener(event) : null;
+    event.currentTarget = null;
+    event._dispatchListeners = null;
+    event._dispatchInstances = null;
+    return dispatchListener;
+  }
+  function functionThatReturnsTrue() {
+    return !0;
+  }
+  function functionThatReturnsFalse() {
+    return !1;
+  }
+  function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
+    this.dispatchConfig = dispatchConfig;
+    this._targetInst = targetInst;
+    this.nativeEvent = nativeEvent;
+    this._dispatchInstances = this._dispatchListeners = null;
+    dispatchConfig = this.constructor.Interface;
+    for (var propName in dispatchConfig) dispatchConfig.hasOwnProperty(propName) && ((targetInst = dispatchConfig[propName]) ? this[propName] = targetInst(nativeEvent) : "target" === propName ? this.target = nativeEventTarget : this[propName] = nativeEvent[propName]);
+    this.isDefaultPrevented = (null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : !1 === nativeEvent.returnValue) ? functionThatReturnsTrue : functionThatReturnsFalse;
+    this.isPropagationStopped = functionThatReturnsFalse;
+    return this;
+  }
+  assign(SyntheticEvent.prototype, {
+    preventDefault: function preventDefault() {
+      this.defaultPrevented = !0;
+      var event = this.nativeEvent;
+      event && (event.preventDefault ? event.preventDefault() : "unknown" !== typeof event.returnValue && (event.returnValue = !1), this.isDefaultPrevented = functionThatReturnsTrue);
+    },
+    stopPropagation: function stopPropagation() {
+      var event = this.nativeEvent;
+      event && (event.stopPropagation ? event.stopPropagation() : "unknown" !== typeof event.cancelBubble && (event.cancelBubble = !0), this.isPropagationStopped = functionThatReturnsTrue);
+    },
+    persist: function persist() {
+      this.isPersistent = functionThatReturnsTrue;
+    },
+    isPersistent: functionThatReturnsFalse,
+    destructor: function destructor() {
+      var Interface = this.constructor.Interface,
+        propName;
+      for (propName in Interface) this[propName] = null;
+      this.nativeEvent = this._targetInst = this.dispatchConfig = null;
+      this.isPropagationStopped = this.isDefaultPrevented = functionThatReturnsFalse;
+      this._dispatchInstances = this._dispatchListeners = null;
+    }
+  });
+  SyntheticEvent.Interface = {
+    type: null,
+    target: null,
+    currentTarget: function currentTarget() {
+      return null;
+    },
+    eventPhase: null,
+    bubbles: null,
+    cancelable: null,
+    timeStamp: function timeStamp(event) {
+      return event.timeStamp || Date.now();
+    },
+    defaultPrevented: null,
+    isTrusted: null
+  };
+  SyntheticEvent.extend = function (Interface) {
+    function E() {}
+    function Class() {
+      return Super.apply(this, arguments);
+    }
+    var Super = this;
+    E.prototype = Super.prototype;
+    var prototype = new E();
+    assign(prototype, Class.prototype);
+    Class.prototype = prototype;
+    Class.prototype.constructor = Class;
+    Class.Interface = assign({}, Super.Interface, Interface);
+    Class.extend = Super.extend;
+    addEventPoolingTo(Class);
+    return Class;
+  };
+  addEventPoolingTo(SyntheticEvent);
+  function createOrGetPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
+    if (this.eventPool.length) {
+      var instance = this.eventPool.pop();
+      this.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst);
+      return instance;
+    }
+    return new this(dispatchConfig, targetInst, nativeEvent, nativeInst);
+  }
+  function releasePooledEvent(event) {
+    if (!(event instanceof this)) throw Error("Trying to release an event instance into a pool of a different type.");
+    event.destructor();
+    10 > this.eventPool.length && this.eventPool.push(event);
+  }
+  function addEventPoolingTo(EventConstructor) {
+    EventConstructor.getPooled = createOrGetPooledEvent;
+    EventConstructor.eventPool = [];
+    EventConstructor.release = releasePooledEvent;
+  }
+  var ResponderSyntheticEvent = SyntheticEvent.extend({
+    touchHistory: function touchHistory() {
+      return null;
+    }
+  });
+  function isStartish(topLevelType) {
+    return "topTouchStart" === topLevelType;
+  }
+  function isMoveish(topLevelType) {
+    return "topTouchMove" === topLevelType;
+  }
+  var startDependencies = ["topTouchStart"],
+    moveDependencies = ["topTouchMove"],
+    endDependencies = ["topTouchCancel", "topTouchEnd"],
+    touchBank = [],
+    touchHistory = {
+      touchBank: touchBank,
+      numberActiveTouches: 0,
+      indexOfSingleActiveTouch: -1,
+      mostRecentTimeStamp: 0
+    };
+  function timestampForTouch(touch) {
+    return touch.timeStamp || touch.timestamp;
+  }
+  function getTouchIdentifier(_ref) {
+    _ref = _ref.identifier;
+    if (null == _ref) throw Error("Touch object is missing identifier.");
+    return _ref;
+  }
+  function recordTouchStart(touch) {
+    var identifier = getTouchIdentifier(touch),
+      touchRecord = touchBank[identifier];
+    touchRecord ? (touchRecord.touchActive = !0, touchRecord.startPageX = touch.pageX, touchRecord.startPageY = touch.pageY, touchRecord.startTimeStamp = timestampForTouch(touch), touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), touchRecord.previousPageX = touch.pageX, touchRecord.previousPageY = touch.pageY, touchRecord.previousTimeStamp = timestampForTouch(touch)) : (touchRecord = {
+      touchActive: !0,
+      startPageX: touch.pageX,
+      startPageY: touch.pageY,
+      startTimeStamp: timestampForTouch(touch),
+      currentPageX: touch.pageX,
+      currentPageY: touch.pageY,
+      currentTimeStamp: timestampForTouch(touch),
+      previousPageX: touch.pageX,
+      previousPageY: touch.pageY,
+      previousTimeStamp: timestampForTouch(touch)
+    }, touchBank[identifier] = touchRecord);
+    touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+  }
+  function recordTouchMove(touch) {
+    var touchRecord = touchBank[getTouchIdentifier(touch)];
+    touchRecord && (touchRecord.touchActive = !0, touchRecord.previousPageX = touchRecord.currentPageX, touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch));
+  }
+  function recordTouchEnd(touch) {
+    var touchRecord = touchBank[getTouchIdentifier(touch)];
+    touchRecord && (touchRecord.touchActive = !1, touchRecord.previousPageX = touchRecord.currentPageX, touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch));
+  }
+  var instrumentationCallback,
+    ResponderTouchHistoryStore = {
+      instrument: function instrument(callback) {
+        instrumentationCallback = callback;
+      },
+      recordTouchTrack: function recordTouchTrack(topLevelType, nativeEvent) {
+        null != instrumentationCallback && instrumentationCallback(topLevelType, nativeEvent);
+        if (isMoveish(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchMove);else if (isStartish(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchStart), touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches && (touchHistory.indexOfSingleActiveTouch = nativeEvent.touches[0].identifier);else if ("topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType) if (nativeEvent.changedTouches.forEach(recordTouchEnd), touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches) for (topLevelType = 0; topLevelType < touchBank.length; topLevelType++) if (nativeEvent = touchBank[topLevelType], null != nativeEvent && nativeEvent.touchActive) {
+          touchHistory.indexOfSingleActiveTouch = topLevelType;
+          break;
+        }
+      },
+      touchHistory: touchHistory
+    };
+  function accumulate(current, next) {
+    if (null == next) throw Error("Accumulated items must not be null or undefined.");
+    return null == current ? next : isArrayImpl(current) ? current.concat(next) : isArrayImpl(next) ? [current].concat(next) : [current, next];
+  }
+  function accumulateInto(current, next) {
+    if (null == next) throw Error("Accumulated items must not be null or undefined.");
+    if (null == current) return next;
+    if (isArrayImpl(current)) {
+      if (isArrayImpl(next)) return current.push.apply(current, next), current;
+      current.push(next);
+      return current;
+    }
+    return isArrayImpl(next) ? [current].concat(next) : [current, next];
+  }
+  function forEachAccumulated(arr, cb, scope) {
+    Array.isArray(arr) ? arr.forEach(cb, scope) : arr && cb.call(scope, arr);
+  }
+  var responderInst = null,
+    trackedTouchCount = 0;
+  function changeResponder(nextResponderInst, blockHostResponder) {
+    var oldResponderInst = responderInst;
+    responderInst = nextResponderInst;
+    if (null !== ResponderEventPlugin.GlobalResponderHandler) ResponderEventPlugin.GlobalResponderHandler.onChange(oldResponderInst, nextResponderInst, blockHostResponder);
+  }
+  var eventTypes = {
+    startShouldSetResponder: {
+      phasedRegistrationNames: {
+        bubbled: "onStartShouldSetResponder",
+        captured: "onStartShouldSetResponderCapture"
+      },
+      dependencies: startDependencies
+    },
+    scrollShouldSetResponder: {
+      phasedRegistrationNames: {
+        bubbled: "onScrollShouldSetResponder",
+        captured: "onScrollShouldSetResponderCapture"
+      },
+      dependencies: ["topScroll"]
+    },
+    selectionChangeShouldSetResponder: {
+      phasedRegistrationNames: {
+        bubbled: "onSelectionChangeShouldSetResponder",
+        captured: "onSelectionChangeShouldSetResponderCapture"
+      },
+      dependencies: ["topSelectionChange"]
+    },
+    moveShouldSetResponder: {
+      phasedRegistrationNames: {
+        bubbled: "onMoveShouldSetResponder",
+        captured: "onMoveShouldSetResponderCapture"
+      },
+      dependencies: moveDependencies
+    },
+    responderStart: {
+      registrationName: "onResponderStart",
+      dependencies: startDependencies
+    },
+    responderMove: {
+      registrationName: "onResponderMove",
+      dependencies: moveDependencies
+    },
+    responderEnd: {
+      registrationName: "onResponderEnd",
+      dependencies: endDependencies
+    },
+    responderRelease: {
+      registrationName: "onResponderRelease",
+      dependencies: endDependencies
+    },
+    responderTerminationRequest: {
+      registrationName: "onResponderTerminationRequest",
+      dependencies: []
+    },
+    responderGrant: {
+      registrationName: "onResponderGrant",
+      dependencies: []
+    },
+    responderReject: {
+      registrationName: "onResponderReject",
+      dependencies: []
+    },
+    responderTerminate: {
+      registrationName: "onResponderTerminate",
+      dependencies: []
+    }
+  };
+  function getParent$1(inst) {
+    do inst = inst.return; while (inst && 5 !== inst.tag);
+    return inst ? inst : null;
+  }
+  function traverseTwoPhase$1(inst, fn, arg) {
+    for (var path = []; inst;) path.push(inst), inst = getParent$1(inst);
+    for (inst = path.length; 0 < inst--;) fn(path[inst], "captured", arg);
+    for (inst = 0; inst < path.length; inst++) fn(path[inst], "bubbled", arg);
+  }
+  function getListener$1(inst, registrationName) {
+    inst = inst.stateNode;
+    if (null === inst) return null;
+    inst = getFiberCurrentPropsFromNode$1(inst);
+    if (null === inst) return null;
+    if ((inst = inst[registrationName]) && "function" !== typeof inst) throw Error("Expected `" + registrationName + "` listener to be a function, instead got a value of `" + typeof inst + "` type.");
+    return inst;
+  }
+  function accumulateDirectionalDispatches$1(inst, phase, event) {
+    if (phase = getListener$1(inst, event.dispatchConfig.phasedRegistrationNames[phase])) event._dispatchListeners = accumulateInto(event._dispatchListeners, phase), event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
+  }
+  function accumulateDirectDispatchesSingle$1(event) {
+    if (event && event.dispatchConfig.registrationName) {
+      var inst = event._targetInst;
+      if (inst && event && event.dispatchConfig.registrationName) {
+        var listener = getListener$1(inst, event.dispatchConfig.registrationName);
+        listener && (event._dispatchListeners = accumulateInto(event._dispatchListeners, listener), event._dispatchInstances = accumulateInto(event._dispatchInstances, inst));
+      }
+    }
+  }
+  function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
+    if (event && event.dispatchConfig.phasedRegistrationNames) {
+      var targetInst = event._targetInst;
+      targetInst = targetInst ? getParent$1(targetInst) : null;
+      traverseTwoPhase$1(targetInst, accumulateDirectionalDispatches$1, event);
+    }
+  }
+  function accumulateTwoPhaseDispatchesSingle$1(event) {
+    event && event.dispatchConfig.phasedRegistrationNames && traverseTwoPhase$1(event._targetInst, accumulateDirectionalDispatches$1, event);
+  }
+  var ResponderEventPlugin = {
+      _getResponder: function _getResponder() {
+        return responderInst;
+      },
+      eventTypes: eventTypes,
+      extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+        if (isStartish(topLevelType)) trackedTouchCount += 1;else if ("topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType) if (0 <= trackedTouchCount) --trackedTouchCount;else return null;
+        ResponderTouchHistoryStore.recordTouchTrack(topLevelType, nativeEvent);
+        if (targetInst && ("topScroll" === topLevelType && !nativeEvent.responderIgnoreScroll || 0 < trackedTouchCount && "topSelectionChange" === topLevelType || isStartish(topLevelType) || isMoveish(topLevelType))) {
+          var shouldSetEventType = isStartish(topLevelType) ? eventTypes.startShouldSetResponder : isMoveish(topLevelType) ? eventTypes.moveShouldSetResponder : "topSelectionChange" === topLevelType ? eventTypes.selectionChangeShouldSetResponder : eventTypes.scrollShouldSetResponder;
+          if (responderInst) b: {
+            var JSCompiler_temp = responderInst;
+            for (var depthA = 0, tempA = JSCompiler_temp; tempA; tempA = getParent$1(tempA)) depthA++;
+            tempA = 0;
+            for (var tempB = targetInst; tempB; tempB = getParent$1(tempB)) tempA++;
+            for (; 0 < depthA - tempA;) JSCompiler_temp = getParent$1(JSCompiler_temp), depthA--;
+            for (; 0 < tempA - depthA;) targetInst = getParent$1(targetInst), tempA--;
+            for (; depthA--;) {
+              if (JSCompiler_temp === targetInst || JSCompiler_temp === targetInst.alternate) break b;
+              JSCompiler_temp = getParent$1(JSCompiler_temp);
+              targetInst = getParent$1(targetInst);
+            }
+            JSCompiler_temp = null;
+          } else JSCompiler_temp = targetInst;
+          targetInst = JSCompiler_temp;
+          JSCompiler_temp = targetInst === responderInst;
+          shouldSetEventType = ResponderSyntheticEvent.getPooled(shouldSetEventType, targetInst, nativeEvent, nativeEventTarget);
+          shouldSetEventType.touchHistory = ResponderTouchHistoryStore.touchHistory;
+          JSCompiler_temp ? forEachAccumulated(shouldSetEventType, accumulateTwoPhaseDispatchesSingleSkipTarget) : forEachAccumulated(shouldSetEventType, accumulateTwoPhaseDispatchesSingle$1);
+          b: {
+            JSCompiler_temp = shouldSetEventType._dispatchListeners;
+            targetInst = shouldSetEventType._dispatchInstances;
+            if (isArrayImpl(JSCompiler_temp)) for (depthA = 0; depthA < JSCompiler_temp.length && !shouldSetEventType.isPropagationStopped(); depthA++) {
+              if (JSCompiler_temp[depthA](shouldSetEventType, targetInst[depthA])) {
+                JSCompiler_temp = targetInst[depthA];
+                break b;
+              }
+            } else if (JSCompiler_temp && JSCompiler_temp(shouldSetEventType, targetInst)) {
+              JSCompiler_temp = targetInst;
+              break b;
+            }
+            JSCompiler_temp = null;
+          }
+          shouldSetEventType._dispatchInstances = null;
+          shouldSetEventType._dispatchListeners = null;
+          shouldSetEventType.isPersistent() || shouldSetEventType.constructor.release(shouldSetEventType);
+          if (JSCompiler_temp && JSCompiler_temp !== responderInst) {
+            if (shouldSetEventType = ResponderSyntheticEvent.getPooled(eventTypes.responderGrant, JSCompiler_temp, nativeEvent, nativeEventTarget), shouldSetEventType.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(shouldSetEventType, accumulateDirectDispatchesSingle$1), targetInst = !0 === executeDirectDispatch(shouldSetEventType), responderInst) {
+              if (depthA = ResponderSyntheticEvent.getPooled(eventTypes.responderTerminationRequest, responderInst, nativeEvent, nativeEventTarget), depthA.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(depthA, accumulateDirectDispatchesSingle$1), tempA = !depthA._dispatchListeners || executeDirectDispatch(depthA), depthA.isPersistent() || depthA.constructor.release(depthA), tempA) {
+                depthA = ResponderSyntheticEvent.getPooled(eventTypes.responderTerminate, responderInst, nativeEvent, nativeEventTarget);
+                depthA.touchHistory = ResponderTouchHistoryStore.touchHistory;
+                forEachAccumulated(depthA, accumulateDirectDispatchesSingle$1);
+                var JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, [shouldSetEventType, depthA]);
+                changeResponder(JSCompiler_temp, targetInst);
+              } else shouldSetEventType = ResponderSyntheticEvent.getPooled(eventTypes.responderReject, JSCompiler_temp, nativeEvent, nativeEventTarget), shouldSetEventType.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(shouldSetEventType, accumulateDirectDispatchesSingle$1), JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, shouldSetEventType);
+            } else JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, shouldSetEventType), changeResponder(JSCompiler_temp, targetInst);
+          } else JSCompiler_temp$jscomp$0 = null;
+        } else JSCompiler_temp$jscomp$0 = null;
+        shouldSetEventType = responderInst && isStartish(topLevelType);
+        JSCompiler_temp = responderInst && isMoveish(topLevelType);
+        targetInst = responderInst && ("topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType);
+        if (shouldSetEventType = shouldSetEventType ? eventTypes.responderStart : JSCompiler_temp ? eventTypes.responderMove : targetInst ? eventTypes.responderEnd : null) shouldSetEventType = ResponderSyntheticEvent.getPooled(shouldSetEventType, responderInst, nativeEvent, nativeEventTarget), shouldSetEventType.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(shouldSetEventType, accumulateDirectDispatchesSingle$1), JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, shouldSetEventType);
+        shouldSetEventType = responderInst && "topTouchCancel" === topLevelType;
+        if (topLevelType = responderInst && !shouldSetEventType && ("topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType)) a: {
+          if ((topLevelType = nativeEvent.touches) && 0 !== topLevelType.length) for (JSCompiler_temp = 0; JSCompiler_temp < topLevelType.length; JSCompiler_temp++) if (targetInst = topLevelType[JSCompiler_temp].target, null !== targetInst && void 0 !== targetInst && 0 !== targetInst) {
+            depthA = getInstanceFromNode$1(targetInst);
+            b: {
+              for (targetInst = responderInst; depthA;) {
+                if (targetInst === depthA || targetInst === depthA.alternate) {
+                  targetInst = !0;
+                  break b;
+                }
+                depthA = getParent$1(depthA);
+              }
+              targetInst = !1;
+            }
+            if (targetInst) {
+              topLevelType = !1;
+              break a;
+            }
+          }
+          topLevelType = !0;
+        }
+        if (topLevelType = shouldSetEventType ? eventTypes.responderTerminate : topLevelType ? eventTypes.responderRelease : null) nativeEvent = ResponderSyntheticEvent.getPooled(topLevelType, responderInst, nativeEvent, nativeEventTarget), nativeEvent.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(nativeEvent, accumulateDirectDispatchesSingle$1), JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, nativeEvent), changeResponder(null);
+        return JSCompiler_temp$jscomp$0;
+      },
+      GlobalResponderHandler: null,
+      injection: {
+        injectGlobalResponderHandler: function injectGlobalResponderHandler(GlobalResponderHandler) {
+          ResponderEventPlugin.GlobalResponderHandler = GlobalResponderHandler;
+        }
+      }
+    },
+    eventPluginOrder = null,
+    namesToPlugins = {};
+  function recomputePluginOrdering() {
+    if (eventPluginOrder) for (var pluginName in namesToPlugins) {
+      var pluginModule = namesToPlugins[pluginName],
+        pluginIndex = eventPluginOrder.indexOf(pluginName);
+      if (-1 >= pluginIndex) throw Error("EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `" + (pluginName + "`."));
+      if (!plugins[pluginIndex]) {
+        if (!pluginModule.extractEvents) throw Error("EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `" + (pluginName + "` does not."));
+        plugins[pluginIndex] = pluginModule;
+        pluginIndex = pluginModule.eventTypes;
+        for (var eventName in pluginIndex) {
+          var JSCompiler_inline_result = void 0;
+          var dispatchConfig = pluginIndex[eventName];
+          if (eventNameDispatchConfigs.hasOwnProperty(eventName)) throw Error("EventPluginRegistry: More than one plugin attempted to publish the same event name, `" + (eventName + "`."));
+          eventNameDispatchConfigs[eventName] = dispatchConfig;
+          var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;
+          if (phasedRegistrationNames) {
+            for (JSCompiler_inline_result in phasedRegistrationNames) phasedRegistrationNames.hasOwnProperty(JSCompiler_inline_result) && publishRegistrationName(phasedRegistrationNames[JSCompiler_inline_result], pluginModule);
+            JSCompiler_inline_result = !0;
+          } else dispatchConfig.registrationName ? (publishRegistrationName(dispatchConfig.registrationName, pluginModule), JSCompiler_inline_result = !0) : JSCompiler_inline_result = !1;
+          if (!JSCompiler_inline_result) throw Error("EventPluginRegistry: Failed to publish event `" + eventName + "` for plugin `" + pluginName + "`.");
+        }
+      }
+    }
+  }
+  function publishRegistrationName(registrationName, pluginModule) {
+    if (registrationNameModules[registrationName]) throw Error("EventPluginRegistry: More than one plugin attempted to publish the same registration name, `" + (registrationName + "`."));
+    registrationNameModules[registrationName] = pluginModule;
+  }
+  var plugins = [],
+    eventNameDispatchConfigs = {},
+    registrationNameModules = {};
+  function getListener(inst, registrationName) {
+    inst = inst.stateNode;
+    if (null === inst) return null;
+    inst = getFiberCurrentPropsFromNode$1(inst);
+    if (null === inst) return null;
+    if ((inst = inst[registrationName]) && "function" !== typeof inst) throw Error("Expected `" + registrationName + "` listener to be a function, instead got a value of `" + typeof inst + "` type.");
+    return inst;
+  }
+  var customBubblingEventTypes = _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").ReactNativeViewConfigRegistry.customBubblingEventTypes,
+    customDirectEventTypes = _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").ReactNativeViewConfigRegistry.customDirectEventTypes;
+  function accumulateDirectionalDispatches(inst, phase, event) {
+    if (phase = getListener(inst, event.dispatchConfig.phasedRegistrationNames[phase])) event._dispatchListeners = accumulateInto(event._dispatchListeners, phase), event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
+  }
+  function traverseTwoPhase(inst, fn, arg, skipBubbling) {
+    for (var path = []; inst;) {
+      path.push(inst);
+      do inst = inst.return; while (inst && 5 !== inst.tag);
+      inst = inst ? inst : null;
+    }
+    for (inst = path.length; 0 < inst--;) fn(path[inst], "captured", arg);
+    if (skipBubbling) fn(path[0], "bubbled", arg);else for (inst = 0; inst < path.length; inst++) fn(path[inst], "bubbled", arg);
+  }
+  function accumulateTwoPhaseDispatchesSingle(event) {
+    event && event.dispatchConfig.phasedRegistrationNames && traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event, !1);
+  }
+  function accumulateDirectDispatchesSingle(event) {
+    if (event && event.dispatchConfig.registrationName) {
+      var inst = event._targetInst;
+      if (inst && event && event.dispatchConfig.registrationName) {
+        var listener = getListener(inst, event.dispatchConfig.registrationName);
+        listener && (event._dispatchListeners = accumulateInto(event._dispatchListeners, listener), event._dispatchInstances = accumulateInto(event._dispatchInstances, inst));
+      }
+    }
+  }
+  if (eventPluginOrder) throw Error("EventPluginRegistry: Cannot inject event plugin ordering more than once. You are likely trying to load more than one copy of React.");
+  eventPluginOrder = Array.prototype.slice.call(["ResponderEventPlugin", "ReactNativeBridgeEventPlugin"]);
+  recomputePluginOrdering();
+  var injectedNamesToPlugins$jscomp$inline_278 = {
+      ResponderEventPlugin: ResponderEventPlugin,
+      ReactNativeBridgeEventPlugin: {
+        eventTypes: {},
+        extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+          if (null == targetInst) return null;
+          var bubbleDispatchConfig = customBubblingEventTypes[topLevelType],
+            directDispatchConfig = customDirectEventTypes[topLevelType];
+          if (!bubbleDispatchConfig && !directDispatchConfig) throw Error('Unsupported top level event type "' + topLevelType + '" dispatched');
+          topLevelType = SyntheticEvent.getPooled(bubbleDispatchConfig || directDispatchConfig, targetInst, nativeEvent, nativeEventTarget);
+          if (bubbleDispatchConfig) null != topLevelType && null != topLevelType.dispatchConfig.phasedRegistrationNames && topLevelType.dispatchConfig.phasedRegistrationNames.skipBubbling ? topLevelType && topLevelType.dispatchConfig.phasedRegistrationNames && traverseTwoPhase(topLevelType._targetInst, accumulateDirectionalDispatches, topLevelType, !0) : forEachAccumulated(topLevelType, accumulateTwoPhaseDispatchesSingle);else if (directDispatchConfig) forEachAccumulated(topLevelType, accumulateDirectDispatchesSingle);else return null;
+          return topLevelType;
+        }
+      }
+    },
+    isOrderingDirty$jscomp$inline_279 = !1,
+    pluginName$jscomp$inline_280;
+  for (pluginName$jscomp$inline_280 in injectedNamesToPlugins$jscomp$inline_278) if (injectedNamesToPlugins$jscomp$inline_278.hasOwnProperty(pluginName$jscomp$inline_280)) {
+    var pluginModule$jscomp$inline_281 = injectedNamesToPlugins$jscomp$inline_278[pluginName$jscomp$inline_280];
+    if (!namesToPlugins.hasOwnProperty(pluginName$jscomp$inline_280) || namesToPlugins[pluginName$jscomp$inline_280] !== pluginModule$jscomp$inline_281) {
+      if (namesToPlugins[pluginName$jscomp$inline_280]) throw Error("EventPluginRegistry: Cannot inject two different event plugins using the same name, `" + (pluginName$jscomp$inline_280 + "`."));
+      namesToPlugins[pluginName$jscomp$inline_280] = pluginModule$jscomp$inline_281;
+      isOrderingDirty$jscomp$inline_279 = !0;
+    }
+  }
+  isOrderingDirty$jscomp$inline_279 && recomputePluginOrdering();
+  var emptyObject = {},
+    removedKeys = null,
+    removedKeyCount = 0,
+    deepDifferOptions = {
+      unsafelyIgnoreFunctions: !0
+    };
+  function defaultDiffer(prevProp, nextProp) {
+    return "object" !== typeof nextProp || null === nextProp ? !0 : _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").deepDiffer(prevProp, nextProp, deepDifferOptions);
+  }
+  function restoreDeletedValuesInNestedArray(updatePayload, node, validAttributes) {
+    if (isArrayImpl(node)) for (var i = node.length; i-- && 0 < removedKeyCount;) restoreDeletedValuesInNestedArray(updatePayload, node[i], validAttributes);else if (node && 0 < removedKeyCount) for (i in removedKeys) if (removedKeys[i]) {
+      var nextProp = node[i];
+      if (void 0 !== nextProp) {
+        var attributeConfig = validAttributes[i];
+        if (attributeConfig) {
+          "function" === typeof nextProp && (nextProp = !0);
+          "undefined" === typeof nextProp && (nextProp = null);
+          if ("object" !== typeof attributeConfig) updatePayload[i] = nextProp;else if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) nextProp = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, updatePayload[i] = nextProp;
+          removedKeys[i] = !1;
+          removedKeyCount--;
+        }
+      }
+    }
+  }
+  function diffNestedProperty(updatePayload, prevProp, nextProp, validAttributes) {
+    if (!updatePayload && prevProp === nextProp) return updatePayload;
+    if (!prevProp || !nextProp) return nextProp ? addNestedProperty(updatePayload, nextProp, validAttributes) : prevProp ? clearNestedProperty(updatePayload, prevProp, validAttributes) : updatePayload;
+    if (!isArrayImpl(prevProp) && !isArrayImpl(nextProp)) return diffProperties(updatePayload, prevProp, nextProp, validAttributes);
+    if (isArrayImpl(prevProp) && isArrayImpl(nextProp)) {
+      var minLength = prevProp.length < nextProp.length ? prevProp.length : nextProp.length,
+        i;
+      for (i = 0; i < minLength; i++) updatePayload = diffNestedProperty(updatePayload, prevProp[i], nextProp[i], validAttributes);
+      for (; i < prevProp.length; i++) updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
+      for (; i < nextProp.length; i++) updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
+      return updatePayload;
+    }
+    return isArrayImpl(prevProp) ? diffProperties(updatePayload, _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").flattenStyle(prevProp), nextProp, validAttributes) : diffProperties(updatePayload, prevProp, _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").flattenStyle(nextProp), validAttributes);
+  }
+  function addNestedProperty(updatePayload, nextProp, validAttributes) {
+    if (!nextProp) return updatePayload;
+    if (!isArrayImpl(nextProp)) return diffProperties(updatePayload, emptyObject, nextProp, validAttributes);
+    for (var i = 0; i < nextProp.length; i++) updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
+    return updatePayload;
+  }
+  function clearNestedProperty(updatePayload, prevProp, validAttributes) {
+    if (!prevProp) return updatePayload;
+    if (!isArrayImpl(prevProp)) return diffProperties(updatePayload, prevProp, emptyObject, validAttributes);
+    for (var i = 0; i < prevProp.length; i++) updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
+    return updatePayload;
+  }
+  function diffProperties(updatePayload, prevProps, nextProps, validAttributes) {
+    var attributeConfig, propKey;
+    for (propKey in nextProps) if (attributeConfig = validAttributes[propKey]) {
+      var prevProp = prevProps[propKey];
+      var nextProp = nextProps[propKey];
+      "function" === typeof nextProp && (nextProp = !0, "function" === typeof prevProp && (prevProp = !0));
+      "undefined" === typeof nextProp && (nextProp = null, "undefined" === typeof prevProp && (prevProp = null));
+      removedKeys && (removedKeys[propKey] = !1);
+      if (updatePayload && void 0 !== updatePayload[propKey]) {
+        if ("object" !== typeof attributeConfig) updatePayload[propKey] = nextProp;else {
+          if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) attributeConfig = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, updatePayload[propKey] = attributeConfig;
+        }
+      } else if (prevProp !== nextProp) if ("object" !== typeof attributeConfig) defaultDiffer(prevProp, nextProp) && ((updatePayload || (updatePayload = {}))[propKey] = nextProp);else if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) {
+        if (void 0 === prevProp || ("function" === typeof attributeConfig.diff ? attributeConfig.diff(prevProp, nextProp) : defaultDiffer(prevProp, nextProp))) attributeConfig = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, (updatePayload || (updatePayload = {}))[propKey] = attributeConfig;
+      } else removedKeys = null, removedKeyCount = 0, updatePayload = diffNestedProperty(updatePayload, prevProp, nextProp, attributeConfig), 0 < removedKeyCount && updatePayload && (restoreDeletedValuesInNestedArray(updatePayload, nextProp, attributeConfig), removedKeys = null);
+    }
+    for (var propKey$6 in prevProps) void 0 === nextProps[propKey$6] && (!(attributeConfig = validAttributes[propKey$6]) || updatePayload && void 0 !== updatePayload[propKey$6] || (prevProp = prevProps[propKey$6], void 0 !== prevProp && ("object" !== typeof attributeConfig || "function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process ? ((updatePayload || (updatePayload = {}))[propKey$6] = null, removedKeys || (removedKeys = {}), removedKeys[propKey$6] || (removedKeys[propKey$6] = !0, removedKeyCount++)) : updatePayload = clearNestedProperty(updatePayload, prevProp, attributeConfig))));
+    return updatePayload;
+  }
+  function fastAddProperties(payload, props, validAttributes) {
+    if (isArrayImpl(props)) {
+      for (var i = 0; i < props.length; i++) payload = fastAddProperties(payload, props[i], validAttributes);
+      return payload;
+    }
+    for (i in props) {
+      var prop = props[i],
+        attributeConfig = validAttributes[i];
+      if (null != attributeConfig) {
+        var newValue = void 0;
+        if (void 0 === prop) {
+          if (payload && void 0 !== payload[i]) newValue = null;else continue;
+        } else "function" === typeof prop ? newValue = !0 : "object" !== typeof attributeConfig ? newValue = prop : "function" === typeof attributeConfig.process ? newValue = attributeConfig.process(prop) : "function" === typeof attributeConfig.diff && (newValue = prop);
+        void 0 !== newValue ? (payload || (payload = {}), payload[i] = newValue) : payload = fastAddProperties(payload, prop, attributeConfig);
+      }
+    }
+    return payload;
+  }
+  function batchedUpdatesImpl(fn, bookkeeping) {
+    return fn(bookkeeping);
+  }
+  var isInsideEventHandler = !1;
+  function batchedUpdates$1(fn, bookkeeping) {
+    if (isInsideEventHandler) return fn(bookkeeping);
+    isInsideEventHandler = !0;
+    try {
+      return batchedUpdatesImpl(fn, bookkeeping);
+    } finally {
+      isInsideEventHandler = !1;
+    }
+  }
+  var eventQueue = null;
+  function executeDispatchesAndReleaseTopLevel(e) {
+    if (e) {
+      var dispatchListeners = e._dispatchListeners,
+        dispatchInstances = e._dispatchInstances;
+      if (isArrayImpl(dispatchListeners)) for (var i = 0; i < dispatchListeners.length && !e.isPropagationStopped(); i++) executeDispatch(e, dispatchListeners[i], dispatchInstances[i]);else dispatchListeners && executeDispatch(e, dispatchListeners, dispatchInstances);
+      e._dispatchListeners = null;
+      e._dispatchInstances = null;
+      e.isPersistent() || e.constructor.release(e);
+    }
+  }
+  function dispatchEvent(target, topLevelType, nativeEvent) {
+    var eventTarget = null;
+    if (null != target) {
+      var stateNode = target.stateNode;
+      null != stateNode && (eventTarget = getPublicInstance(stateNode));
+    }
+    batchedUpdates$1(function () {
+      var event = {
+        eventName: topLevelType,
+        nativeEvent: nativeEvent
+      };
+      _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").RawEventEmitter.emit(topLevelType, event);
+      _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").RawEventEmitter.emit("*", event);
+      event = eventTarget;
+      for (var events = null, legacyPlugins = plugins, i = 0; i < legacyPlugins.length; i++) {
+        var possiblePlugin = legacyPlugins[i];
+        possiblePlugin && (possiblePlugin = possiblePlugin.extractEvents(topLevelType, target, nativeEvent, event)) && (events = accumulateInto(events, possiblePlugin));
+      }
+      event = events;
+      null !== event && (eventQueue = accumulateInto(eventQueue, event));
+      event = eventQueue;
+      eventQueue = null;
+      if (event) {
+        forEachAccumulated(event, executeDispatchesAndReleaseTopLevel);
+        if (eventQueue) throw Error("processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented.");
+        if (hasError) throw event = caughtError, hasError = !1, caughtError = null, event;
+      }
+    });
+  }
+  var rendererID = null,
+    injectedHook = null;
+  function setIsStrictModeForDevtools(newIsStrictMode) {
+    "function" === typeof _$$_REQUIRE(_dependencyMap[3], "scheduler").log && _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_setDisableYieldValue(newIsStrictMode);
+    if (injectedHook && "function" === typeof injectedHook.setStrictMode) try {
+      injectedHook.setStrictMode(rendererID, newIsStrictMode);
+    } catch (err) {}
+  }
+  var clz32 = Math.clz32 ? Math.clz32 : clz32Fallback,
+    log = Math.log,
+    LN2 = Math.LN2;
+  function clz32Fallback(x) {
+    x >>>= 0;
+    return 0 === x ? 32 : 31 - (log(x) / LN2 | 0) | 0;
+  }
+  var nextTransitionLane = 256,
+    nextRetryLane = 4194304;
+  function getHighestPriorityLanes(lanes) {
+    var pendingSyncLanes = lanes & 42;
+    if (0 !== pendingSyncLanes) return pendingSyncLanes;
+    switch (lanes & -lanes) {
+      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:
+        return 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 lanes & 4194048;
+      case 4194304:
+      case 8388608:
+      case 16777216:
+      case 33554432:
+        return lanes & 62914560;
+      case 67108864:
+        return 67108864;
+      case 134217728:
+        return 134217728;
+      case 268435456:
+        return 268435456;
+      case 536870912:
+        return 536870912;
+      case 1073741824:
+        return 0;
+      default:
+        return lanes;
+    }
+  }
+  function getNextLanes(root, wipLanes, rootHasPendingCommit) {
+    var pendingLanes = root.pendingLanes;
+    if (0 === pendingLanes) return 0;
+    var nextLanes = 0,
+      suspendedLanes = root.suspendedLanes,
+      pingedLanes = root.pingedLanes;
+    root = root.warmLanes;
+    var nonIdlePendingLanes = pendingLanes & 134217727;
+    0 !== nonIdlePendingLanes ? (pendingLanes = nonIdlePendingLanes & ~suspendedLanes, 0 !== pendingLanes ? nextLanes = getHighestPriorityLanes(pendingLanes) : (pingedLanes &= nonIdlePendingLanes, 0 !== pingedLanes ? nextLanes = getHighestPriorityLanes(pingedLanes) : rootHasPendingCommit || (rootHasPendingCommit = nonIdlePendingLanes & ~root, 0 !== rootHasPendingCommit && (nextLanes = getHighestPriorityLanes(rootHasPendingCommit))))) : (nonIdlePendingLanes = pendingLanes & ~suspendedLanes, 0 !== nonIdlePendingLanes ? nextLanes = getHighestPriorityLanes(nonIdlePendingLanes) : 0 !== pingedLanes ? nextLanes = getHighestPriorityLanes(pingedLanes) : rootHasPendingCommit || (rootHasPendingCommit = pendingLanes & ~root, 0 !== rootHasPendingCommit && (nextLanes = getHighestPriorityLanes(rootHasPendingCommit))));
+    return 0 === nextLanes ? 0 : 0 !== wipLanes && wipLanes !== nextLanes && 0 === (wipLanes & suspendedLanes) && (suspendedLanes = nextLanes & -nextLanes, rootHasPendingCommit = wipLanes & -wipLanes, suspendedLanes >= rootHasPendingCommit || 32 === suspendedLanes && 0 !== (rootHasPendingCommit & 4194048)) ? wipLanes : nextLanes;
+  }
+  function checkIfRootIsPrerendering(root, renderLanes) {
+    return 0 === (root.pendingLanes & ~(root.suspendedLanes & ~root.pingedLanes) & renderLanes);
+  }
+  function computeExpirationTime(lane, currentTime) {
+    switch (lane) {
+      case 1:
+      case 2:
+      case 4:
+      case 8:
+      case 64:
+        return currentTime + 250;
+      case 16:
+      case 32:
+      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 currentTime + 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 claimNextTransitionLane() {
+    var lane = nextTransitionLane;
+    nextTransitionLane <<= 1;
+    0 === (nextTransitionLane & 4194048) && (nextTransitionLane = 256);
+    return lane;
+  }
+  function claimNextRetryLane() {
+    var lane = nextRetryLane;
+    nextRetryLane <<= 1;
+    0 === (nextRetryLane & 62914560) && (nextRetryLane = 4194304);
+    return lane;
+  }
+  function createLaneMap(initial) {
+    for (var laneMap = [], i = 0; 31 > i; i++) laneMap.push(initial);
+    return laneMap;
+  }
+  function markRootUpdated$1(root, updateLane) {
+    root.pendingLanes |= updateLane;
+    268435456 !== updateLane && (root.suspendedLanes = 0, root.pingedLanes = 0, root.warmLanes = 0);
+  }
+  function markRootFinished(root, finishedLanes, remainingLanes, spawnedLane, updatedLanes, suspendedRetryLanes) {
+    var previouslyPendingLanes = root.pendingLanes;
+    root.pendingLanes = remainingLanes;
+    root.suspendedLanes = 0;
+    root.pingedLanes = 0;
+    root.warmLanes = 0;
+    root.expiredLanes &= remainingLanes;
+    root.entangledLanes &= remainingLanes;
+    root.errorRecoveryDisabledLanes &= remainingLanes;
+    root.shellSuspendCounter = 0;
+    var entanglements = root.entanglements,
+      expirationTimes = root.expirationTimes,
+      hiddenUpdates = root.hiddenUpdates;
+    for (remainingLanes = previouslyPendingLanes & ~remainingLanes; 0 < remainingLanes;) {
+      var index$11 = 31 - clz32(remainingLanes),
+        lane = 1 << index$11;
+      entanglements[index$11] = 0;
+      expirationTimes[index$11] = -1;
+      var hiddenUpdatesForLane = hiddenUpdates[index$11];
+      if (null !== hiddenUpdatesForLane) for (hiddenUpdates[index$11] = null, index$11 = 0; index$11 < hiddenUpdatesForLane.length; index$11++) {
+        var update = hiddenUpdatesForLane[index$11];
+        null !== update && (update.lane &= -536870913);
+      }
+      remainingLanes &= ~lane;
+    }
+    0 !== spawnedLane && markSpawnedDeferredLane(root, spawnedLane, 0);
+    0 !== suspendedRetryLanes && 0 === updatedLanes && (root.suspendedLanes |= suspendedRetryLanes & ~(previouslyPendingLanes & ~finishedLanes));
+  }
+  function markSpawnedDeferredLane(root, spawnedLane, entangledLanes) {
+    root.pendingLanes |= spawnedLane;
+    root.suspendedLanes &= ~spawnedLane;
+    var spawnedLaneIndex = 31 - clz32(spawnedLane);
+    root.entangledLanes |= spawnedLane;
+    root.entanglements[spawnedLaneIndex] = root.entanglements[spawnedLaneIndex] | 1073741824 | entangledLanes & 4194090;
+  }
+  function markRootEntangled(root, entangledLanes) {
+    var rootEntangledLanes = root.entangledLanes |= entangledLanes;
+    for (root = root.entanglements; rootEntangledLanes;) {
+      var index$12 = 31 - clz32(rootEntangledLanes),
+        lane = 1 << index$12;
+      lane & entangledLanes | root[index$12] & entangledLanes && (root[index$12] |= entangledLanes);
+      rootEntangledLanes &= ~lane;
+    }
+  }
+  function lanesToEventPriority(lanes) {
+    lanes &= -lanes;
+    return 2 < lanes ? 8 < lanes ? 0 !== (lanes & 134217727) ? 32 : 268435456 : 8 : 2;
+  }
+  function getNearestMountedFiber(fiber) {
+    var node = fiber,
+      nearestMounted = fiber;
+    if (fiber.alternate) for (; node.return;) node = node.return;else {
+      fiber = node;
+      do node = fiber, 0 !== (node.flags & 4098) && (nearestMounted = node.return), fiber = node.return; while (fiber);
+    }
+    return 3 === node.tag ? nearestMounted : null;
+  }
+  function assertIsMounted(fiber) {
+    if (getNearestMountedFiber(fiber) !== fiber) throw Error("Unable to find node on an unmounted component.");
+  }
+  function findCurrentFiberUsingSlowPath(fiber) {
+    var alternate = fiber.alternate;
+    if (!alternate) {
+      alternate = getNearestMountedFiber(fiber);
+      if (null === alternate) throw Error("Unable to find node on an unmounted component.");
+      return alternate !== fiber ? null : fiber;
+    }
+    for (var a = fiber, b = alternate;;) {
+      var parentA = a.return;
+      if (null === parentA) break;
+      var parentB = parentA.alternate;
+      if (null === parentB) {
+        b = parentA.return;
+        if (null !== b) {
+          a = b;
+          continue;
+        }
+        break;
+      }
+      if (parentA.child === parentB.child) {
+        for (parentB = parentA.child; parentB;) {
+          if (parentB === a) return assertIsMounted(parentA), fiber;
+          if (parentB === b) return assertIsMounted(parentA), alternate;
+          parentB = parentB.sibling;
+        }
+        throw Error("Unable to find node on an unmounted component.");
+      }
+      if (a.return !== b.return) a = parentA, b = parentB;else {
+        for (var didFindChild = !1, child$13 = parentA.child; child$13;) {
+          if (child$13 === a) {
+            didFindChild = !0;
+            a = parentA;
+            b = parentB;
+            break;
+          }
+          if (child$13 === b) {
+            didFindChild = !0;
+            b = parentA;
+            a = parentB;
+            break;
+          }
+          child$13 = child$13.sibling;
+        }
+        if (!didFindChild) {
+          for (child$13 = parentB.child; child$13;) {
+            if (child$13 === a) {
+              didFindChild = !0;
+              a = parentB;
+              b = parentA;
+              break;
+            }
+            if (child$13 === b) {
+              didFindChild = !0;
+              b = parentB;
+              a = parentA;
+              break;
+            }
+            child$13 = child$13.sibling;
+          }
+          if (!didFindChild) throw 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 Error("Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue.");
+    }
+    if (3 !== a.tag) throw Error("Unable to find node on an unmounted component.");
+    return a.stateNode.current === a ? fiber : alternate;
+  }
+  function findCurrentHostFiberImpl(node) {
+    var tag = node.tag;
+    if (5 === tag || 26 === tag || 27 === tag || 6 === tag) return node;
+    for (node = node.child; null !== node;) {
+      tag = findCurrentHostFiberImpl(node);
+      if (null !== tag) return tag;
+      node = node.sibling;
+    }
+    return null;
+  }
+  var valueStack = [],
+    index = -1;
+  function createCursor(defaultValue) {
+    return {
+      current: defaultValue
+    };
+  }
+  function pop(cursor) {
+    0 > index || (cursor.current = valueStack[index], valueStack[index] = null, index--);
+  }
+  function push(cursor, value) {
+    index++;
+    valueStack[index] = cursor.current;
+    cursor.current = value;
+  }
+  var emptyContextObject = {},
+    CapturedStacks = new WeakMap();
+  function createCapturedValueAtFiber(value, source) {
+    if ("object" === typeof value && null !== value) {
+      var existing = CapturedStacks.get(value);
+      if (void 0 !== existing) return existing;
+      source = {
+        value: value,
+        source: source,
+        stack: getStackByFiberInDevAndProd(source)
+      };
+      CapturedStacks.set(value, source);
+      return source;
+    }
+    return {
+      value: value,
+      source: source,
+      stack: getStackByFiberInDevAndProd(source)
+    };
+  }
+  var contextStackCursor = createCursor(null),
+    contextFiberStackCursor = createCursor(null),
+    rootInstanceStackCursor = createCursor(null),
+    hostTransitionProviderCursor = createCursor(null);
+  function pushHostContainer(fiber, nextRootInstance) {
+    push(rootInstanceStackCursor, nextRootInstance);
+    push(contextFiberStackCursor, fiber);
+    push(contextStackCursor, null);
+    fiber = PROD_HOST_CONTEXT;
+    pop(contextStackCursor);
+    push(contextStackCursor, fiber);
+  }
+  function popHostContainer() {
+    pop(contextStackCursor);
+    pop(contextFiberStackCursor);
+    pop(rootInstanceStackCursor);
+  }
+  function pushHostContext(fiber) {
+    null !== fiber.memoizedState && push(hostTransitionProviderCursor, fiber);
+    var context = contextStackCursor.current;
+    context !== context && (push(contextFiberStackCursor, fiber), push(contextStackCursor, context));
+  }
+  function popHostContext(fiber) {
+    contextFiberStackCursor.current === fiber && (pop(contextStackCursor), pop(contextFiberStackCursor));
+    hostTransitionProviderCursor.current === fiber && (pop(hostTransitionProviderCursor), HostTransitionContext._currentValue2 = null);
+  }
+  var hydrationErrors = null;
+  function upgradeHydrationErrorsToRecoverable() {
+    var queuedErrors = hydrationErrors;
+    null !== queuedErrors && (null === workInProgressRootRecoverableErrors ? workInProgressRootRecoverableErrors = queuedErrors : workInProgressRootRecoverableErrors.push.apply(workInProgressRootRecoverableErrors, queuedErrors), hydrationErrors = null);
+    return queuedErrors;
+  }
+  function is(x, y) {
+    return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+  }
+  var objectIs = "function" === typeof Object.is ? Object.is : is,
+    valueCursor = createCursor(null),
+    currentlyRenderingFiber$1 = null,
+    lastContextDependency = null;
+  function pushProvider(providerFiber, context, nextValue) {
+    push(valueCursor, context._currentValue2);
+    context._currentValue2 = nextValue;
+  }
+  function popProvider(context) {
+    context._currentValue2 = valueCursor.current;
+    pop(valueCursor);
+  }
+  function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
+    for (; null !== parent;) {
+      var alternate = parent.alternate;
+      (parent.childLanes & renderLanes) !== renderLanes ? (parent.childLanes |= renderLanes, null !== alternate && (alternate.childLanes |= renderLanes)) : null !== alternate && (alternate.childLanes & renderLanes) !== renderLanes && (alternate.childLanes |= renderLanes);
+      if (parent === propagationRoot) break;
+      parent = parent.return;
+    }
+  }
+  function propagateContextChanges(workInProgress, contexts, renderLanes, forcePropagateEntireTree) {
+    var fiber = workInProgress.child;
+    null !== fiber && (fiber.return = workInProgress);
+    for (; null !== fiber;) {
+      var list = fiber.dependencies;
+      if (null !== list) {
+        var nextFiber = fiber.child;
+        list = list.firstContext;
+        a: for (; null !== list;) {
+          var dependency = list;
+          list = fiber;
+          for (var i = 0; i < contexts.length; i++) if (dependency.context === contexts[i]) {
+            list.lanes |= renderLanes;
+            dependency = list.alternate;
+            null !== dependency && (dependency.lanes |= renderLanes);
+            scheduleContextWorkOnParentPath(list.return, renderLanes, workInProgress);
+            forcePropagateEntireTree || (nextFiber = null);
+            break a;
+          }
+          list = dependency.next;
+        }
+      } else if (18 === fiber.tag) {
+        nextFiber = fiber.return;
+        if (null === nextFiber) throw Error("We just came from a parent so we must have had a parent. This is a bug in React.");
+        nextFiber.lanes |= renderLanes;
+        list = nextFiber.alternate;
+        null !== list && (list.lanes |= renderLanes);
+        scheduleContextWorkOnParentPath(nextFiber, renderLanes, workInProgress);
+        nextFiber = null;
+      } else nextFiber = fiber.child;
+      if (null !== nextFiber) nextFiber.return = fiber;else for (nextFiber = fiber; null !== nextFiber;) {
+        if (nextFiber === workInProgress) {
+          nextFiber = null;
+          break;
+        }
+        fiber = nextFiber.sibling;
+        if (null !== fiber) {
+          fiber.return = nextFiber.return;
+          nextFiber = fiber;
+          break;
+        }
+        nextFiber = nextFiber.return;
+      }
+      fiber = nextFiber;
+    }
+  }
+  function propagateParentContextChanges(current, workInProgress, renderLanes, forcePropagateEntireTree) {
+    current = null;
+    for (var parent = workInProgress, isInsidePropagationBailout = !1; null !== parent;) {
+      if (!isInsidePropagationBailout) if (0 !== (parent.flags & 524288)) isInsidePropagationBailout = !0;else if (0 !== (parent.flags & 262144)) break;
+      if (10 === parent.tag) {
+        var currentParent = parent.alternate;
+        if (null === currentParent) throw Error("Should have a current fiber. This is a bug in React.");
+        currentParent = currentParent.memoizedProps;
+        if (null !== currentParent) {
+          var context = parent.type;
+          objectIs(parent.pendingProps.value, currentParent.value) || (null !== current ? current.push(context) : current = [context]);
+        }
+      } else if (parent === hostTransitionProviderCursor.current) {
+        currentParent = parent.alternate;
+        if (null === currentParent) throw Error("Should have a current fiber. This is a bug in React.");
+        currentParent.memoizedState.memoizedState !== parent.memoizedState.memoizedState && (null !== current ? current.push(HostTransitionContext) : current = [HostTransitionContext]);
+      }
+      parent = parent.return;
+    }
+    null !== current && propagateContextChanges(workInProgress, current, renderLanes, forcePropagateEntireTree);
+    workInProgress.flags |= 262144;
+  }
+  function checkIfContextChanged(currentDependencies) {
+    for (currentDependencies = currentDependencies.firstContext; null !== currentDependencies;) {
+      if (!objectIs(currentDependencies.context._currentValue2, currentDependencies.memoizedValue)) return !0;
+      currentDependencies = currentDependencies.next;
+    }
+    return !1;
+  }
+  function prepareToReadContext(workInProgress) {
+    currentlyRenderingFiber$1 = workInProgress;
+    lastContextDependency = null;
+    workInProgress = workInProgress.dependencies;
+    null !== workInProgress && (workInProgress.firstContext = null);
+  }
+  function readContext(context) {
+    return readContextForConsumer(currentlyRenderingFiber$1, context);
+  }
+  function readContextDuringReconciliation(consumer, context) {
+    null === currentlyRenderingFiber$1 && prepareToReadContext(consumer);
+    return readContextForConsumer(consumer, context);
+  }
+  function readContextForConsumer(consumer, context) {
+    var value = context._currentValue2;
+    context = {
+      context: context,
+      memoizedValue: value,
+      next: null
+    };
+    if (null === lastContextDependency) {
+      if (null === consumer) throw Error("Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo().");
+      lastContextDependency = context;
+      consumer.dependencies = {
+        lanes: 0,
+        firstContext: context
+      };
+      consumer.flags |= 524288;
+    } else lastContextDependency = lastContextDependency.next = context;
+    return value;
+  }
+  var AbortControllerLocal = "undefined" !== typeof AbortController ? AbortController : function () {
+      var listeners = [],
+        signal = this.signal = {
+          aborted: !1,
+          addEventListener: function addEventListener(type, listener) {
+            listeners.push(listener);
+          }
+        };
+      this.abort = function () {
+        signal.aborted = !0;
+        listeners.forEach(function (listener) {
+          return listener();
+        });
+      };
+    },
+    CacheContext = {
+      $$typeof: REACT_CONTEXT_TYPE,
+      Consumer: null,
+      Provider: null,
+      _currentValue: null,
+      _currentValue2: null,
+      _threadCount: 0
+    };
+  function createCache() {
+    return {
+      controller: new AbortControllerLocal(),
+      data: new Map(),
+      refCount: 0
+    };
+  }
+  function releaseCache(cache) {
+    cache.refCount--;
+    0 === cache.refCount && _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_scheduleCallback(_$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_NormalPriority, function () {
+      cache.controller.abort();
+    });
+  }
+  var firstScheduledRoot = null,
+    lastScheduledRoot = null,
+    didScheduleMicrotask = !1,
+    mightHavePendingSyncWork = !1,
+    isFlushingWork = !1,
+    currentEventTransitionLane = 0;
+  function ensureRootIsScheduled(root) {
+    root !== lastScheduledRoot && null === root.next && (null === lastScheduledRoot ? firstScheduledRoot = lastScheduledRoot = root : lastScheduledRoot = lastScheduledRoot.next = root);
+    mightHavePendingSyncWork = !0;
+    didScheduleMicrotask || (didScheduleMicrotask = !0, scheduleImmediateRootScheduleTask());
+  }
+  function flushSyncWorkAcrossRoots_impl(syncTransitionLanes, onlyLegacy) {
+    if (!isFlushingWork && mightHavePendingSyncWork) {
+      isFlushingWork = !0;
+      do {
+        var didPerformSomeWork = !1;
+        for (var root = firstScheduledRoot; null !== root;) {
+          if (!onlyLegacy || 0 === root.tag) if (0 !== syncTransitionLanes) {
+            var pendingLanes = root.pendingLanes;
+            if (0 === pendingLanes) var JSCompiler_inline_result = 0;else {
+              var suspendedLanes = root.suspendedLanes,
+                pingedLanes = root.pingedLanes;
+              JSCompiler_inline_result = (1 << 31 - clz32(42 | syncTransitionLanes) + 1) - 1;
+              JSCompiler_inline_result &= pendingLanes & ~(suspendedLanes & ~pingedLanes);
+              JSCompiler_inline_result = JSCompiler_inline_result & 201326741 ? JSCompiler_inline_result & 201326741 | 1 : JSCompiler_inline_result ? JSCompiler_inline_result | 2 : 0;
+            }
+            0 !== JSCompiler_inline_result && (didPerformSomeWork = !0, performSyncWorkOnRoot(root, JSCompiler_inline_result));
+          } else JSCompiler_inline_result = workInProgressRootRenderLanes, JSCompiler_inline_result = getNextLanes(root, root === workInProgressRoot ? JSCompiler_inline_result : 0, null !== root.cancelPendingCommit || -1 !== root.timeoutHandle), 0 === (JSCompiler_inline_result & 3) || checkIfRootIsPrerendering(root, JSCompiler_inline_result) || (didPerformSomeWork = !0, performSyncWorkOnRoot(root, JSCompiler_inline_result));
+          root = root.next;
+        }
+      } while (didPerformSomeWork);
+      isFlushingWork = !1;
+    }
+  }
+  function processRootScheduleInImmediateTask() {
+    processRootScheduleInMicrotask();
+  }
+  function processRootScheduleInMicrotask() {
+    mightHavePendingSyncWork = didScheduleMicrotask = !1;
+    0 !== currentEventTransitionLane && (currentEventTransitionLane = 0);
+    for (var currentTime = _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_now(), prev = null, root = firstScheduledRoot; null !== root;) {
+      var next = root.next,
+        nextLanes = scheduleTaskForRootDuringMicrotask(root, currentTime);
+      0 === nextLanes ? (root.next = null, null === prev ? firstScheduledRoot = next : prev.next = next, null === next && (lastScheduledRoot = prev)) : (prev = root, 0 !== (nextLanes & 3) && (mightHavePendingSyncWork = !0));
+      root = next;
+    }
+    flushSyncWorkAcrossRoots_impl(0, !1);
+  }
+  function scheduleTaskForRootDuringMicrotask(root, currentTime) {
+    for (var suspendedLanes = root.suspendedLanes, pingedLanes = root.pingedLanes, expirationTimes = root.expirationTimes, lanes = root.pendingLanes & -62914561; 0 < lanes;) {
+      var index$9 = 31 - clz32(lanes),
+        lane = 1 << index$9,
+        expirationTime = expirationTimes[index$9];
+      if (-1 === expirationTime) {
+        if (0 === (lane & suspendedLanes) || 0 !== (lane & pingedLanes)) expirationTimes[index$9] = computeExpirationTime(lane, currentTime);
+      } else expirationTime <= currentTime && (root.expiredLanes |= lane);
+      lanes &= ~lane;
+    }
+    currentTime = workInProgressRoot;
+    suspendedLanes = workInProgressRootRenderLanes;
+    suspendedLanes = getNextLanes(root, root === currentTime ? suspendedLanes : 0, null !== root.cancelPendingCommit || -1 !== root.timeoutHandle);
+    pingedLanes = root.callbackNode;
+    if (0 === suspendedLanes || root === currentTime && (2 === workInProgressSuspendedReason || 9 === workInProgressSuspendedReason) || null !== root.cancelPendingCommit) return null !== pingedLanes && null !== pingedLanes && _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_cancelCallback(pingedLanes), root.callbackNode = null, root.callbackPriority = 0;
+    if (0 === (suspendedLanes & 3) || checkIfRootIsPrerendering(root, suspendedLanes)) {
+      currentTime = suspendedLanes & -suspendedLanes;
+      if (currentTime === root.callbackPriority) return currentTime;
+      null !== pingedLanes && _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_cancelCallback(pingedLanes);
+      switch (lanesToEventPriority(suspendedLanes)) {
+        case 2:
+        case 8:
+          suspendedLanes = _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_UserBlockingPriority;
+          break;
+        case 32:
+          suspendedLanes = _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_NormalPriority;
+          break;
+        case 268435456:
+          suspendedLanes = _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_IdlePriority;
+          break;
+        default:
+          suspendedLanes = _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_NormalPriority;
+      }
+      pingedLanes = performWorkOnRootViaSchedulerTask.bind(null, root);
+      suspendedLanes = _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_scheduleCallback(suspendedLanes, pingedLanes);
+      root.callbackPriority = currentTime;
+      root.callbackNode = suspendedLanes;
+      return currentTime;
+    }
+    null !== pingedLanes && null !== pingedLanes && _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_cancelCallback(pingedLanes);
+    root.callbackPriority = 2;
+    root.callbackNode = null;
+    return 2;
+  }
+  function performWorkOnRootViaSchedulerTask(root, didTimeout) {
+    if (0 !== pendingEffectsStatus && 5 !== pendingEffectsStatus) return root.callbackNode = null, root.callbackPriority = 0, null;
+    var originalCallbackNode = root.callbackNode;
+    if (flushPendingEffects(!0) && root.callbackNode !== originalCallbackNode) return null;
+    var workInProgressRootRenderLanes$jscomp$0 = workInProgressRootRenderLanes;
+    workInProgressRootRenderLanes$jscomp$0 = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes$jscomp$0 : 0, null !== root.cancelPendingCommit || -1 !== root.timeoutHandle);
+    if (0 === workInProgressRootRenderLanes$jscomp$0) return null;
+    performWorkOnRoot(root, workInProgressRootRenderLanes$jscomp$0, didTimeout);
+    scheduleTaskForRootDuringMicrotask(root, _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_now());
+    return null != root.callbackNode && root.callbackNode === originalCallbackNode ? performWorkOnRootViaSchedulerTask.bind(null, root) : null;
+  }
+  function performSyncWorkOnRoot(root, lanes) {
+    if (flushPendingEffects()) return null;
+    performWorkOnRoot(root, lanes, !0);
+  }
+  function scheduleImmediateRootScheduleTask() {
+    supportsMicrotasks ? scheduleMicrotask(function () {
+      0 !== (executionContext & 6) ? _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_scheduleCallback(_$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_ImmediatePriority, processRootScheduleInImmediateTask) : processRootScheduleInMicrotask();
+    }) : _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_scheduleCallback(_$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_ImmediatePriority, processRootScheduleInImmediateTask);
+  }
+  function requestTransitionLane() {
+    0 === currentEventTransitionLane && (currentEventTransitionLane = claimNextTransitionLane());
+    return currentEventTransitionLane;
+  }
+  var currentEntangledListeners = null,
+    currentEntangledPendingCount = 0,
+    currentEntangledLane = 0,
+    currentEntangledActionThenable = null;
+  function entangleAsyncAction(transition, thenable) {
+    if (null === currentEntangledListeners) {
+      var entangledListeners = currentEntangledListeners = [];
+      currentEntangledPendingCount = 0;
+      currentEntangledLane = requestTransitionLane();
+      currentEntangledActionThenable = {
+        status: "pending",
+        value: void 0,
+        then: function then(resolve) {
+          entangledListeners.push(resolve);
+        }
+      };
+    }
+    currentEntangledPendingCount++;
+    thenable.then(pingEngtangledActionScope, pingEngtangledActionScope);
+    return thenable;
+  }
+  function pingEngtangledActionScope() {
+    if (0 === --currentEntangledPendingCount && null !== currentEntangledListeners) {
+      null !== currentEntangledActionThenable && (currentEntangledActionThenable.status = "fulfilled");
+      var listeners = currentEntangledListeners;
+      currentEntangledListeners = null;
+      currentEntangledLane = 0;
+      currentEntangledActionThenable = null;
+      for (var i = 0; i < listeners.length; i++) (0, listeners[i])();
+    }
+  }
+  function chainThenableValue(thenable, result) {
+    var listeners = [],
+      thenableWithOverride = {
+        status: "pending",
+        value: null,
+        reason: null,
+        then: function then(resolve) {
+          listeners.push(resolve);
+        }
+      };
+    thenable.then(function () {
+      thenableWithOverride.status = "fulfilled";
+      thenableWithOverride.value = result;
+      for (var i = 0; i < listeners.length; i++) (0, listeners[i])(result);
+    }, function (error) {
+      thenableWithOverride.status = "rejected";
+      thenableWithOverride.reason = error;
+      for (error = 0; error < listeners.length; error++) (0, listeners[error])(void 0);
+    });
+    return thenableWithOverride;
+  }
+  var prevOnStartTransitionFinish = ReactSharedInternals.S;
+  ReactSharedInternals.S = function (transition, returnValue) {
+    "object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && entangleAsyncAction(transition, returnValue);
+    null !== prevOnStartTransitionFinish && prevOnStartTransitionFinish(transition, returnValue);
+  };
+  var resumedCache = createCursor(null);
+  function peekCacheFromPool() {
+    var cacheResumedFromPreviousRender = resumedCache.current;
+    return null !== cacheResumedFromPreviousRender ? cacheResumedFromPreviousRender : workInProgressRoot.pooledCache;
+  }
+  function pushTransition(offscreenWorkInProgress, prevCachePool) {
+    null === prevCachePool ? push(resumedCache, resumedCache.current) : push(resumedCache, prevCachePool.pool);
+  }
+  function getSuspendedCache() {
+    var cacheFromPool = peekCacheFromPool();
+    return null === cacheFromPool ? null : {
+      parent: CacheContext._currentValue2,
+      pool: cacheFromPool
+    };
+  }
+  var hasOwnProperty = Object.prototype.hasOwnProperty;
+  function shallowEqual(objA, objB) {
+    if (objectIs(objA, objB)) return !0;
+    if ("object" !== typeof objA || null === objA || "object" !== typeof objB || null === objB) return !1;
+    var keysA = Object.keys(objA),
+      keysB = Object.keys(objB);
+    if (keysA.length !== keysB.length) return !1;
+    for (keysB = 0; keysB < keysA.length; keysB++) {
+      var currentKey = keysA[keysB];
+      if (!hasOwnProperty.call(objB, currentKey) || !objectIs(objA[currentKey], objB[currentKey])) return !1;
+    }
+    return !0;
+  }
+  var SuspenseException = Error("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`."),
+    SuspenseyCommitException = Error("Suspense Exception: This is not a real error, and should not leak into userspace. If you're seeing this, it's likely a bug in React."),
+    SuspenseActionException = Error("Suspense Exception: This is not a real error! It's an implementation detail of `useActionState` to interrupt the current render. You must either rethrow it immediately, or move the `useActionState` 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."),
+    noopSuspenseyCommitThenable = {
+      then: function then() {}
+    };
+  function isThenableResolved(thenable) {
+    thenable = thenable.status;
+    return "fulfilled" === thenable || "rejected" === thenable;
+  }
+  function noop() {}
+  function trackUsedThenable(thenableState, thenable, index) {
+    index = thenableState[index];
+    void 0 === index ? thenableState.push(thenable) : index !== thenable && (thenable.then(noop, noop), thenable = index);
+    switch (thenable.status) {
+      case "fulfilled":
+        return thenable.value;
+      case "rejected":
+        throw thenableState = thenable.reason, checkIfUseWrappedInAsyncCatch(thenableState), thenableState;
+      default:
+        if ("string" === typeof thenable.status) thenable.then(noop, noop);else {
+          thenableState = workInProgressRoot;
+          if (null !== thenableState && 100 < thenableState.shellSuspendCounter) throw Error("An unknown Component is an async Client Component. Only Server Components can be async at the moment. This error is often caused by accidentally adding `'use client'` to a module that was originally written for the server.");
+          thenableState = thenable;
+          thenableState.status = "pending";
+          thenableState.then(function (fulfilledValue) {
+            if ("pending" === thenable.status) {
+              var fulfilledThenable = thenable;
+              fulfilledThenable.status = "fulfilled";
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, function (error) {
+            if ("pending" === thenable.status) {
+              var rejectedThenable = thenable;
+              rejectedThenable.status = "rejected";
+              rejectedThenable.reason = error;
+            }
+          });
+        }
+        switch (thenable.status) {
+          case "fulfilled":
+            return thenable.value;
+          case "rejected":
+            throw thenableState = thenable.reason, checkIfUseWrappedInAsyncCatch(thenableState), thenableState;
+        }
+        suspendedThenable = thenable;
+        throw SuspenseException;
+    }
+  }
+  var suspendedThenable = null;
+  function getSuspendedThenable() {
+    if (null === suspendedThenable) throw Error("Expected a suspended thenable. This is a bug in React. Please file an issue.");
+    var thenable = suspendedThenable;
+    suspendedThenable = null;
+    return thenable;
+  }
+  function checkIfUseWrappedInAsyncCatch(rejectedReason) {
+    if (rejectedReason === SuspenseException || rejectedReason === SuspenseActionException) throw Error("Hooks are not supported inside an async component. This error is often caused by accidentally adding `'use client'` to a module that was originally written for the server.");
+  }
+  var concurrentQueues = [],
+    concurrentQueuesIndex = 0,
+    concurrentlyUpdatedLanes = 0;
+  function finishQueueingConcurrentUpdates() {
+    for (var endIndex = concurrentQueuesIndex, i = concurrentlyUpdatedLanes = concurrentQueuesIndex = 0; i < endIndex;) {
+      var fiber = concurrentQueues[i];
+      concurrentQueues[i++] = null;
+      var queue = concurrentQueues[i];
+      concurrentQueues[i++] = null;
+      var update = concurrentQueues[i];
+      concurrentQueues[i++] = null;
+      var lane = concurrentQueues[i];
+      concurrentQueues[i++] = null;
+      if (null !== queue && null !== update) {
+        var pending = queue.pending;
+        null === pending ? update.next = update : (update.next = pending.next, pending.next = update);
+        queue.pending = update;
+      }
+      0 !== lane && markUpdateLaneFromFiberToRoot(fiber, update, lane);
+    }
+  }
+  function enqueueUpdate$1(fiber, queue, update, lane) {
+    concurrentQueues[concurrentQueuesIndex++] = fiber;
+    concurrentQueues[concurrentQueuesIndex++] = queue;
+    concurrentQueues[concurrentQueuesIndex++] = update;
+    concurrentQueues[concurrentQueuesIndex++] = lane;
+    concurrentlyUpdatedLanes |= lane;
+    fiber.lanes |= lane;
+    fiber = fiber.alternate;
+    null !== fiber && (fiber.lanes |= lane);
+  }
+  function enqueueConcurrentHookUpdate(fiber, queue, update, lane) {
+    enqueueUpdate$1(fiber, queue, update, lane);
+    return getRootForUpdatedFiber(fiber);
+  }
+  function enqueueConcurrentRenderForLane(fiber, lane) {
+    enqueueUpdate$1(fiber, null, null, lane);
+    return getRootForUpdatedFiber(fiber);
+  }
+  function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
+    sourceFiber.lanes |= lane;
+    var alternate = sourceFiber.alternate;
+    null !== alternate && (alternate.lanes |= lane);
+    for (var isHidden = !1, parent = sourceFiber.return; null !== parent;) parent.childLanes |= lane, alternate = parent.alternate, null !== alternate && (alternate.childLanes |= lane), 22 === parent.tag && (sourceFiber = parent.stateNode, null === sourceFiber || sourceFiber._visibility & 1 || (isHidden = !0)), sourceFiber = parent, parent = parent.return;
+    return 3 === sourceFiber.tag ? (parent = sourceFiber.stateNode, isHidden && null !== update && (isHidden = 31 - clz32(lane), sourceFiber = parent.hiddenUpdates, alternate = sourceFiber[isHidden], null === alternate ? sourceFiber[isHidden] = [update] : alternate.push(update), update.lane = lane | 536870912), parent) : null;
+  }
+  function getRootForUpdatedFiber(sourceFiber) {
+    if (50 < nestedUpdateCount) throw nestedUpdateCount = 0, rootWithNestedUpdates = null, Error("Maximum update depth exceeded. This can happen when a component repeatedly calls setState inside componentWillUpdate or componentDidUpdate. React limits the number of nested updates to prevent infinite loops.");
+    for (var parent = sourceFiber.return; null !== parent;) sourceFiber = parent, parent = sourceFiber.return;
+    return 3 === sourceFiber.tag ? sourceFiber.stateNode : null;
+  }
+  var hasForceUpdate = !1;
+  function initializeUpdateQueue(fiber) {
+    fiber.updateQueue = {
+      baseState: fiber.memoizedState,
+      firstBaseUpdate: null,
+      lastBaseUpdate: null,
+      shared: {
+        pending: null,
+        lanes: 0,
+        hiddenCallbacks: null
+      },
+      callbacks: null
+    };
+  }
+  function cloneUpdateQueue(current, workInProgress) {
+    current = current.updateQueue;
+    workInProgress.updateQueue === current && (workInProgress.updateQueue = {
+      baseState: current.baseState,
+      firstBaseUpdate: current.firstBaseUpdate,
+      lastBaseUpdate: current.lastBaseUpdate,
+      shared: current.shared,
+      callbacks: null
+    });
+  }
+  function createUpdate(lane) {
+    return {
+      lane: lane,
+      tag: 0,
+      payload: null,
+      callback: null,
+      next: null
+    };
+  }
+  function enqueueUpdate(fiber, update, lane) {
+    var updateQueue = fiber.updateQueue;
+    if (null === updateQueue) return null;
+    updateQueue = updateQueue.shared;
+    if (0 !== (executionContext & 2)) {
+      var pending = updateQueue.pending;
+      null === pending ? update.next = update : (update.next = pending.next, pending.next = update);
+      updateQueue.pending = update;
+      update = getRootForUpdatedFiber(fiber);
+      markUpdateLaneFromFiberToRoot(fiber, null, lane);
+      return update;
+    }
+    enqueueUpdate$1(fiber, updateQueue, update, lane);
+    return getRootForUpdatedFiber(fiber);
+  }
+  function entangleTransitions(root, fiber, lane) {
+    fiber = fiber.updateQueue;
+    if (null !== fiber && (fiber = fiber.shared, 0 !== (lane & 4194048))) {
+      var queueLanes = fiber.lanes;
+      queueLanes &= root.pendingLanes;
+      lane |= queueLanes;
+      fiber.lanes = lane;
+      markRootEntangled(root, lane);
+    }
+  }
+  function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
+    var queue = workInProgress.updateQueue,
+      current = workInProgress.alternate;
+    if (null !== current && (current = current.updateQueue, queue === current)) {
+      var newFirst = null,
+        newLast = null;
+      queue = queue.firstBaseUpdate;
+      if (null !== queue) {
+        do {
+          var clone = {
+            lane: queue.lane,
+            tag: queue.tag,
+            payload: queue.payload,
+            callback: null,
+            next: null
+          };
+          null === newLast ? newFirst = newLast = clone : newLast = newLast.next = clone;
+          queue = queue.next;
+        } while (null !== queue);
+        null === newLast ? newFirst = newLast = capturedUpdate : newLast = newLast.next = capturedUpdate;
+      } else newFirst = newLast = capturedUpdate;
+      queue = {
+        baseState: current.baseState,
+        firstBaseUpdate: newFirst,
+        lastBaseUpdate: newLast,
+        shared: current.shared,
+        callbacks: current.callbacks
+      };
+      workInProgress.updateQueue = queue;
+      return;
+    }
+    workInProgress = queue.lastBaseUpdate;
+    null === workInProgress ? queue.firstBaseUpdate = capturedUpdate : workInProgress.next = capturedUpdate;
+    queue.lastBaseUpdate = capturedUpdate;
+  }
+  var didReadFromEntangledAsyncAction = !1;
+  function suspendIfUpdateReadFromEntangledAsyncAction() {
+    if (didReadFromEntangledAsyncAction) {
+      var entangledActionThenable = currentEntangledActionThenable;
+      if (null !== entangledActionThenable) throw entangledActionThenable;
+    }
+  }
+  function processUpdateQueue(workInProgress$jscomp$0, props, instance$jscomp$0, renderLanes) {
+    didReadFromEntangledAsyncAction = !1;
+    var queue = workInProgress$jscomp$0.updateQueue;
+    hasForceUpdate = !1;
+    var firstBaseUpdate = queue.firstBaseUpdate,
+      lastBaseUpdate = queue.lastBaseUpdate,
+      pendingQueue = queue.shared.pending;
+    if (null !== pendingQueue) {
+      queue.shared.pending = null;
+      var lastPendingUpdate = pendingQueue,
+        firstPendingUpdate = lastPendingUpdate.next;
+      lastPendingUpdate.next = null;
+      null === lastBaseUpdate ? firstBaseUpdate = firstPendingUpdate : lastBaseUpdate.next = firstPendingUpdate;
+      lastBaseUpdate = lastPendingUpdate;
+      var current = workInProgress$jscomp$0.alternate;
+      null !== current && (current = current.updateQueue, pendingQueue = current.lastBaseUpdate, pendingQueue !== lastBaseUpdate && (null === pendingQueue ? current.firstBaseUpdate = firstPendingUpdate : pendingQueue.next = firstPendingUpdate, current.lastBaseUpdate = lastPendingUpdate));
+    }
+    if (null !== firstBaseUpdate) {
+      var newState = queue.baseState;
+      lastBaseUpdate = 0;
+      current = firstPendingUpdate = lastPendingUpdate = null;
+      pendingQueue = firstBaseUpdate;
+      do {
+        var updateLane = pendingQueue.lane & -536870913,
+          isHiddenUpdate = updateLane !== pendingQueue.lane;
+        if (isHiddenUpdate ? (workInProgressRootRenderLanes & updateLane) === updateLane : (renderLanes & updateLane) === updateLane) {
+          0 !== updateLane && updateLane === currentEntangledLane && (didReadFromEntangledAsyncAction = !0);
+          null !== current && (current = current.next = {
+            lane: 0,
+            tag: pendingQueue.tag,
+            payload: pendingQueue.payload,
+            callback: null,
+            next: null
+          });
+          a: {
+            var workInProgress = workInProgress$jscomp$0,
+              update = pendingQueue;
+            updateLane = props;
+            var instance = instance$jscomp$0;
+            switch (update.tag) {
+              case 1:
+                workInProgress = update.payload;
+                if ("function" === typeof workInProgress) {
+                  newState = workInProgress.call(instance, newState, updateLane);
+                  break a;
+                }
+                newState = workInProgress;
+                break a;
+              case 3:
+                workInProgress.flags = workInProgress.flags & -65537 | 128;
+              case 0:
+                workInProgress = update.payload;
+                updateLane = "function" === typeof workInProgress ? workInProgress.call(instance, newState, updateLane) : workInProgress;
+                if (null === updateLane || void 0 === updateLane) break a;
+                newState = assign({}, newState, updateLane);
+                break a;
+              case 2:
+                hasForceUpdate = !0;
+            }
+          }
+          updateLane = pendingQueue.callback;
+          null !== updateLane && (workInProgress$jscomp$0.flags |= 64, isHiddenUpdate && (workInProgress$jscomp$0.flags |= 8192), isHiddenUpdate = queue.callbacks, null === isHiddenUpdate ? queue.callbacks = [updateLane] : isHiddenUpdate.push(updateLane));
+        } else isHiddenUpdate = {
+          lane: updateLane,
+          tag: pendingQueue.tag,
+          payload: pendingQueue.payload,
+          callback: pendingQueue.callback,
+          next: null
+        }, null === current ? (firstPendingUpdate = current = isHiddenUpdate, lastPendingUpdate = newState) : current = current.next = isHiddenUpdate, lastBaseUpdate |= updateLane;
+        pendingQueue = pendingQueue.next;
+        if (null === pendingQueue) if (pendingQueue = queue.shared.pending, null === pendingQueue) break;else isHiddenUpdate = pendingQueue, pendingQueue = isHiddenUpdate.next, isHiddenUpdate.next = null, queue.lastBaseUpdate = isHiddenUpdate, queue.shared.pending = null;
+      } while (1);
+      null === current && (lastPendingUpdate = newState);
+      queue.baseState = lastPendingUpdate;
+      queue.firstBaseUpdate = firstPendingUpdate;
+      queue.lastBaseUpdate = current;
+      null === firstBaseUpdate && (queue.shared.lanes = 0);
+      workInProgressRootSkippedLanes |= lastBaseUpdate;
+      workInProgress$jscomp$0.lanes = lastBaseUpdate;
+      workInProgress$jscomp$0.memoizedState = newState;
+    }
+  }
+  function callCallback(callback, context) {
+    if ("function" !== typeof callback) throw Error("Invalid argument passed as callback. Expected a function. Instead received: " + callback);
+    callback.call(context);
+  }
+  function commitCallbacks(updateQueue, context) {
+    var callbacks = updateQueue.callbacks;
+    if (null !== callbacks) for (updateQueue.callbacks = null, updateQueue = 0; updateQueue < callbacks.length; updateQueue++) callCallback(callbacks[updateQueue], context);
+  }
+  var currentTreeHiddenStackCursor = createCursor(null),
+    prevEntangledRenderLanesCursor = createCursor(0);
+  function pushHiddenContext(fiber, context) {
+    fiber = entangledRenderLanes;
+    push(prevEntangledRenderLanesCursor, fiber);
+    push(currentTreeHiddenStackCursor, context);
+    entangledRenderLanes = fiber | context.baseLanes;
+  }
+  function reuseHiddenContextOnStack() {
+    push(prevEntangledRenderLanesCursor, entangledRenderLanes);
+    push(currentTreeHiddenStackCursor, currentTreeHiddenStackCursor.current);
+  }
+  function popHiddenContext() {
+    entangledRenderLanes = prevEntangledRenderLanesCursor.current;
+    pop(currentTreeHiddenStackCursor);
+    pop(prevEntangledRenderLanesCursor);
+  }
+  var renderLanes = 0,
+    currentlyRenderingFiber = null,
+    currentHook = null,
+    workInProgressHook = null,
+    didScheduleRenderPhaseUpdate = !1,
+    didScheduleRenderPhaseUpdateDuringThisPass = !1,
+    shouldDoubleInvokeUserFnsInHooksDEV = !1,
+    thenableIndexCounter$1 = 0,
+    thenableState$1 = null,
+    globalClientIdCounter = 0;
+  function throwInvalidHookError() {
+    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://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.");
+  }
+  function areHookInputsEqual(nextDeps, prevDeps) {
+    if (null === prevDeps) return !1;
+    for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) if (!objectIs(nextDeps[i], prevDeps[i])) return !1;
+    return !0;
+  }
+  function renderWithHooks(current, workInProgress, Component, props, secondArg, nextRenderLanes) {
+    renderLanes = nextRenderLanes;
+    currentlyRenderingFiber = workInProgress;
+    workInProgress.memoizedState = null;
+    workInProgress.updateQueue = null;
+    workInProgress.lanes = 0;
+    ReactSharedInternals.H = null === current || null === current.memoizedState ? HooksDispatcherOnMount : HooksDispatcherOnUpdate;
+    shouldDoubleInvokeUserFnsInHooksDEV = !1;
+    nextRenderLanes = Component(props, secondArg);
+    shouldDoubleInvokeUserFnsInHooksDEV = !1;
+    didScheduleRenderPhaseUpdateDuringThisPass && (nextRenderLanes = renderWithHooksAgain(workInProgress, Component, props, secondArg));
+    finishRenderingHooks(current);
+    return nextRenderLanes;
+  }
+  function finishRenderingHooks(current) {
+    ReactSharedInternals.H = ContextOnlyDispatcher;
+    var didRenderTooFewHooks = null !== currentHook && null !== currentHook.next;
+    renderLanes = 0;
+    workInProgressHook = currentHook = currentlyRenderingFiber = null;
+    didScheduleRenderPhaseUpdate = !1;
+    thenableIndexCounter$1 = 0;
+    thenableState$1 = null;
+    if (didRenderTooFewHooks) throw Error("Rendered fewer hooks than expected. This may be caused by an accidental early return statement.");
+    null === current || didReceiveUpdate || (current = current.dependencies, null !== current && checkIfContextChanged(current) && (didReceiveUpdate = !0));
+  }
+  function renderWithHooksAgain(workInProgress, Component, props, secondArg) {
+    currentlyRenderingFiber = workInProgress;
+    var numberOfReRenders = 0;
+    do {
+      didScheduleRenderPhaseUpdateDuringThisPass && (thenableState$1 = null);
+      thenableIndexCounter$1 = 0;
+      didScheduleRenderPhaseUpdateDuringThisPass = !1;
+      if (25 <= numberOfReRenders) throw Error("Too many re-renders. React limits the number of renders to prevent an infinite loop.");
+      numberOfReRenders += 1;
+      workInProgressHook = currentHook = null;
+      if (null != workInProgress.updateQueue) {
+        var children = workInProgress.updateQueue;
+        children.lastEffect = null;
+        children.events = null;
+        children.stores = null;
+        null != children.memoCache && (children.memoCache.index = 0);
+      }
+      ReactSharedInternals.H = HooksDispatcherOnRerender;
+      children = Component(props, secondArg);
+    } while (didScheduleRenderPhaseUpdateDuringThisPass);
+    return children;
+  }
+  function TransitionAwareHostComponent() {
+    var dispatcher = ReactSharedInternals.H,
+      maybeThenable = dispatcher.useState()[0];
+    maybeThenable = "function" === typeof maybeThenable.then ? useThenable(maybeThenable) : maybeThenable;
+    dispatcher = dispatcher.useState()[0];
+    (null !== currentHook ? currentHook.memoizedState : null) !== dispatcher && (currentlyRenderingFiber.flags |= 1024);
+    return maybeThenable;
+  }
+  function bailoutHooks(current, workInProgress, lanes) {
+    workInProgress.updateQueue = current.updateQueue;
+    workInProgress.flags &= -2053;
+    current.lanes &= ~lanes;
+  }
+  function resetHooksOnUnwind(workInProgress) {
+    if (didScheduleRenderPhaseUpdate) {
+      for (workInProgress = workInProgress.memoizedState; null !== workInProgress;) {
+        var queue = workInProgress.queue;
+        null !== queue && (queue.pending = null);
+        workInProgress = workInProgress.next;
+      }
+      didScheduleRenderPhaseUpdate = !1;
+    }
+    renderLanes = 0;
+    workInProgressHook = currentHook = currentlyRenderingFiber = null;
+    didScheduleRenderPhaseUpdateDuringThisPass = !1;
+    thenableIndexCounter$1 = 0;
+    thenableState$1 = null;
+  }
+  function mountWorkInProgressHook() {
+    var hook = {
+      memoizedState: null,
+      baseState: null,
+      baseQueue: null,
+      queue: null,
+      next: null
+    };
+    null === workInProgressHook ? currentlyRenderingFiber.memoizedState = workInProgressHook = hook : workInProgressHook = workInProgressHook.next = hook;
+    return workInProgressHook;
+  }
+  function updateWorkInProgressHook() {
+    if (null === currentHook) {
+      var nextCurrentHook = currentlyRenderingFiber.alternate;
+      nextCurrentHook = null !== nextCurrentHook ? nextCurrentHook.memoizedState : null;
+    } else nextCurrentHook = currentHook.next;
+    var nextWorkInProgressHook = null === workInProgressHook ? currentlyRenderingFiber.memoizedState : workInProgressHook.next;
+    if (null !== nextWorkInProgressHook) workInProgressHook = nextWorkInProgressHook, currentHook = nextCurrentHook;else {
+      if (null === nextCurrentHook) {
+        if (null === currentlyRenderingFiber.alternate) throw Error("Update hook called on initial render. This is likely a bug in React. Please file an issue.");
+        throw Error("Rendered more hooks than during the previous render.");
+      }
+      currentHook = nextCurrentHook;
+      nextCurrentHook = {
+        memoizedState: currentHook.memoizedState,
+        baseState: currentHook.baseState,
+        baseQueue: currentHook.baseQueue,
+        queue: currentHook.queue,
+        next: null
+      };
+      null === workInProgressHook ? currentlyRenderingFiber.memoizedState = workInProgressHook = nextCurrentHook : workInProgressHook = workInProgressHook.next = nextCurrentHook;
+    }
+    return workInProgressHook;
+  }
+  function createFunctionComponentUpdateQueue() {
+    return {
+      lastEffect: null,
+      events: null,
+      stores: null,
+      memoCache: null
+    };
+  }
+  function useThenable(thenable) {
+    var index = thenableIndexCounter$1;
+    thenableIndexCounter$1 += 1;
+    null === thenableState$1 && (thenableState$1 = []);
+    thenable = trackUsedThenable(thenableState$1, thenable, index);
+    index = currentlyRenderingFiber;
+    null === (null === workInProgressHook ? index.memoizedState : workInProgressHook.next) && (index = index.alternate, ReactSharedInternals.H = null === index || null === index.memoizedState ? HooksDispatcherOnMount : HooksDispatcherOnUpdate);
+    return thenable;
+  }
+  function use(usable) {
+    if (null !== usable && "object" === typeof usable) {
+      if ("function" === typeof usable.then) return useThenable(usable);
+      if (usable.$$typeof === REACT_CONTEXT_TYPE) return readContext(usable);
+    }
+    throw Error("An unsupported type was passed to use(): " + String(usable));
+  }
+  function useMemoCache(size) {
+    var memoCache = null,
+      updateQueue = currentlyRenderingFiber.updateQueue;
+    null !== updateQueue && (memoCache = updateQueue.memoCache);
+    if (null == memoCache) {
+      var current = currentlyRenderingFiber.alternate;
+      null !== current && (current = current.updateQueue, null !== current && (current = current.memoCache, null != current && (memoCache = {
+        data: current.data.map(function (array) {
+          return array.slice();
+        }),
+        index: 0
+      })));
+    }
+    null == memoCache && (memoCache = {
+      data: [],
+      index: 0
+    });
+    null === updateQueue && (updateQueue = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = updateQueue);
+    updateQueue.memoCache = memoCache;
+    updateQueue = memoCache.data[memoCache.index];
+    if (void 0 === updateQueue) for (updateQueue = memoCache.data[memoCache.index] = Array(size), current = 0; current < size; current++) updateQueue[current] = REACT_MEMO_CACHE_SENTINEL;
+    memoCache.index++;
+    return updateQueue;
+  }
+  function basicStateReducer(state, action) {
+    return "function" === typeof action ? action(state) : action;
+  }
+  function updateReducer(reducer) {
+    var hook = updateWorkInProgressHook();
+    return updateReducerImpl(hook, currentHook, reducer);
+  }
+  function updateReducerImpl(hook, current, reducer) {
+    var queue = hook.queue;
+    if (null === queue) throw Error("Should have a queue. You are likely calling Hooks conditionally, which is not allowed. (https://react.dev/link/invalid-hook-call)");
+    queue.lastRenderedReducer = reducer;
+    var baseQueue = hook.baseQueue,
+      pendingQueue = queue.pending;
+    if (null !== pendingQueue) {
+      if (null !== baseQueue) {
+        var baseFirst = baseQueue.next;
+        baseQueue.next = pendingQueue.next;
+        pendingQueue.next = baseFirst;
+      }
+      current.baseQueue = baseQueue = pendingQueue;
+      queue.pending = null;
+    }
+    pendingQueue = hook.baseState;
+    if (null === baseQueue) hook.memoizedState = pendingQueue;else {
+      current = baseQueue.next;
+      var newBaseQueueFirst = baseFirst = null,
+        newBaseQueueLast = null,
+        update = current,
+        didReadFromEntangledAsyncAction$24 = !1;
+      do {
+        var updateLane = update.lane & -536870913;
+        if (updateLane !== update.lane ? (workInProgressRootRenderLanes & updateLane) === updateLane : (renderLanes & updateLane) === updateLane) {
+          var revertLane = update.revertLane;
+          if (0 === revertLane) null !== newBaseQueueLast && (newBaseQueueLast = newBaseQueueLast.next = {
+            lane: 0,
+            revertLane: 0,
+            action: update.action,
+            hasEagerState: update.hasEagerState,
+            eagerState: update.eagerState,
+            next: null
+          }), updateLane === currentEntangledLane && (didReadFromEntangledAsyncAction$24 = !0);else if ((renderLanes & revertLane) === revertLane) {
+            update = update.next;
+            revertLane === currentEntangledLane && (didReadFromEntangledAsyncAction$24 = !0);
+            continue;
+          } else updateLane = {
+            lane: 0,
+            revertLane: update.revertLane,
+            action: update.action,
+            hasEagerState: update.hasEagerState,
+            eagerState: update.eagerState,
+            next: null
+          }, null === newBaseQueueLast ? (newBaseQueueFirst = newBaseQueueLast = updateLane, baseFirst = pendingQueue) : newBaseQueueLast = newBaseQueueLast.next = updateLane, currentlyRenderingFiber.lanes |= revertLane, workInProgressRootSkippedLanes |= revertLane;
+          updateLane = update.action;
+          shouldDoubleInvokeUserFnsInHooksDEV && reducer(pendingQueue, updateLane);
+          pendingQueue = update.hasEagerState ? update.eagerState : reducer(pendingQueue, updateLane);
+        } else revertLane = {
+          lane: updateLane,
+          revertLane: update.revertLane,
+          action: update.action,
+          hasEagerState: update.hasEagerState,
+          eagerState: update.eagerState,
+          next: null
+        }, null === newBaseQueueLast ? (newBaseQueueFirst = newBaseQueueLast = revertLane, baseFirst = pendingQueue) : newBaseQueueLast = newBaseQueueLast.next = revertLane, currentlyRenderingFiber.lanes |= updateLane, workInProgressRootSkippedLanes |= updateLane;
+        update = update.next;
+      } while (null !== update && update !== current);
+      null === newBaseQueueLast ? baseFirst = pendingQueue : newBaseQueueLast.next = newBaseQueueFirst;
+      if (!objectIs(pendingQueue, hook.memoizedState) && (didReceiveUpdate = !0, didReadFromEntangledAsyncAction$24 && (reducer = currentEntangledActionThenable, null !== reducer))) throw reducer;
+      hook.memoizedState = pendingQueue;
+      hook.baseState = baseFirst;
+      hook.baseQueue = newBaseQueueLast;
+      queue.lastRenderedState = pendingQueue;
+    }
+    null === baseQueue && (queue.lanes = 0);
+    return [hook.memoizedState, queue.dispatch];
+  }
+  function rerenderReducer(reducer) {
+    var hook = updateWorkInProgressHook(),
+      queue = hook.queue;
+    if (null === queue) throw Error("Should have a queue. You are likely calling Hooks conditionally, which is not allowed. (https://react.dev/link/invalid-hook-call)");
+    queue.lastRenderedReducer = reducer;
+    var dispatch = queue.dispatch,
+      lastRenderPhaseUpdate = queue.pending,
+      newState = hook.memoizedState;
+    if (null !== lastRenderPhaseUpdate) {
+      queue.pending = null;
+      var update = lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+      do newState = reducer(newState, update.action), update = update.next; while (update !== lastRenderPhaseUpdate);
+      objectIs(newState, hook.memoizedState) || (didReceiveUpdate = !0);
+      hook.memoizedState = newState;
+      null === hook.baseQueue && (hook.baseState = newState);
+      queue.lastRenderedState = newState;
+    }
+    return [newState, dispatch];
+  }
+  function updateSyncExternalStore(subscribe, getSnapshot) {
+    var fiber = currentlyRenderingFiber,
+      hook = updateWorkInProgressHook();
+    var nextSnapshot = getSnapshot();
+    var snapshotChanged = !objectIs((currentHook || hook).memoizedState, nextSnapshot);
+    snapshotChanged && (hook.memoizedState = nextSnapshot, didReceiveUpdate = !0);
+    hook = hook.queue;
+    var create = subscribeToStore.bind(null, fiber, hook, subscribe);
+    updateEffectImpl(2048, 8, create, [subscribe]);
+    if (hook.getSnapshot !== getSnapshot || snapshotChanged || null !== workInProgressHook && workInProgressHook.memoizedState.tag & 1) {
+      fiber.flags |= 2048;
+      pushSimpleEffect(9, createEffectInstance(), updateStoreInstance.bind(null, fiber, hook, nextSnapshot, getSnapshot), null);
+      if (null === workInProgressRoot) throw Error("Expected a work-in-progress root. This is a bug in React. Please file an issue.");
+      0 !== (renderLanes & 124) || pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+    }
+    return nextSnapshot;
+  }
+  function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
+    fiber.flags |= 16384;
+    fiber = {
+      getSnapshot: getSnapshot,
+      value: renderedSnapshot
+    };
+    getSnapshot = currentlyRenderingFiber.updateQueue;
+    null === getSnapshot ? (getSnapshot = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = getSnapshot, getSnapshot.stores = [fiber]) : (renderedSnapshot = getSnapshot.stores, null === renderedSnapshot ? getSnapshot.stores = [fiber] : renderedSnapshot.push(fiber));
+  }
+  function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
+    inst.value = nextSnapshot;
+    inst.getSnapshot = getSnapshot;
+    checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
+  }
+  function subscribeToStore(fiber, inst, subscribe) {
+    return subscribe(function () {
+      checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
+    });
+  }
+  function checkIfSnapshotChanged(inst) {
+    var latestGetSnapshot = inst.getSnapshot;
+    inst = inst.value;
+    try {
+      var nextValue = latestGetSnapshot();
+      return !objectIs(inst, nextValue);
+    } catch (error) {
+      return !0;
+    }
+  }
+  function forceStoreRerender(fiber) {
+    var root = enqueueConcurrentRenderForLane(fiber, 2);
+    null !== root && scheduleUpdateOnFiber(root, fiber, 2);
+  }
+  function mountStateImpl(initialState) {
+    var hook = mountWorkInProgressHook();
+    if ("function" === typeof initialState) {
+      var initialStateInitializer = initialState;
+      initialState = initialStateInitializer();
+      if (shouldDoubleInvokeUserFnsInHooksDEV) {
+        setIsStrictModeForDevtools(!0);
+        try {
+          initialStateInitializer();
+        } finally {
+          setIsStrictModeForDevtools(!1);
+        }
+      }
+    }
+    hook.memoizedState = hook.baseState = initialState;
+    hook.queue = {
+      pending: null,
+      lanes: 0,
+      dispatch: null,
+      lastRenderedReducer: basicStateReducer,
+      lastRenderedState: initialState
+    };
+    return hook;
+  }
+  function updateOptimisticImpl(hook, current, passthrough, reducer) {
+    hook.baseState = passthrough;
+    return updateReducerImpl(hook, currentHook, "function" === typeof reducer ? reducer : basicStateReducer);
+  }
+  function dispatchActionState(fiber, actionQueue, setPendingState, setState, payload) {
+    if (isRenderPhaseUpdate(fiber)) throw Error("Cannot update form state while rendering.");
+    fiber = actionQueue.action;
+    if (null !== fiber) {
+      var actionNode = {
+        payload: payload,
+        action: fiber,
+        next: null,
+        isTransition: !0,
+        status: "pending",
+        value: null,
+        reason: null,
+        listeners: [],
+        then: function then(listener) {
+          actionNode.listeners.push(listener);
+        }
+      };
+      null !== ReactSharedInternals.T ? setPendingState(!0) : actionNode.isTransition = !1;
+      setState(actionNode);
+      setPendingState = actionQueue.pending;
+      null === setPendingState ? (actionNode.next = actionQueue.pending = actionNode, runActionStateAction(actionQueue, actionNode)) : (actionNode.next = setPendingState.next, actionQueue.pending = setPendingState.next = actionNode);
+    }
+  }
+  function runActionStateAction(actionQueue, node) {
+    var action = node.action,
+      payload = node.payload,
+      prevState = actionQueue.state;
+    if (node.isTransition) {
+      var prevTransition = ReactSharedInternals.T,
+        currentTransition = {};
+      ReactSharedInternals.T = currentTransition;
+      try {
+        var returnValue = action(prevState, payload),
+          onStartTransitionFinish = ReactSharedInternals.S;
+        null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
+        handleActionReturnValue(actionQueue, node, returnValue);
+      } catch (error) {
+        onActionError(actionQueue, node, error);
+      } finally {
+        ReactSharedInternals.T = prevTransition;
+      }
+    } else try {
+      prevTransition = action(prevState, payload), handleActionReturnValue(actionQueue, node, prevTransition);
+    } catch (error$28) {
+      onActionError(actionQueue, node, error$28);
+    }
+  }
+  function handleActionReturnValue(actionQueue, node, returnValue) {
+    null !== returnValue && "object" === typeof returnValue && "function" === typeof returnValue.then ? returnValue.then(function (nextState) {
+      onActionSuccess(actionQueue, node, nextState);
+    }, function (error) {
+      return onActionError(actionQueue, node, error);
+    }) : onActionSuccess(actionQueue, node, returnValue);
+  }
+  function onActionSuccess(actionQueue, actionNode, nextState) {
+    actionNode.status = "fulfilled";
+    actionNode.value = nextState;
+    notifyActionListeners(actionNode);
+    actionQueue.state = nextState;
+    actionNode = actionQueue.pending;
+    null !== actionNode && (nextState = actionNode.next, nextState === actionNode ? actionQueue.pending = null : (nextState = nextState.next, actionNode.next = nextState, runActionStateAction(actionQueue, nextState)));
+  }
+  function onActionError(actionQueue, actionNode, error) {
+    var last = actionQueue.pending;
+    actionQueue.pending = null;
+    if (null !== last) {
+      last = last.next;
+      do actionNode.status = "rejected", actionNode.reason = error, notifyActionListeners(actionNode), actionNode = actionNode.next; while (actionNode !== last);
+    }
+    actionQueue.action = null;
+  }
+  function notifyActionListeners(actionNode) {
+    actionNode = actionNode.listeners;
+    for (var i = 0; i < actionNode.length; i++) (0, actionNode[i])();
+  }
+  function actionStateReducer(oldState, newState) {
+    return newState;
+  }
+  function mountActionState(action, initialStateProp) {
+    var stateHook = mountWorkInProgressHook();
+    stateHook.memoizedState = stateHook.baseState = initialStateProp;
+    var stateQueue = {
+      pending: null,
+      lanes: 0,
+      dispatch: null,
+      lastRenderedReducer: actionStateReducer,
+      lastRenderedState: initialStateProp
+    };
+    stateHook.queue = stateQueue;
+    stateHook = dispatchSetState.bind(null, currentlyRenderingFiber, stateQueue);
+    stateQueue.dispatch = stateHook;
+    stateQueue = mountStateImpl(!1);
+    var setPendingState = dispatchOptimisticSetState.bind(null, currentlyRenderingFiber, !1, stateQueue.queue);
+    stateQueue = mountWorkInProgressHook();
+    var actionQueue = {
+      state: initialStateProp,
+      dispatch: null,
+      action: action,
+      pending: null
+    };
+    stateQueue.queue = actionQueue;
+    stateHook = dispatchActionState.bind(null, currentlyRenderingFiber, actionQueue, setPendingState, stateHook);
+    actionQueue.dispatch = stateHook;
+    stateQueue.memoizedState = action;
+    return [initialStateProp, stateHook, !1];
+  }
+  function updateActionState(action) {
+    var stateHook = updateWorkInProgressHook();
+    return updateActionStateImpl(stateHook, currentHook, action);
+  }
+  function updateActionStateImpl(stateHook, currentStateHook, action) {
+    currentStateHook = updateReducerImpl(stateHook, currentStateHook, actionStateReducer)[0];
+    stateHook = updateReducer(basicStateReducer)[0];
+    if ("object" === typeof currentStateHook && null !== currentStateHook && "function" === typeof currentStateHook.then) try {
+      var state = useThenable(currentStateHook);
+    } catch (x) {
+      if (x === SuspenseException) throw SuspenseActionException;
+      throw x;
+    } else state = currentStateHook;
+    currentStateHook = updateWorkInProgressHook();
+    var actionQueue = currentStateHook.queue,
+      dispatch = actionQueue.dispatch;
+    action !== currentStateHook.memoizedState && (currentlyRenderingFiber.flags |= 2048, pushSimpleEffect(9, createEffectInstance(), actionStateActionEffect.bind(null, actionQueue, action), null));
+    return [state, dispatch, stateHook];
+  }
+  function actionStateActionEffect(actionQueue, action) {
+    actionQueue.action = action;
+  }
+  function rerenderActionState(action) {
+    var stateHook = updateWorkInProgressHook(),
+      currentStateHook = currentHook;
+    if (null !== currentStateHook) return updateActionStateImpl(stateHook, currentStateHook, action);
+    updateWorkInProgressHook();
+    stateHook = stateHook.memoizedState;
+    currentStateHook = updateWorkInProgressHook();
+    var dispatch = currentStateHook.queue.dispatch;
+    currentStateHook.memoizedState = action;
+    return [stateHook, dispatch, !1];
+  }
+  function pushSimpleEffect(tag, inst, create, createDeps) {
+    tag = {
+      tag: tag,
+      create: create,
+      deps: createDeps,
+      inst: inst,
+      next: null
+    };
+    inst = currentlyRenderingFiber.updateQueue;
+    null === inst && (inst = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = inst);
+    create = inst.lastEffect;
+    null === create ? inst.lastEffect = tag.next = tag : (createDeps = create.next, create.next = tag, tag.next = createDeps, inst.lastEffect = tag);
+    return tag;
+  }
+  function createEffectInstance() {
+    return {
+      destroy: void 0,
+      resource: void 0
+    };
+  }
+  function updateRef() {
+    return updateWorkInProgressHook().memoizedState;
+  }
+  function mountEffectImpl(fiberFlags, hookFlags, create, createDeps) {
+    var hook = mountWorkInProgressHook();
+    createDeps = void 0 === createDeps ? null : createDeps;
+    currentlyRenderingFiber.flags |= fiberFlags;
+    hook.memoizedState = pushSimpleEffect(1 | hookFlags, createEffectInstance(), create, createDeps);
+  }
+  function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
+    var hook = updateWorkInProgressHook();
+    deps = void 0 === deps ? null : deps;
+    var inst = hook.memoizedState.inst;
+    null !== currentHook && null !== deps && areHookInputsEqual(deps, currentHook.memoizedState.deps) ? hook.memoizedState = pushSimpleEffect(hookFlags, inst, create, deps) : (currentlyRenderingFiber.flags |= fiberFlags, hook.memoizedState = pushSimpleEffect(1 | hookFlags, inst, create, deps));
+  }
+  function mountEffect(create, createDeps) {
+    mountEffectImpl(8390656, 8, create, createDeps);
+  }
+  function updateEffect(create, createDeps) {
+    updateEffectImpl(2048, 8, create, createDeps);
+  }
+  function updateInsertionEffect(create, deps) {
+    return updateEffectImpl(4, 2, create, deps);
+  }
+  function updateLayoutEffect(create, deps) {
+    return updateEffectImpl(4, 4, create, deps);
+  }
+  function imperativeHandleEffect(create, ref) {
+    if ("function" === typeof ref) {
+      create = create();
+      var refCleanup = ref(create);
+      return function () {
+        "function" === typeof refCleanup ? refCleanup() : ref(null);
+      };
+    }
+    if (null !== ref && void 0 !== ref) return create = create(), ref.current = create, function () {
+      ref.current = null;
+    };
+  }
+  function updateImperativeHandle(ref, create, deps) {
+    deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+    updateEffectImpl(4, 4, imperativeHandleEffect.bind(null, create, ref), deps);
+  }
+  function mountDebugValue() {}
+  function updateCallback(callback, deps) {
+    var hook = updateWorkInProgressHook();
+    deps = void 0 === deps ? null : deps;
+    var prevState = hook.memoizedState;
+    if (null !== deps && areHookInputsEqual(deps, prevState[1])) return prevState[0];
+    hook.memoizedState = [callback, deps];
+    return callback;
+  }
+  function updateMemo(nextCreate, deps) {
+    var hook = updateWorkInProgressHook();
+    deps = void 0 === deps ? null : deps;
+    var prevState = hook.memoizedState;
+    if (null !== deps && areHookInputsEqual(deps, prevState[1])) return prevState[0];
+    prevState = nextCreate();
+    if (shouldDoubleInvokeUserFnsInHooksDEV) {
+      setIsStrictModeForDevtools(!0);
+      try {
+        nextCreate();
+      } finally {
+        setIsStrictModeForDevtools(!1);
+      }
+    }
+    hook.memoizedState = [prevState, deps];
+    return prevState;
+  }
+  function mountDeferredValueImpl(hook, value, initialValue) {
+    if (void 0 === initialValue || 0 !== (renderLanes & 1073741824)) return hook.memoizedState = value;
+    hook.memoizedState = initialValue;
+    hook = requestDeferredLane();
+    currentlyRenderingFiber.lanes |= hook;
+    workInProgressRootSkippedLanes |= hook;
+    return initialValue;
+  }
+  function updateDeferredValueImpl(hook, prevValue, value, initialValue) {
+    if (objectIs(value, prevValue)) return value;
+    if (null !== currentTreeHiddenStackCursor.current) return hook = mountDeferredValueImpl(hook, value, initialValue), objectIs(hook, prevValue) || (didReceiveUpdate = !0), hook;
+    if (0 === (renderLanes & 42)) return didReceiveUpdate = !0, hook.memoizedState = value;
+    hook = requestDeferredLane();
+    currentlyRenderingFiber.lanes |= hook;
+    workInProgressRootSkippedLanes |= hook;
+    return prevValue;
+  }
+  function startTransition(fiber, queue, pendingState, finishedState, callback) {
+    var previousPriority = currentUpdatePriority;
+    currentUpdatePriority = 0 !== previousPriority && 8 > previousPriority ? previousPriority : 8;
+    var prevTransition = ReactSharedInternals.T,
+      currentTransition = {};
+    ReactSharedInternals.T = currentTransition;
+    dispatchOptimisticSetState(fiber, !1, queue, pendingState);
+    try {
+      var returnValue = callback(),
+        onStartTransitionFinish = ReactSharedInternals.S;
+      null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
+      if (null !== returnValue && "object" === typeof returnValue && "function" === typeof returnValue.then) {
+        var thenableForFinishedState = chainThenableValue(returnValue, finishedState);
+        dispatchSetStateInternal(fiber, queue, thenableForFinishedState, requestUpdateLane(fiber));
+      } else dispatchSetStateInternal(fiber, queue, finishedState, requestUpdateLane(fiber));
+    } catch (error) {
+      dispatchSetStateInternal(fiber, queue, {
+        then: function then() {},
+        status: "rejected",
+        reason: error
+      }, requestUpdateLane(fiber));
+    } finally {
+      currentUpdatePriority = previousPriority, ReactSharedInternals.T = prevTransition;
+    }
+  }
+  function useHostTransitionStatus() {
+    return readContext(HostTransitionContext);
+  }
+  function updateId() {
+    return updateWorkInProgressHook().memoizedState;
+  }
+  function updateRefresh() {
+    return updateWorkInProgressHook().memoizedState;
+  }
+  function refreshCache(fiber) {
+    for (var provider = fiber.return; null !== provider;) {
+      switch (provider.tag) {
+        case 24:
+        case 3:
+          var lane = requestUpdateLane(provider);
+          fiber = createUpdate(lane);
+          var root = enqueueUpdate(provider, fiber, lane);
+          null !== root && (scheduleUpdateOnFiber(root, provider, lane), entangleTransitions(root, provider, lane));
+          provider = {
+            cache: createCache()
+          };
+          fiber.payload = provider;
+          return;
+      }
+      provider = provider.return;
+    }
+  }
+  function dispatchReducerAction(fiber, queue, action) {
+    var lane = requestUpdateLane(fiber);
+    action = {
+      lane: lane,
+      revertLane: 0,
+      action: action,
+      hasEagerState: !1,
+      eagerState: null,
+      next: null
+    };
+    isRenderPhaseUpdate(fiber) ? enqueueRenderPhaseUpdate(queue, action) : (action = enqueueConcurrentHookUpdate(fiber, queue, action, lane), null !== action && (scheduleUpdateOnFiber(action, fiber, lane), entangleTransitionUpdate(action, queue, lane)));
+  }
+  function dispatchSetState(fiber, queue, action) {
+    var lane = requestUpdateLane(fiber);
+    dispatchSetStateInternal(fiber, queue, action, lane);
+  }
+  function dispatchSetStateInternal(fiber, queue, action, lane) {
+    var update = {
+      lane: lane,
+      revertLane: 0,
+      action: action,
+      hasEagerState: !1,
+      eagerState: null,
+      next: null
+    };
+    if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, update);else {
+      var alternate = fiber.alternate;
+      if (0 === fiber.lanes && (null === alternate || 0 === alternate.lanes) && (alternate = queue.lastRenderedReducer, null !== alternate)) try {
+        var currentState = queue.lastRenderedState,
+          eagerState = alternate(currentState, action);
+        update.hasEagerState = !0;
+        update.eagerState = eagerState;
+        if (objectIs(eagerState, currentState)) return enqueueUpdate$1(fiber, queue, update, 0), null === workInProgressRoot && finishQueueingConcurrentUpdates(), !1;
+      } catch (error) {} finally {}
+      action = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
+      if (null !== action) return scheduleUpdateOnFiber(action, fiber, lane), entangleTransitionUpdate(action, queue, lane), !0;
+    }
+    return !1;
+  }
+  function dispatchOptimisticSetState(fiber, throwIfDuringRender, queue, action) {
+    action = {
+      lane: 2,
+      revertLane: requestTransitionLane(),
+      action: action,
+      hasEagerState: !1,
+      eagerState: null,
+      next: null
+    };
+    if (isRenderPhaseUpdate(fiber)) {
+      if (throwIfDuringRender) throw Error("Cannot update optimistic state while rendering.");
+    } else throwIfDuringRender = enqueueConcurrentHookUpdate(fiber, queue, action, 2), null !== throwIfDuringRender && scheduleUpdateOnFiber(throwIfDuringRender, fiber, 2);
+  }
+  function isRenderPhaseUpdate(fiber) {
+    var alternate = fiber.alternate;
+    return fiber === currentlyRenderingFiber || null !== alternate && alternate === currentlyRenderingFiber;
+  }
+  function enqueueRenderPhaseUpdate(queue, update) {
+    didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate = !0;
+    var pending = queue.pending;
+    null === pending ? update.next = update : (update.next = pending.next, pending.next = update);
+    queue.pending = update;
+  }
+  function entangleTransitionUpdate(root, queue, lane) {
+    if (0 !== (lane & 4194048)) {
+      var queueLanes = queue.lanes;
+      queueLanes &= root.pendingLanes;
+      lane |= queueLanes;
+      queue.lanes = lane;
+      markRootEntangled(root, lane);
+    }
+  }
+  var ContextOnlyDispatcher = {
+      readContext: readContext,
+      use: use,
+      useCallback: throwInvalidHookError,
+      useContext: throwInvalidHookError,
+      useEffect: throwInvalidHookError,
+      useImperativeHandle: throwInvalidHookError,
+      useLayoutEffect: throwInvalidHookError,
+      useInsertionEffect: throwInvalidHookError,
+      useMemo: throwInvalidHookError,
+      useReducer: throwInvalidHookError,
+      useRef: throwInvalidHookError,
+      useState: throwInvalidHookError,
+      useDebugValue: throwInvalidHookError,
+      useDeferredValue: throwInvalidHookError,
+      useTransition: throwInvalidHookError,
+      useSyncExternalStore: throwInvalidHookError,
+      useId: throwInvalidHookError,
+      useHostTransitionStatus: throwInvalidHookError,
+      useFormState: throwInvalidHookError,
+      useActionState: throwInvalidHookError,
+      useOptimistic: throwInvalidHookError,
+      useMemoCache: throwInvalidHookError,
+      useCacheRefresh: throwInvalidHookError
+    },
+    HooksDispatcherOnMount = {
+      readContext: readContext,
+      use: use,
+      useCallback: function useCallback(callback, deps) {
+        mountWorkInProgressHook().memoizedState = [callback, void 0 === deps ? null : deps];
+        return callback;
+      },
+      useContext: readContext,
+      useEffect: mountEffect,
+      useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+        deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+        mountEffectImpl(4194308, 4, imperativeHandleEffect.bind(null, create, ref), deps);
+      },
+      useLayoutEffect: function useLayoutEffect(create, deps) {
+        return mountEffectImpl(4194308, 4, create, deps);
+      },
+      useInsertionEffect: function useInsertionEffect(create, deps) {
+        mountEffectImpl(4, 2, create, deps);
+      },
+      useMemo: function useMemo(nextCreate, deps) {
+        var hook = mountWorkInProgressHook();
+        deps = void 0 === deps ? null : deps;
+        var nextValue = nextCreate();
+        if (shouldDoubleInvokeUserFnsInHooksDEV) {
+          setIsStrictModeForDevtools(!0);
+          try {
+            nextCreate();
+          } finally {
+            setIsStrictModeForDevtools(!1);
+          }
+        }
+        hook.memoizedState = [nextValue, deps];
+        return nextValue;
+      },
+      useReducer: function useReducer(reducer, initialArg, init) {
+        var hook = mountWorkInProgressHook();
+        if (void 0 !== init) {
+          var initialState = init(initialArg);
+          if (shouldDoubleInvokeUserFnsInHooksDEV) {
+            setIsStrictModeForDevtools(!0);
+            try {
+              init(initialArg);
+            } finally {
+              setIsStrictModeForDevtools(!1);
+            }
+          }
+        } else initialState = initialArg;
+        hook.memoizedState = hook.baseState = initialState;
+        reducer = {
+          pending: null,
+          lanes: 0,
+          dispatch: null,
+          lastRenderedReducer: reducer,
+          lastRenderedState: initialState
+        };
+        hook.queue = reducer;
+        reducer = reducer.dispatch = dispatchReducerAction.bind(null, currentlyRenderingFiber, reducer);
+        return [hook.memoizedState, reducer];
+      },
+      useRef: function useRef(initialValue) {
+        var hook = mountWorkInProgressHook();
+        initialValue = {
+          current: initialValue
+        };
+        return hook.memoizedState = initialValue;
+      },
+      useState: function useState(initialState) {
+        initialState = mountStateImpl(initialState);
+        var queue = initialState.queue,
+          dispatch = dispatchSetState.bind(null, currentlyRenderingFiber, queue);
+        queue.dispatch = dispatch;
+        return [initialState.memoizedState, dispatch];
+      },
+      useDebugValue: mountDebugValue,
+      useDeferredValue: function useDeferredValue(value, initialValue) {
+        var hook = mountWorkInProgressHook();
+        return mountDeferredValueImpl(hook, value, initialValue);
+      },
+      useTransition: function useTransition() {
+        var stateHook = mountStateImpl(!1);
+        stateHook = startTransition.bind(null, currentlyRenderingFiber, stateHook.queue, !0, !1);
+        mountWorkInProgressHook().memoizedState = stateHook;
+        return [!1, stateHook];
+      },
+      useSyncExternalStore: function useSyncExternalStore(subscribe, getSnapshot) {
+        var fiber = currentlyRenderingFiber,
+          hook = mountWorkInProgressHook();
+        var nextSnapshot = getSnapshot();
+        if (null === workInProgressRoot) throw Error("Expected a work-in-progress root. This is a bug in React. Please file an issue.");
+        0 !== (workInProgressRootRenderLanes & 124) || pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+        hook.memoizedState = nextSnapshot;
+        var inst = {
+          value: nextSnapshot,
+          getSnapshot: getSnapshot
+        };
+        hook.queue = inst;
+        mountEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [subscribe]);
+        fiber.flags |= 2048;
+        pushSimpleEffect(9, createEffectInstance(), updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot), null);
+        return nextSnapshot;
+      },
+      useId: function useId() {
+        var hook = mountWorkInProgressHook(),
+          identifierPrefix = workInProgressRoot.identifierPrefix,
+          globalClientId = globalClientIdCounter++;
+        identifierPrefix = "\xAB" + identifierPrefix + "r" + globalClientId.toString(32) + "\xBB";
+        return hook.memoizedState = identifierPrefix;
+      },
+      useHostTransitionStatus: useHostTransitionStatus,
+      useFormState: mountActionState,
+      useActionState: mountActionState,
+      useOptimistic: function useOptimistic(passthrough) {
+        var hook = mountWorkInProgressHook();
+        hook.memoizedState = hook.baseState = passthrough;
+        var queue = {
+          pending: null,
+          lanes: 0,
+          dispatch: null,
+          lastRenderedReducer: null,
+          lastRenderedState: null
+        };
+        hook.queue = queue;
+        hook = dispatchOptimisticSetState.bind(null, currentlyRenderingFiber, !0, queue);
+        queue.dispatch = hook;
+        return [passthrough, hook];
+      },
+      useMemoCache: useMemoCache,
+      useCacheRefresh: function useCacheRefresh() {
+        return mountWorkInProgressHook().memoizedState = refreshCache.bind(null, currentlyRenderingFiber);
+      }
+    },
+    HooksDispatcherOnUpdate = {
+      readContext: readContext,
+      use: use,
+      useCallback: updateCallback,
+      useContext: readContext,
+      useEffect: updateEffect,
+      useImperativeHandle: updateImperativeHandle,
+      useInsertionEffect: updateInsertionEffect,
+      useLayoutEffect: updateLayoutEffect,
+      useMemo: updateMemo,
+      useReducer: updateReducer,
+      useRef: updateRef,
+      useState: function useState() {
+        return updateReducer(basicStateReducer);
+      },
+      useDebugValue: mountDebugValue,
+      useDeferredValue: function useDeferredValue(value, initialValue) {
+        var hook = updateWorkInProgressHook();
+        return updateDeferredValueImpl(hook, currentHook.memoizedState, value, initialValue);
+      },
+      useTransition: function useTransition() {
+        var booleanOrThenable = updateReducer(basicStateReducer)[0],
+          start = updateWorkInProgressHook().memoizedState;
+        return ["boolean" === typeof booleanOrThenable ? booleanOrThenable : useThenable(booleanOrThenable), start];
+      },
+      useSyncExternalStore: updateSyncExternalStore,
+      useId: updateId,
+      useHostTransitionStatus: useHostTransitionStatus,
+      useFormState: updateActionState,
+      useActionState: updateActionState,
+      useOptimistic: function useOptimistic(passthrough, reducer) {
+        var hook = updateWorkInProgressHook();
+        return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
+      },
+      useMemoCache: useMemoCache,
+      useCacheRefresh: updateRefresh
+    },
+    HooksDispatcherOnRerender = {
+      readContext: readContext,
+      use: use,
+      useCallback: updateCallback,
+      useContext: readContext,
+      useEffect: updateEffect,
+      useImperativeHandle: updateImperativeHandle,
+      useInsertionEffect: updateInsertionEffect,
+      useLayoutEffect: updateLayoutEffect,
+      useMemo: updateMemo,
+      useReducer: rerenderReducer,
+      useRef: updateRef,
+      useState: function useState() {
+        return rerenderReducer(basicStateReducer);
+      },
+      useDebugValue: mountDebugValue,
+      useDeferredValue: function useDeferredValue(value, initialValue) {
+        var hook = updateWorkInProgressHook();
+        return null === currentHook ? mountDeferredValueImpl(hook, value, initialValue) : updateDeferredValueImpl(hook, currentHook.memoizedState, value, initialValue);
+      },
+      useTransition: function useTransition() {
+        var booleanOrThenable = rerenderReducer(basicStateReducer)[0],
+          start = updateWorkInProgressHook().memoizedState;
+        return ["boolean" === typeof booleanOrThenable ? booleanOrThenable : useThenable(booleanOrThenable), start];
+      },
+      useSyncExternalStore: updateSyncExternalStore,
+      useId: updateId,
+      useHostTransitionStatus: useHostTransitionStatus,
+      useFormState: rerenderActionState,
+      useActionState: rerenderActionState,
+      useOptimistic: function useOptimistic(passthrough, reducer) {
+        var hook = updateWorkInProgressHook();
+        if (null !== currentHook) return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
+        hook.baseState = passthrough;
+        return [passthrough, hook.queue.dispatch];
+      },
+      useMemoCache: useMemoCache,
+      useCacheRefresh: updateRefresh
+    },
+    thenableState = null,
+    thenableIndexCounter = 0;
+  function unwrapThenable(thenable) {
+    var index = thenableIndexCounter;
+    thenableIndexCounter += 1;
+    null === thenableState && (thenableState = []);
+    return trackUsedThenable(thenableState, thenable, index);
+  }
+  function coerceRef(workInProgress, element) {
+    element = element.props.ref;
+    workInProgress.ref = void 0 !== element ? element : null;
+  }
+  function throwOnInvalidObjectType(returnFiber, newChild) {
+    if (newChild.$$typeof === REACT_LEGACY_ELEMENT_TYPE) throw Error('A React Element from an older version of React was rendered. This is not supported. It can happen if:\n- Multiple copies of the "react" package is used.\n- A library pre-bundled an old copy of "react" or "react/jsx-runtime".\n- A compiler tries to "inline" JSX instead of using the runtime.');
+    returnFiber = Object.prototype.toString.call(newChild);
+    throw Error("Objects are not valid as a React child (found: " + ("[object Object]" === returnFiber ? "object with keys {" + Object.keys(newChild).join(", ") + "}" : returnFiber) + "). If you meant to render a collection of children, use an array instead.");
+  }
+  function resolveLazy(lazyType) {
+    var init = lazyType._init;
+    return init(lazyType._payload);
+  }
+  function createChildReconciler(shouldTrackSideEffects) {
+    function deleteChild(returnFiber, childToDelete) {
+      if (shouldTrackSideEffects) {
+        var deletions = returnFiber.deletions;
+        null === deletions ? (returnFiber.deletions = [childToDelete], returnFiber.flags |= 16) : deletions.push(childToDelete);
+      }
+    }
+    function deleteRemainingChildren(returnFiber, currentFirstChild) {
+      if (!shouldTrackSideEffects) return null;
+      for (; null !== currentFirstChild;) deleteChild(returnFiber, currentFirstChild), currentFirstChild = currentFirstChild.sibling;
+      return null;
+    }
+    function mapRemainingChildren(currentFirstChild) {
+      for (var existingChildren = new Map(); null !== currentFirstChild;) null !== currentFirstChild.key ? existingChildren.set(currentFirstChild.key, currentFirstChild) : existingChildren.set(currentFirstChild.index, currentFirstChild), currentFirstChild = currentFirstChild.sibling;
+      return existingChildren;
+    }
+    function useFiber(fiber, pendingProps) {
+      fiber = createWorkInProgress(fiber, pendingProps);
+      fiber.index = 0;
+      fiber.sibling = null;
+      return fiber;
+    }
+    function placeChild(newFiber, lastPlacedIndex, newIndex) {
+      newFiber.index = newIndex;
+      if (!shouldTrackSideEffects) return newFiber.flags |= 1048576, lastPlacedIndex;
+      newIndex = newFiber.alternate;
+      if (null !== newIndex) return newIndex = newIndex.index, newIndex < lastPlacedIndex ? (newFiber.flags |= 67108866, lastPlacedIndex) : newIndex;
+      newFiber.flags |= 67108866;
+      return lastPlacedIndex;
+    }
+    function placeSingleChild(newFiber) {
+      shouldTrackSideEffects && null === newFiber.alternate && (newFiber.flags |= 67108866);
+      return newFiber;
+    }
+    function updateTextNode(returnFiber, current, textContent, lanes) {
+      if (null === current || 6 !== current.tag) return current = createFiberFromText(textContent, returnFiber.mode, lanes), current.return = returnFiber, current;
+      current = useFiber(current, textContent);
+      current.return = returnFiber;
+      return current;
+    }
+    function updateElement(returnFiber, current, element, lanes) {
+      var elementType = element.type;
+      if (elementType === REACT_FRAGMENT_TYPE) return updateFragment(returnFiber, current, element.props.children, lanes, element.key);
+      if (null !== current && (current.elementType === elementType || "object" === typeof elementType && null !== elementType && elementType.$$typeof === REACT_LAZY_TYPE && resolveLazy(elementType) === current.type)) return current = useFiber(current, element.props), coerceRef(current, element), current.return = returnFiber, current;
+      current = createFiberFromTypeAndProps(element.type, element.key, element.props, null, returnFiber.mode, lanes);
+      coerceRef(current, element);
+      current.return = returnFiber;
+      return current;
+    }
+    function updatePortal(returnFiber, current, portal, lanes) {
+      if (null === current || 4 !== current.tag || current.stateNode.containerInfo !== portal.containerInfo || current.stateNode.implementation !== portal.implementation) return current = createFiberFromPortal(portal, returnFiber.mode, lanes), current.return = returnFiber, current;
+      current = useFiber(current, portal.children || []);
+      current.return = returnFiber;
+      return current;
+    }
+    function updateFragment(returnFiber, current, fragment, lanes, key) {
+      if (null === current || 7 !== current.tag) return current = createFiberFromFragment(fragment, returnFiber.mode, lanes, key), current.return = returnFiber, current;
+      current = useFiber(current, fragment);
+      current.return = returnFiber;
+      return current;
+    }
+    function createChild(returnFiber, newChild, lanes) {
+      if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild) return newChild = createFiberFromText("" + newChild, returnFiber.mode, lanes), newChild.return = returnFiber, newChild;
+      if ("object" === typeof newChild && null !== newChild) {
+        switch (newChild.$$typeof) {
+          case REACT_ELEMENT_TYPE:
+            return lanes = createFiberFromTypeAndProps(newChild.type, newChild.key, newChild.props, null, returnFiber.mode, lanes), coerceRef(lanes, newChild), lanes.return = returnFiber, lanes;
+          case REACT_PORTAL_TYPE:
+            return newChild = createFiberFromPortal(newChild, returnFiber.mode, lanes), newChild.return = returnFiber, newChild;
+          case REACT_LAZY_TYPE:
+            var init = newChild._init;
+            newChild = init(newChild._payload);
+            return createChild(returnFiber, newChild, lanes);
+        }
+        if (isArrayImpl(newChild) || getIteratorFn(newChild)) return newChild = createFiberFromFragment(newChild, returnFiber.mode, lanes, null), newChild.return = returnFiber, newChild;
+        if ("function" === typeof newChild.then) return createChild(returnFiber, unwrapThenable(newChild), lanes);
+        if (newChild.$$typeof === REACT_CONTEXT_TYPE) return createChild(returnFiber, readContextDuringReconciliation(returnFiber, newChild), lanes);
+        throwOnInvalidObjectType(returnFiber, newChild);
+      }
+      return null;
+    }
+    function updateSlot(returnFiber, oldFiber, newChild, lanes) {
+      var key = null !== oldFiber ? oldFiber.key : null;
+      if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild) return null !== key ? null : updateTextNode(returnFiber, oldFiber, "" + newChild, lanes);
+      if ("object" === typeof newChild && null !== newChild) {
+        switch (newChild.$$typeof) {
+          case REACT_ELEMENT_TYPE:
+            return newChild.key === key ? updateElement(returnFiber, oldFiber, newChild, lanes) : null;
+          case REACT_PORTAL_TYPE:
+            return newChild.key === key ? updatePortal(returnFiber, oldFiber, newChild, lanes) : null;
+          case REACT_LAZY_TYPE:
+            return key = newChild._init, newChild = key(newChild._payload), updateSlot(returnFiber, oldFiber, newChild, lanes);
+        }
+        if (isArrayImpl(newChild) || getIteratorFn(newChild)) return null !== key ? null : updateFragment(returnFiber, oldFiber, newChild, lanes, null);
+        if ("function" === typeof newChild.then) return updateSlot(returnFiber, oldFiber, unwrapThenable(newChild), lanes);
+        if (newChild.$$typeof === REACT_CONTEXT_TYPE) return updateSlot(returnFiber, oldFiber, readContextDuringReconciliation(returnFiber, newChild), lanes);
+        throwOnInvalidObjectType(returnFiber, newChild);
+      }
+      return null;
+    }
+    function updateFromMap(existingChildren, returnFiber, newIdx, newChild, lanes) {
+      if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild) return existingChildren = existingChildren.get(newIdx) || null, updateTextNode(returnFiber, existingChildren, "" + newChild, lanes);
+      if ("object" === typeof newChild && null !== newChild) {
+        switch (newChild.$$typeof) {
+          case REACT_ELEMENT_TYPE:
+            return existingChildren = existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, updateElement(returnFiber, existingChildren, newChild, lanes);
+          case REACT_PORTAL_TYPE:
+            return existingChildren = existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, updatePortal(returnFiber, existingChildren, newChild, lanes);
+          case REACT_LAZY_TYPE:
+            var init = newChild._init;
+            newChild = init(newChild._payload);
+            return updateFromMap(existingChildren, returnFiber, newIdx, newChild, lanes);
+        }
+        if (isArrayImpl(newChild) || getIteratorFn(newChild)) return existingChildren = existingChildren.get(newIdx) || null, updateFragment(returnFiber, existingChildren, newChild, lanes, null);
+        if ("function" === typeof newChild.then) return updateFromMap(existingChildren, returnFiber, newIdx, unwrapThenable(newChild), lanes);
+        if (newChild.$$typeof === REACT_CONTEXT_TYPE) return updateFromMap(existingChildren, returnFiber, newIdx, readContextDuringReconciliation(returnFiber, newChild), lanes);
+        throwOnInvalidObjectType(returnFiber, newChild);
+      }
+      return null;
+    }
+    function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, lanes) {
+      for (var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null; null !== oldFiber && newIdx < newChildren.length; newIdx++) {
+        oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
+        var newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], lanes);
+        if (null === newFiber) {
+          null === oldFiber && (oldFiber = nextOldFiber);
+          break;
+        }
+        shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
+        currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
+        null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber;
+        previousNewFiber = newFiber;
+        oldFiber = nextOldFiber;
+      }
+      if (newIdx === newChildren.length) return deleteRemainingChildren(returnFiber, oldFiber), resultingFirstChild;
+      if (null === oldFiber) {
+        for (; newIdx < newChildren.length; newIdx++) oldFiber = createChild(returnFiber, newChildren[newIdx], lanes), null !== oldFiber && (currentFirstChild = placeChild(oldFiber, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = oldFiber : previousNewFiber.sibling = oldFiber, previousNewFiber = oldFiber);
+        return resultingFirstChild;
+      }
+      for (oldFiber = mapRemainingChildren(oldFiber); newIdx < newChildren.length; newIdx++) nextOldFiber = updateFromMap(oldFiber, returnFiber, newIdx, newChildren[newIdx], lanes), null !== nextOldFiber && (shouldTrackSideEffects && null !== nextOldFiber.alternate && oldFiber.delete(null === nextOldFiber.key ? newIdx : nextOldFiber.key), currentFirstChild = placeChild(nextOldFiber, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = nextOldFiber : previousNewFiber.sibling = nextOldFiber, previousNewFiber = nextOldFiber);
+      shouldTrackSideEffects && oldFiber.forEach(function (child) {
+        return deleteChild(returnFiber, child);
+      });
+      return resultingFirstChild;
+    }
+    function reconcileChildrenIterator(returnFiber, currentFirstChild, newChildren, lanes) {
+      if (null == newChildren) throw Error("An iterable object provided no iterator.");
+      for (var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null, step = newChildren.next(); null !== oldFiber && !step.done; newIdx++, step = newChildren.next()) {
+        oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
+        var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
+        if (null === newFiber) {
+          null === oldFiber && (oldFiber = nextOldFiber);
+          break;
+        }
+        shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
+        currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
+        null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber;
+        previousNewFiber = newFiber;
+        oldFiber = nextOldFiber;
+      }
+      if (step.done) return deleteRemainingChildren(returnFiber, oldFiber), resultingFirstChild;
+      if (null === oldFiber) {
+        for (; !step.done; newIdx++, step = newChildren.next()) step = createChild(returnFiber, step.value, lanes), null !== step && (currentFirstChild = placeChild(step, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = step : previousNewFiber.sibling = step, previousNewFiber = step);
+        return resultingFirstChild;
+      }
+      for (oldFiber = mapRemainingChildren(oldFiber); !step.done; newIdx++, step = newChildren.next()) step = updateFromMap(oldFiber, returnFiber, newIdx, step.value, lanes), null !== step && (shouldTrackSideEffects && null !== step.alternate && oldFiber.delete(null === step.key ? newIdx : step.key), currentFirstChild = placeChild(step, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = step : previousNewFiber.sibling = step, previousNewFiber = step);
+      shouldTrackSideEffects && oldFiber.forEach(function (child) {
+        return deleteChild(returnFiber, child);
+      });
+      return resultingFirstChild;
+    }
+    function reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes) {
+      "object" === typeof newChild && null !== newChild && newChild.type === REACT_FRAGMENT_TYPE && null === newChild.key && (newChild = newChild.props.children);
+      if ("object" === typeof newChild && null !== newChild) {
+        switch (newChild.$$typeof) {
+          case REACT_ELEMENT_TYPE:
+            a: {
+              for (var key = newChild.key; null !== currentFirstChild;) {
+                if (currentFirstChild.key === key) {
+                  key = newChild.type;
+                  if (key === REACT_FRAGMENT_TYPE) {
+                    if (7 === currentFirstChild.tag) {
+                      deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+                      lanes = useFiber(currentFirstChild, newChild.props.children);
+                      lanes.return = returnFiber;
+                      returnFiber = lanes;
+                      break a;
+                    }
+                  } else if (currentFirstChild.elementType === key || "object" === typeof key && null !== key && key.$$typeof === REACT_LAZY_TYPE && resolveLazy(key) === currentFirstChild.type) {
+                    deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+                    lanes = useFiber(currentFirstChild, newChild.props);
+                    coerceRef(lanes, newChild);
+                    lanes.return = returnFiber;
+                    returnFiber = lanes;
+                    break a;
+                  }
+                  deleteRemainingChildren(returnFiber, currentFirstChild);
+                  break;
+                } else deleteChild(returnFiber, currentFirstChild);
+                currentFirstChild = currentFirstChild.sibling;
+              }
+              newChild.type === REACT_FRAGMENT_TYPE ? (lanes = createFiberFromFragment(newChild.props.children, returnFiber.mode, lanes, newChild.key), lanes.return = returnFiber, returnFiber = lanes) : (lanes = createFiberFromTypeAndProps(newChild.type, newChild.key, newChild.props, null, returnFiber.mode, lanes), coerceRef(lanes, newChild), lanes.return = returnFiber, returnFiber = lanes);
+            }
+            return placeSingleChild(returnFiber);
+          case REACT_PORTAL_TYPE:
+            a: {
+              for (key = newChild.key; null !== currentFirstChild;) {
+                if (currentFirstChild.key === key) {
+                  if (4 === currentFirstChild.tag && currentFirstChild.stateNode.containerInfo === newChild.containerInfo && currentFirstChild.stateNode.implementation === newChild.implementation) {
+                    deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+                    lanes = useFiber(currentFirstChild, newChild.children || []);
+                    lanes.return = returnFiber;
+                    returnFiber = lanes;
+                    break a;
+                  } else {
+                    deleteRemainingChildren(returnFiber, currentFirstChild);
+                    break;
+                  }
+                } else deleteChild(returnFiber, currentFirstChild);
+                currentFirstChild = currentFirstChild.sibling;
+              }
+              lanes = createFiberFromPortal(newChild, returnFiber.mode, lanes);
+              lanes.return = returnFiber;
+              returnFiber = lanes;
+            }
+            return placeSingleChild(returnFiber);
+          case REACT_LAZY_TYPE:
+            return key = newChild._init, newChild = key(newChild._payload), reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes);
+        }
+        if (isArrayImpl(newChild)) return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, lanes);
+        if (getIteratorFn(newChild)) {
+          key = getIteratorFn(newChild);
+          if ("function" !== typeof key) throw Error("An object is not an iterable. This error is likely caused by a bug in React. Please file an issue.");
+          newChild = key.call(newChild);
+          return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, lanes);
+        }
+        if ("function" === typeof newChild.then) return reconcileChildFibersImpl(returnFiber, currentFirstChild, unwrapThenable(newChild), lanes);
+        if (newChild.$$typeof === REACT_CONTEXT_TYPE) return reconcileChildFibersImpl(returnFiber, currentFirstChild, readContextDuringReconciliation(returnFiber, newChild), lanes);
+        throwOnInvalidObjectType(returnFiber, newChild);
+      }
+      return "string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild ? (newChild = "" + newChild, null !== currentFirstChild && 6 === currentFirstChild.tag ? (deleteRemainingChildren(returnFiber, currentFirstChild.sibling), lanes = useFiber(currentFirstChild, newChild), lanes.return = returnFiber, returnFiber = lanes) : (deleteRemainingChildren(returnFiber, currentFirstChild), lanes = createFiberFromText(newChild, returnFiber.mode, lanes), lanes.return = returnFiber, returnFiber = lanes), placeSingleChild(returnFiber)) : deleteRemainingChildren(returnFiber, currentFirstChild);
+    }
+    return function (returnFiber, currentFirstChild, newChild, lanes) {
+      try {
+        thenableIndexCounter = 0;
+        var firstChildFiber = reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes);
+        thenableState = null;
+        return firstChildFiber;
+      } catch (x) {
+        if (x === SuspenseException || x === SuspenseActionException || 0 === (returnFiber.mode & 1) && "object" === typeof x && null !== x && "function" === typeof x.then) throw x;
+        var fiber = createFiberImplClass(29, x, null, returnFiber.mode);
+        fiber.lanes = lanes;
+        fiber.return = returnFiber;
+        return fiber;
+      } finally {}
+    };
+  }
+  var reconcileChildFibers = createChildReconciler(!0),
+    mountChildFibers = createChildReconciler(!1),
+    suspenseHandlerStackCursor = createCursor(null),
+    shellBoundary = null;
+  function pushPrimaryTreeSuspenseHandler(handler) {
+    var current = handler.alternate;
+    push(suspenseStackCursor, suspenseStackCursor.current & 1);
+    push(suspenseHandlerStackCursor, handler);
+    null === shellBoundary && (null === current || null !== currentTreeHiddenStackCursor.current ? shellBoundary = handler : null !== current.memoizedState && (shellBoundary = handler));
+  }
+  function pushOffscreenSuspenseHandler(fiber) {
+    if (22 === fiber.tag) {
+      if (push(suspenseStackCursor, suspenseStackCursor.current), push(suspenseHandlerStackCursor, fiber), null === shellBoundary) {
+        var current = fiber.alternate;
+        null !== current && null !== current.memoizedState && (shellBoundary = fiber);
+      }
+    } else reuseSuspenseHandlerOnStack(fiber);
+  }
+  function reuseSuspenseHandlerOnStack() {
+    push(suspenseStackCursor, suspenseStackCursor.current);
+    push(suspenseHandlerStackCursor, suspenseHandlerStackCursor.current);
+  }
+  function popSuspenseHandler(fiber) {
+    pop(suspenseHandlerStackCursor);
+    shellBoundary === fiber && (shellBoundary = null);
+    pop(suspenseStackCursor);
+  }
+  var suspenseStackCursor = createCursor(0);
+  function findFirstSuspended(row) {
+    for (var node = row; null !== node;) {
+      if (13 === node.tag) {
+        var state = node.memoizedState;
+        if (null !== state && (null === state.dehydrated || shim$1() || shim$1())) return node;
+      } else if (19 === node.tag && void 0 !== node.memoizedProps.revealOrder) {
+        if (0 !== (node.flags & 128)) return node;
+      } else if (null !== node.child) {
+        node.child.return = node;
+        node = node.child;
+        continue;
+      }
+      if (node === row) break;
+      for (; null === node.sibling;) {
+        if (null === node.return || node.return === row) return null;
+        node = node.return;
+      }
+      node.sibling.return = node.return;
+      node = node.sibling;
+    }
+    return null;
+  }
+  function applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, nextProps) {
+    ctor = workInProgress.memoizedState;
+    getDerivedStateFromProps = getDerivedStateFromProps(nextProps, ctor);
+    getDerivedStateFromProps = null === getDerivedStateFromProps || void 0 === getDerivedStateFromProps ? ctor : assign({}, ctor, getDerivedStateFromProps);
+    workInProgress.memoizedState = getDerivedStateFromProps;
+    0 === workInProgress.lanes && (workInProgress.updateQueue.baseState = getDerivedStateFromProps);
+  }
+  var classComponentUpdater = {
+    enqueueSetState: function enqueueSetState(inst, payload, callback) {
+      inst = inst._reactInternals;
+      var lane = requestUpdateLane(inst),
+        update = createUpdate(lane);
+      update.payload = payload;
+      void 0 !== callback && null !== callback && (update.callback = callback);
+      payload = enqueueUpdate(inst, update, lane);
+      null !== payload && (scheduleUpdateOnFiber(payload, inst, lane), entangleTransitions(payload, inst, lane));
+    },
+    enqueueReplaceState: function enqueueReplaceState(inst, payload, callback) {
+      inst = inst._reactInternals;
+      var lane = requestUpdateLane(inst),
+        update = createUpdate(lane);
+      update.tag = 1;
+      update.payload = payload;
+      void 0 !== callback && null !== callback && (update.callback = callback);
+      payload = enqueueUpdate(inst, update, lane);
+      null !== payload && (scheduleUpdateOnFiber(payload, inst, lane), entangleTransitions(payload, inst, lane));
+    },
+    enqueueForceUpdate: function enqueueForceUpdate(inst, callback) {
+      inst = inst._reactInternals;
+      var lane = requestUpdateLane(inst),
+        update = createUpdate(lane);
+      update.tag = 2;
+      void 0 !== callback && null !== callback && (update.callback = callback);
+      callback = enqueueUpdate(inst, update, lane);
+      null !== callback && (scheduleUpdateOnFiber(callback, inst, lane), entangleTransitions(callback, inst, lane));
+    }
+  };
+  function checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) {
+    workInProgress = workInProgress.stateNode;
+    return "function" === typeof workInProgress.shouldComponentUpdate ? workInProgress.shouldComponentUpdate(newProps, newState, nextContext) : ctor.prototype && ctor.prototype.isPureReactComponent ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState) : !0;
+  }
+  function constructClassInstance(workInProgress, ctor, props) {
+    var context = emptyContextObject,
+      contextType = ctor.contextType;
+    "object" === typeof contextType && null !== contextType && (context = readContext(contextType));
+    ctor = new ctor(props, context);
+    workInProgress.memoizedState = null !== ctor.state && void 0 !== ctor.state ? ctor.state : null;
+    ctor.updater = classComponentUpdater;
+    workInProgress.stateNode = ctor;
+    ctor._reactInternals = workInProgress;
+    return ctor;
+  }
+  function callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext) {
+    workInProgress = instance.state;
+    "function" === typeof instance.componentWillReceiveProps && instance.componentWillReceiveProps(newProps, nextContext);
+    "function" === typeof instance.UNSAFE_componentWillReceiveProps && instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+    instance.state !== workInProgress && classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+  function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
+    var instance = workInProgress.stateNode;
+    instance.props = newProps;
+    instance.state = workInProgress.memoizedState;
+    instance.refs = {};
+    initializeUpdateQueue(workInProgress);
+    var contextType = ctor.contextType;
+    instance.context = "object" === typeof contextType && null !== contextType ? readContext(contextType) : emptyContextObject;
+    instance.state = workInProgress.memoizedState;
+    contextType = ctor.getDerivedStateFromProps;
+    "function" === typeof contextType && (applyDerivedStateFromProps(workInProgress, ctor, contextType, newProps), instance.state = workInProgress.memoizedState);
+    "function" === typeof ctor.getDerivedStateFromProps || "function" === typeof instance.getSnapshotBeforeUpdate || "function" !== typeof instance.UNSAFE_componentWillMount && "function" !== typeof instance.componentWillMount || (ctor = instance.state, "function" === typeof instance.componentWillMount && instance.componentWillMount(), "function" === typeof instance.UNSAFE_componentWillMount && instance.UNSAFE_componentWillMount(), ctor !== instance.state && classComponentUpdater.enqueueReplaceState(instance, instance.state, null), processUpdateQueue(workInProgress, newProps, instance, renderLanes), suspendIfUpdateReadFromEntangledAsyncAction(), instance.state = workInProgress.memoizedState);
+    "function" === typeof instance.componentDidMount && (workInProgress.flags |= 4194308);
+  }
+  function resolveClassComponentProps(Component, baseProps) {
+    var newProps = baseProps;
+    if ("ref" in baseProps) {
+      newProps = {};
+      for (var propName in baseProps) "ref" !== propName && (newProps[propName] = baseProps[propName]);
+    }
+    if (Component = Component.defaultProps) {
+      newProps === baseProps && (newProps = assign({}, newProps));
+      for (var propName$54 in Component) void 0 === newProps[propName$54] && (newProps[propName$54] = Component[propName$54]);
+    }
+    return newProps;
+  }
+  var reportGlobalError = "function" === typeof reportError ? reportError : function (error) {
+    if ("object" === typeof window && "function" === typeof window.ErrorEvent) {
+      var event = new window.ErrorEvent("error", {
+        bubbles: !0,
+        cancelable: !0,
+        message: "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error),
+        error: error
+      });
+      if (!window.dispatchEvent(event)) return;
+    } else if ("object" === typeof process && "function" === typeof process.emit) {
+      process.emit("uncaughtException", error);
+      return;
+    }
+    console.error(error);
+  };
+  function defaultOnRecoverableError(error) {
+    reportGlobalError(error);
+  }
+  function logUncaughtError(root, errorInfo) {
+    try {
+      var onUncaughtError = root.onUncaughtError;
+      onUncaughtError(errorInfo.value, {
+        componentStack: errorInfo.stack
+      });
+    } catch (e) {
+      setTimeout(function () {
+        throw e;
+      });
+    }
+  }
+  function logCaughtError(root, boundary, errorInfo) {
+    try {
+      var onCaughtError = root.onCaughtError;
+      onCaughtError(errorInfo.value, {
+        componentStack: errorInfo.stack,
+        errorBoundary: 1 === boundary.tag ? boundary.stateNode : null
+      });
+    } catch (e) {
+      setTimeout(function () {
+        throw e;
+      });
+    }
+  }
+  function createRootErrorUpdate(root, errorInfo, lane) {
+    lane = createUpdate(lane);
+    lane.tag = 3;
+    lane.payload = {
+      element: null
+    };
+    lane.callback = function () {
+      logUncaughtError(root, errorInfo);
+    };
+    return lane;
+  }
+  function createClassErrorUpdate(lane) {
+    lane = createUpdate(lane);
+    lane.tag = 3;
+    return lane;
+  }
+  function initializeClassErrorUpdate(update, root, fiber, errorInfo) {
+    var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+    if ("function" === typeof getDerivedStateFromError) {
+      var error = errorInfo.value;
+      update.payload = function () {
+        return getDerivedStateFromError(error);
+      };
+      update.callback = function () {
+        logCaughtError(root, fiber, errorInfo);
+      };
+    }
+    var inst = fiber.stateNode;
+    null !== inst && "function" === typeof inst.componentDidCatch && (update.callback = function () {
+      logCaughtError(root, fiber, errorInfo);
+      "function" !== typeof getDerivedStateFromError && (null === legacyErrorBoundariesThatAlreadyFailed ? legacyErrorBoundariesThatAlreadyFailed = new Set([this]) : legacyErrorBoundariesThatAlreadyFailed.add(this));
+      var stack = errorInfo.stack;
+      this.componentDidCatch(errorInfo.value, {
+        componentStack: null !== stack ? stack : ""
+      });
+    });
+  }
+  function throwException(root, returnFiber, sourceFiber, value, rootRenderLanes) {
+    sourceFiber.flags |= 32768;
+    if (null !== value && "object" === typeof value && "function" === typeof value.then) {
+      var currentSourceFiber = sourceFiber.alternate;
+      null !== currentSourceFiber && propagateParentContextChanges(currentSourceFiber, sourceFiber, rootRenderLanes, !0);
+      currentSourceFiber = sourceFiber.tag;
+      0 !== (sourceFiber.mode & 1) || 0 !== currentSourceFiber && 11 !== currentSourceFiber && 15 !== currentSourceFiber || ((currentSourceFiber = sourceFiber.alternate) ? (sourceFiber.updateQueue = currentSourceFiber.updateQueue, sourceFiber.memoizedState = currentSourceFiber.memoizedState, sourceFiber.lanes = currentSourceFiber.lanes) : (sourceFiber.updateQueue = null, sourceFiber.memoizedState = null));
+      currentSourceFiber = suspenseHandlerStackCursor.current;
+      if (null !== currentSourceFiber) {
+        switch (currentSourceFiber.tag) {
+          case 13:
+            return sourceFiber.mode & 1 && (null === shellBoundary ? renderDidSuspendDelayIfPossible() : null === currentSourceFiber.alternate && 0 === workInProgressRootExitStatus && (workInProgressRootExitStatus = 3)), currentSourceFiber.flags &= -257, 0 === (currentSourceFiber.mode & 1) ? currentSourceFiber === returnFiber ? currentSourceFiber.flags |= 65536 : (currentSourceFiber.flags |= 128, sourceFiber.flags |= 131072, sourceFiber.flags &= -52805, 1 === sourceFiber.tag ? null === sourceFiber.alternate ? sourceFiber.tag = 17 : (returnFiber = createUpdate(2), returnFiber.tag = 2, enqueueUpdate(sourceFiber, returnFiber, 2)) : 0 === sourceFiber.tag && null === sourceFiber.alternate && (sourceFiber.tag = 28), sourceFiber.lanes |= 2) : (currentSourceFiber.flags |= 65536, currentSourceFiber.lanes = rootRenderLanes), value === noopSuspenseyCommitThenable ? currentSourceFiber.flags |= 16384 : (returnFiber = currentSourceFiber.updateQueue, null === returnFiber ? currentSourceFiber.updateQueue = new Set([value]) : returnFiber.add(value), currentSourceFiber.mode & 1 && attachPingListener(root, value, rootRenderLanes)), !1;
+          case 22:
+            if (currentSourceFiber.mode & 1) return currentSourceFiber.flags |= 65536, value === noopSuspenseyCommitThenable ? currentSourceFiber.flags |= 16384 : (returnFiber = currentSourceFiber.updateQueue, null === returnFiber ? (returnFiber = {
+              transitions: null,
+              markerInstances: null,
+              retryQueue: new Set([value])
+            }, currentSourceFiber.updateQueue = returnFiber) : (sourceFiber = returnFiber.retryQueue, null === sourceFiber ? returnFiber.retryQueue = new Set([value]) : sourceFiber.add(value)), attachPingListener(root, value, rootRenderLanes)), !1;
+        }
+        throw Error("Unexpected Suspense handler tag (" + currentSourceFiber.tag + "). This is a bug in React.");
+      }
+      if (1 === root.tag) return attachPingListener(root, value, rootRenderLanes), renderDidSuspendDelayIfPossible(), !1;
+      value = 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.");
+    }
+    currentSourceFiber = createCapturedValueAtFiber(Error("There was an error during concurrent rendering but React was able to recover by instead synchronously rendering the entire root.", {
+      cause: value
+    }), sourceFiber);
+    null === workInProgressRootConcurrentErrors ? workInProgressRootConcurrentErrors = [currentSourceFiber] : workInProgressRootConcurrentErrors.push(currentSourceFiber);
+    4 !== workInProgressRootExitStatus && (workInProgressRootExitStatus = 2);
+    if (null === returnFiber) return !0;
+    value = createCapturedValueAtFiber(value, sourceFiber);
+    do {
+      switch (returnFiber.tag) {
+        case 3:
+          return returnFiber.flags |= 65536, root = rootRenderLanes & -rootRenderLanes, returnFiber.lanes |= root, root = createRootErrorUpdate(returnFiber.stateNode, value, root), enqueueCapturedUpdate(returnFiber, root), !1;
+        case 1:
+          if (sourceFiber = returnFiber.type, currentSourceFiber = returnFiber.stateNode, 0 === (returnFiber.flags & 128) && ("function" === typeof sourceFiber.getDerivedStateFromError || null !== currentSourceFiber && "function" === typeof currentSourceFiber.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(currentSourceFiber)))) return returnFiber.flags |= 65536, rootRenderLanes &= -rootRenderLanes, returnFiber.lanes |= rootRenderLanes, rootRenderLanes = createClassErrorUpdate(rootRenderLanes), initializeClassErrorUpdate(rootRenderLanes, root, returnFiber, value), enqueueCapturedUpdate(returnFiber, rootRenderLanes), !1;
+      }
+      returnFiber = returnFiber.return;
+    } while (null !== returnFiber);
+    return !1;
+  }
+  var SelectiveHydrationException = Error("This is not a real error. It's an implementation detail of React's selective hydration feature. If this leaks into userspace, it's a bug in React. Please file an issue."),
+    didReceiveUpdate = !1;
+  function reconcileChildren(current, workInProgress, nextChildren, renderLanes) {
+    workInProgress.child = null === current ? mountChildFibers(workInProgress, null, nextChildren, renderLanes) : reconcileChildFibers(workInProgress, current.child, nextChildren, renderLanes);
+  }
+  function updateForwardRef(current, workInProgress, Component, nextProps, renderLanes) {
+    Component = Component.render;
+    var ref = workInProgress.ref;
+    if ("ref" in nextProps) {
+      var propsWithoutRef = {};
+      for (var key in nextProps) "ref" !== key && (propsWithoutRef[key] = nextProps[key]);
+    } else propsWithoutRef = nextProps;
+    prepareToReadContext(workInProgress);
+    nextProps = renderWithHooks(current, workInProgress, Component, propsWithoutRef, ref, renderLanes);
+    if (null !== current && !didReceiveUpdate) return bailoutHooks(current, workInProgress, renderLanes), bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    workInProgress.flags |= 1;
+    reconcileChildren(current, workInProgress, nextProps, renderLanes);
+    return workInProgress.child;
+  }
+  function updateMemoComponent(current, workInProgress, Component, nextProps, renderLanes) {
+    if (null === current) {
+      var type = Component.type;
+      if ("function" === typeof type && !shouldConstruct(type) && void 0 === type.defaultProps && null === Component.compare) return workInProgress.tag = 15, workInProgress.type = type, updateSimpleMemoComponent(current, workInProgress, type, nextProps, renderLanes);
+      current = createFiberFromTypeAndProps(Component.type, null, nextProps, workInProgress, workInProgress.mode, renderLanes);
+      current.ref = workInProgress.ref;
+      current.return = workInProgress;
+      return workInProgress.child = current;
+    }
+    type = current.child;
+    if (!checkScheduledUpdateOrContext(current, renderLanes)) {
+      var prevProps = type.memoizedProps;
+      Component = Component.compare;
+      Component = null !== Component ? Component : shallowEqual;
+      if (Component(prevProps, nextProps) && current.ref === workInProgress.ref) return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    }
+    workInProgress.flags |= 1;
+    current = createWorkInProgress(type, nextProps);
+    current.ref = workInProgress.ref;
+    current.return = workInProgress;
+    return workInProgress.child = current;
+  }
+  function updateSimpleMemoComponent(current, workInProgress, Component, nextProps, renderLanes) {
+    if (null !== current) {
+      var prevProps = current.memoizedProps;
+      if (shallowEqual(prevProps, nextProps) && current.ref === workInProgress.ref) if (didReceiveUpdate = !1, workInProgress.pendingProps = nextProps = prevProps, checkScheduledUpdateOrContext(current, renderLanes)) 0 !== (current.flags & 131072) && (didReceiveUpdate = !0);else return workInProgress.lanes = current.lanes, bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    }
+    return updateFunctionComponent(current, workInProgress, Component, nextProps, renderLanes);
+  }
+  function updateOffscreenComponent(current, workInProgress, renderLanes) {
+    var nextProps = workInProgress.pendingProps,
+      nextChildren = nextProps.children,
+      prevState = null !== current ? current.memoizedState : null;
+    if ("hidden" === nextProps.mode) {
+      if (0 !== (workInProgress.flags & 128)) {
+        nextProps = null !== prevState ? prevState.baseLanes | renderLanes : renderLanes;
+        if (null !== current) {
+          nextChildren = workInProgress.child = current.child;
+          for (prevState = 0; null !== nextChildren;) prevState = prevState | nextChildren.lanes | nextChildren.childLanes, nextChildren = nextChildren.sibling;
+          workInProgress.childLanes = prevState & ~nextProps;
+        } else workInProgress.childLanes = 0, workInProgress.child = null;
+        return deferHiddenOffscreenComponent(current, workInProgress, nextProps, renderLanes);
+      }
+      if (0 === (workInProgress.mode & 1)) workInProgress.memoizedState = {
+        baseLanes: 0,
+        cachePool: null
+      }, null !== current && pushTransition(workInProgress, null), reuseHiddenContextOnStack(), pushOffscreenSuspenseHandler(workInProgress);else if (0 !== (renderLanes & 536870912)) workInProgress.memoizedState = {
+        baseLanes: 0,
+        cachePool: null
+      }, null !== current && pushTransition(workInProgress, null !== prevState ? prevState.cachePool : null), null !== prevState ? pushHiddenContext(workInProgress, prevState) : reuseHiddenContextOnStack(), pushOffscreenSuspenseHandler(workInProgress);else return workInProgress.lanes = workInProgress.childLanes = 536870912, deferHiddenOffscreenComponent(current, workInProgress, null !== prevState ? prevState.baseLanes | renderLanes : renderLanes, renderLanes);
+    } else null !== prevState ? (pushTransition(workInProgress, prevState.cachePool), pushHiddenContext(workInProgress, prevState), reuseSuspenseHandlerOnStack(workInProgress), workInProgress.memoizedState = null) : (null !== current && pushTransition(workInProgress, null), reuseHiddenContextOnStack(), reuseSuspenseHandlerOnStack(workInProgress));
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+    return workInProgress.child;
+  }
+  function deferHiddenOffscreenComponent(current, workInProgress, nextBaseLanes, renderLanes) {
+    var JSCompiler_inline_result = peekCacheFromPool();
+    JSCompiler_inline_result = null === JSCompiler_inline_result ? null : {
+      parent: CacheContext._currentValue2,
+      pool: JSCompiler_inline_result
+    };
+    workInProgress.memoizedState = {
+      baseLanes: nextBaseLanes,
+      cachePool: JSCompiler_inline_result
+    };
+    null !== current && pushTransition(workInProgress, null);
+    reuseHiddenContextOnStack();
+    pushOffscreenSuspenseHandler(workInProgress);
+    null !== current && propagateParentContextChanges(current, workInProgress, renderLanes, !0);
+    return null;
+  }
+  function markRef(current, workInProgress) {
+    var ref = workInProgress.ref;
+    if (null === ref) null !== current && null !== current.ref && (workInProgress.flags |= 4194816);else {
+      if ("function" !== typeof ref && "object" !== typeof ref) throw Error("Expected ref to be a function, an object returned by React.createRef(), or undefined/null.");
+      if (null === current || current.ref !== ref) workInProgress.flags |= 4194816;
+    }
+  }
+  function updateFunctionComponent(current, workInProgress, Component, nextProps, renderLanes) {
+    prepareToReadContext(workInProgress);
+    Component = renderWithHooks(current, workInProgress, Component, nextProps, void 0, renderLanes);
+    if (null !== current && !didReceiveUpdate) return bailoutHooks(current, workInProgress, renderLanes), bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    workInProgress.flags |= 1;
+    reconcileChildren(current, workInProgress, Component, renderLanes);
+    return workInProgress.child;
+  }
+  function replayFunctionComponent(current, workInProgress, nextProps, Component, secondArg, renderLanes) {
+    prepareToReadContext(workInProgress);
+    workInProgress.updateQueue = null;
+    nextProps = renderWithHooksAgain(workInProgress, Component, nextProps, secondArg);
+    finishRenderingHooks(current);
+    if (null !== current && !didReceiveUpdate) return bailoutHooks(current, workInProgress, renderLanes), bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    workInProgress.flags |= 1;
+    reconcileChildren(current, workInProgress, nextProps, renderLanes);
+    return workInProgress.child;
+  }
+  function updateClassComponent(current, workInProgress, Component, nextProps, renderLanes) {
+    prepareToReadContext(workInProgress);
+    if (null === workInProgress.stateNode) resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress), constructClassInstance(workInProgress, Component, nextProps), mountClassInstance(workInProgress, Component, nextProps, renderLanes), nextProps = !0;else if (null === current) {
+      var instance = workInProgress.stateNode,
+        unresolvedOldProps = workInProgress.memoizedProps,
+        oldProps = resolveClassComponentProps(Component, unresolvedOldProps);
+      instance.props = oldProps;
+      var oldContext = instance.context,
+        contextType = Component.contextType,
+        nextContext = emptyContextObject;
+      "object" === typeof contextType && null !== contextType && (nextContext = readContext(contextType));
+      var getDerivedStateFromProps = Component.getDerivedStateFromProps;
+      contextType = "function" === typeof getDerivedStateFromProps || "function" === typeof instance.getSnapshotBeforeUpdate;
+      unresolvedOldProps = workInProgress.pendingProps !== unresolvedOldProps;
+      contextType || "function" !== typeof instance.UNSAFE_componentWillReceiveProps && "function" !== typeof instance.componentWillReceiveProps || (unresolvedOldProps || oldContext !== nextContext) && callComponentWillReceiveProps(workInProgress, instance, nextProps, nextContext);
+      hasForceUpdate = !1;
+      var oldState = workInProgress.memoizedState;
+      instance.state = oldState;
+      processUpdateQueue(workInProgress, nextProps, instance, renderLanes);
+      suspendIfUpdateReadFromEntangledAsyncAction();
+      oldContext = workInProgress.memoizedState;
+      unresolvedOldProps || oldState !== oldContext || hasForceUpdate ? ("function" === typeof getDerivedStateFromProps && (applyDerivedStateFromProps(workInProgress, Component, getDerivedStateFromProps, nextProps), oldContext = workInProgress.memoizedState), (oldProps = hasForceUpdate || checkShouldComponentUpdate(workInProgress, Component, oldProps, nextProps, oldState, oldContext, nextContext)) ? (contextType || "function" !== typeof instance.UNSAFE_componentWillMount && "function" !== typeof instance.componentWillMount || ("function" === typeof instance.componentWillMount && instance.componentWillMount(), "function" === typeof instance.UNSAFE_componentWillMount && instance.UNSAFE_componentWillMount()), "function" === typeof instance.componentDidMount && (workInProgress.flags |= 4194308)) : ("function" === typeof instance.componentDidMount && (workInProgress.flags |= 4194308), workInProgress.memoizedProps = nextProps, workInProgress.memoizedState = oldContext), instance.props = nextProps, instance.state = oldContext, instance.context = nextContext, nextProps = oldProps) : ("function" === typeof instance.componentDidMount && (workInProgress.flags |= 4194308), nextProps = !1);
+    } else {
+      instance = workInProgress.stateNode;
+      cloneUpdateQueue(current, workInProgress);
+      nextContext = workInProgress.memoizedProps;
+      contextType = resolveClassComponentProps(Component, nextContext);
+      instance.props = contextType;
+      getDerivedStateFromProps = workInProgress.pendingProps;
+      oldState = instance.context;
+      oldContext = Component.contextType;
+      oldProps = emptyContextObject;
+      "object" === typeof oldContext && null !== oldContext && (oldProps = readContext(oldContext));
+      unresolvedOldProps = Component.getDerivedStateFromProps;
+      (oldContext = "function" === typeof unresolvedOldProps || "function" === typeof instance.getSnapshotBeforeUpdate) || "function" !== typeof instance.UNSAFE_componentWillReceiveProps && "function" !== typeof instance.componentWillReceiveProps || (nextContext !== getDerivedStateFromProps || oldState !== oldProps) && callComponentWillReceiveProps(workInProgress, instance, nextProps, oldProps);
+      hasForceUpdate = !1;
+      oldState = workInProgress.memoizedState;
+      instance.state = oldState;
+      processUpdateQueue(workInProgress, nextProps, instance, renderLanes);
+      suspendIfUpdateReadFromEntangledAsyncAction();
+      var newState = workInProgress.memoizedState;
+      nextContext !== getDerivedStateFromProps || oldState !== newState || hasForceUpdate || null !== current && null !== current.dependencies && checkIfContextChanged(current.dependencies) ? ("function" === typeof unresolvedOldProps && (applyDerivedStateFromProps(workInProgress, Component, unresolvedOldProps, nextProps), newState = workInProgress.memoizedState), (contextType = hasForceUpdate || checkShouldComponentUpdate(workInProgress, Component, contextType, nextProps, oldState, newState, oldProps) || null !== current && null !== current.dependencies && checkIfContextChanged(current.dependencies)) ? (oldContext || "function" !== typeof instance.UNSAFE_componentWillUpdate && "function" !== typeof instance.componentWillUpdate || ("function" === typeof instance.componentWillUpdate && instance.componentWillUpdate(nextProps, newState, oldProps), "function" === typeof instance.UNSAFE_componentWillUpdate && instance.UNSAFE_componentWillUpdate(nextProps, newState, oldProps)), "function" === typeof instance.componentDidUpdate && (workInProgress.flags |= 4), "function" === typeof instance.getSnapshotBeforeUpdate && (workInProgress.flags |= 1024)) : ("function" !== typeof instance.componentDidUpdate || nextContext === current.memoizedProps && oldState === current.memoizedState || (workInProgress.flags |= 4), "function" !== typeof instance.getSnapshotBeforeUpdate || nextContext === current.memoizedProps && oldState === current.memoizedState || (workInProgress.flags |= 1024), workInProgress.memoizedProps = nextProps, workInProgress.memoizedState = newState), instance.props = nextProps, instance.state = newState, instance.context = oldProps, nextProps = contextType) : ("function" !== typeof instance.componentDidUpdate || nextContext === current.memoizedProps && oldState === current.memoizedState || (workInProgress.flags |= 4), "function" !== typeof instance.getSnapshotBeforeUpdate || nextContext === current.memoizedProps && oldState === current.memoizedState || (workInProgress.flags |= 1024), nextProps = !1);
+    }
+    return finishClassComponent(current, workInProgress, Component, nextProps, !1, renderLanes);
+  }
+  function finishClassComponent(current, workInProgress, Component, shouldUpdate, hasContext, renderLanes) {
+    markRef(current, workInProgress);
+    hasContext = 0 !== (workInProgress.flags & 128);
+    if (!shouldUpdate && !hasContext) return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    shouldUpdate = workInProgress.stateNode;
+    Component = hasContext && "function" !== typeof Component.getDerivedStateFromError ? null : shouldUpdate.render();
+    workInProgress.flags |= 1;
+    null !== current && hasContext ? (workInProgress.child = reconcileChildFibers(workInProgress, current.child, null, renderLanes), workInProgress.child = reconcileChildFibers(workInProgress, null, Component, renderLanes)) : reconcileChildren(current, workInProgress, Component, renderLanes);
+    workInProgress.memoizedState = shouldUpdate.state;
+    return workInProgress.child;
+  }
+  var SUSPENDED_MARKER = {
+    dehydrated: null,
+    treeContext: null,
+    retryLane: 0,
+    hydrationErrors: null
+  };
+  function mountSuspenseOffscreenState(renderLanes) {
+    return {
+      baseLanes: renderLanes,
+      cachePool: getSuspendedCache()
+    };
+  }
+  function getRemainingWorkInPrimaryTree(current, primaryTreeDidDefer, renderLanes) {
+    current = null !== current ? current.childLanes & ~renderLanes : 0;
+    primaryTreeDidDefer && (current |= workInProgressDeferredLane);
+    return current;
+  }
+  function updateSuspenseComponent(current, workInProgress, renderLanes) {
+    var nextProps = workInProgress.pendingProps,
+      showFallback = !1,
+      didSuspend = 0 !== (workInProgress.flags & 128),
+      JSCompiler_temp;
+    (JSCompiler_temp = didSuspend) || (JSCompiler_temp = null !== current && null === current.memoizedState ? !1 : 0 !== (suspenseStackCursor.current & 2));
+    JSCompiler_temp && (showFallback = !0, workInProgress.flags &= -129);
+    JSCompiler_temp = 0 !== (workInProgress.flags & 32);
+    workInProgress.flags &= -33;
+    if (null === current) {
+      var nextPrimaryChildren = nextProps.children;
+      nextProps = nextProps.fallback;
+      if (showFallback) return reuseSuspenseHandlerOnStack(workInProgress), showFallback = workInProgress.mode, didSuspend = workInProgress.child, nextPrimaryChildren = {
+        mode: "hidden",
+        children: nextPrimaryChildren
+      }, 0 === (showFallback & 1) && null !== didSuspend ? (didSuspend.childLanes = 0, didSuspend.pendingProps = nextPrimaryChildren) : didSuspend = mountWorkInProgressOffscreenFiber(nextPrimaryChildren, showFallback), nextProps = createFiberFromFragment(nextProps, showFallback, renderLanes, null), didSuspend.return = workInProgress, nextProps.return = workInProgress, didSuspend.sibling = nextProps, workInProgress.child = didSuspend, nextPrimaryChildren = workInProgress.child, nextPrimaryChildren.memoizedState = mountSuspenseOffscreenState(renderLanes), nextPrimaryChildren.childLanes = getRemainingWorkInPrimaryTree(current, JSCompiler_temp, renderLanes), workInProgress.memoizedState = SUSPENDED_MARKER, nextProps;
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      return mountSuspensePrimaryChildren(workInProgress, nextPrimaryChildren);
+    }
+    nextPrimaryChildren = current.memoizedState;
+    if (null !== nextPrimaryChildren && null !== nextPrimaryChildren.dehydrated) {
+      if (didSuspend) workInProgress.flags & 256 ? (pushPrimaryTreeSuspenseHandler(workInProgress), workInProgress.flags &= -257, workInProgress = retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes)) : null !== workInProgress.memoizedState ? (reuseSuspenseHandlerOnStack(workInProgress), workInProgress.child = current.child, workInProgress.flags |= 128, workInProgress = null) : (reuseSuspenseHandlerOnStack(workInProgress), nextPrimaryChildren = nextProps.fallback, showFallback = workInProgress.mode, nextProps = mountWorkInProgressOffscreenFiber({
+        mode: "visible",
+        children: nextProps.children
+      }, showFallback), nextPrimaryChildren = createFiberFromFragment(nextPrimaryChildren, showFallback, renderLanes, null), nextPrimaryChildren.flags |= 2, nextProps.return = workInProgress, nextPrimaryChildren.return = workInProgress, nextProps.sibling = nextPrimaryChildren, workInProgress.child = nextProps, 0 !== (workInProgress.mode & 1) && reconcileChildFibers(workInProgress, current.child, null, renderLanes), nextProps = workInProgress.child, nextProps.memoizedState = mountSuspenseOffscreenState(renderLanes), nextProps.childLanes = getRemainingWorkInPrimaryTree(current, JSCompiler_temp, renderLanes), workInProgress.memoizedState = SUSPENDED_MARKER, workInProgress = nextPrimaryChildren);else if (pushPrimaryTreeSuspenseHandler(workInProgress), shim$1()) JSCompiler_temp = shim$1().digest, nextProps = Error("The server could not finish this Suspense boundary, likely due to an error during server rendering. Switched to client rendering."), nextProps.stack = "", nextProps.digest = JSCompiler_temp, JSCompiler_temp = {
+        value: nextProps,
+        source: null,
+        stack: null
+      }, null === hydrationErrors ? hydrationErrors = [JSCompiler_temp] : hydrationErrors.push(JSCompiler_temp), workInProgress = retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes);else if (didReceiveUpdate || propagateParentContextChanges(current, workInProgress, renderLanes, !1), JSCompiler_temp = 0 !== (renderLanes & current.childLanes), didReceiveUpdate || JSCompiler_temp) {
+        JSCompiler_temp = workInProgressRoot;
+        if (null !== JSCompiler_temp) {
+          nextProps = renderLanes & -renderLanes;
+          if (0 !== (nextProps & 42)) nextProps = 1;else switch (nextProps) {
+            case 2:
+              nextProps = 1;
+              break;
+            case 8:
+              nextProps = 4;
+              break;
+            case 32:
+              nextProps = 16;
+              break;
+            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:
+              nextProps = 128;
+              break;
+            case 268435456:
+              nextProps = 134217728;
+              break;
+            default:
+              nextProps = 0;
+          }
+          nextProps = 0 !== (nextProps & (JSCompiler_temp.suspendedLanes | renderLanes)) ? 0 : nextProps;
+          if (0 !== nextProps && nextProps !== nextPrimaryChildren.retryLane) throw nextPrimaryChildren.retryLane = nextProps, enqueueConcurrentRenderForLane(current, nextProps), scheduleUpdateOnFiber(JSCompiler_temp, current, nextProps), SelectiveHydrationException;
+        }
+        shim$1() || renderDidSuspendDelayIfPossible();
+        workInProgress = retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes);
+      } else shim$1() ? (workInProgress.flags |= 192, workInProgress.child = current.child, workInProgress = null) : (workInProgress = mountSuspensePrimaryChildren(workInProgress, nextProps.children), workInProgress.flags |= 4096);
+      return workInProgress;
+    }
+    if (showFallback) {
+      reuseSuspenseHandlerOnStack(workInProgress);
+      nextPrimaryChildren = nextProps.fallback;
+      showFallback = workInProgress.mode;
+      didSuspend = current.child;
+      var currentFallbackChildFragment = didSuspend.sibling,
+        primaryChildProps = {
+          mode: "hidden",
+          children: nextProps.children
+        };
+      0 === (showFallback & 1) && workInProgress.child !== didSuspend ? (nextProps = workInProgress.child, nextProps.childLanes = 0, nextProps.pendingProps = primaryChildProps, workInProgress.deletions = null) : (nextProps = createWorkInProgress(didSuspend, primaryChildProps), nextProps.subtreeFlags = didSuspend.subtreeFlags & 65011712);
+      null !== currentFallbackChildFragment ? nextPrimaryChildren = createWorkInProgress(currentFallbackChildFragment, nextPrimaryChildren) : (nextPrimaryChildren = createFiberFromFragment(nextPrimaryChildren, showFallback, renderLanes, null), nextPrimaryChildren.flags |= 2);
+      nextPrimaryChildren.return = workInProgress;
+      nextProps.return = workInProgress;
+      nextProps.sibling = nextPrimaryChildren;
+      workInProgress.child = nextProps;
+      nextProps = nextPrimaryChildren;
+      nextPrimaryChildren = workInProgress.child;
+      showFallback = current.child.memoizedState;
+      null === showFallback ? showFallback = mountSuspenseOffscreenState(renderLanes) : (didSuspend = showFallback.cachePool, null !== didSuspend ? (currentFallbackChildFragment = CacheContext._currentValue2, didSuspend = didSuspend.parent !== currentFallbackChildFragment ? {
+        parent: currentFallbackChildFragment,
+        pool: currentFallbackChildFragment
+      } : didSuspend) : didSuspend = getSuspendedCache(), showFallback = {
+        baseLanes: showFallback.baseLanes | renderLanes,
+        cachePool: didSuspend
+      });
+      nextPrimaryChildren.memoizedState = showFallback;
+      nextPrimaryChildren.childLanes = getRemainingWorkInPrimaryTree(current, JSCompiler_temp, renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER;
+      return nextProps;
+    }
+    pushPrimaryTreeSuspenseHandler(workInProgress);
+    JSCompiler_temp = current.child;
+    current = JSCompiler_temp.sibling;
+    JSCompiler_temp = createWorkInProgress(JSCompiler_temp, {
+      mode: "visible",
+      children: nextProps.children
+    });
+    0 === (workInProgress.mode & 1) && (JSCompiler_temp.lanes = renderLanes);
+    JSCompiler_temp.return = workInProgress;
+    JSCompiler_temp.sibling = null;
+    null !== current && (renderLanes = workInProgress.deletions, null === renderLanes ? (workInProgress.deletions = [current], workInProgress.flags |= 16) : renderLanes.push(current));
+    workInProgress.child = JSCompiler_temp;
+    workInProgress.memoizedState = null;
+    return JSCompiler_temp;
+  }
+  function mountSuspensePrimaryChildren(workInProgress, primaryChildren) {
+    primaryChildren = mountWorkInProgressOffscreenFiber({
+      mode: "visible",
+      children: primaryChildren
+    }, workInProgress.mode);
+    primaryChildren.return = workInProgress;
+    return workInProgress.child = primaryChildren;
+  }
+  function mountWorkInProgressOffscreenFiber(offscreenProps, mode) {
+    offscreenProps = createFiberImplClass(22, offscreenProps, null, mode);
+    offscreenProps.lanes = 0;
+    offscreenProps.stateNode = {
+      _visibility: 1,
+      _pendingMarkers: null,
+      _retryCache: null,
+      _transitions: null
+    };
+    return offscreenProps;
+  }
+  function retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes) {
+    reconcileChildFibers(workInProgress, current.child, null, renderLanes);
+    current = mountSuspensePrimaryChildren(workInProgress, workInProgress.pendingProps.children);
+    current.flags |= 2;
+    workInProgress.memoizedState = null;
+    return current;
+  }
+  function scheduleSuspenseWorkOnFiber(fiber, renderLanes, propagationRoot) {
+    fiber.lanes |= renderLanes;
+    var alternate = fiber.alternate;
+    null !== alternate && (alternate.lanes |= renderLanes);
+    scheduleContextWorkOnParentPath(fiber.return, renderLanes, propagationRoot);
+  }
+  function initSuspenseListRenderState(workInProgress, isBackwards, tail, lastContentRow, tailMode) {
+    var renderState = workInProgress.memoizedState;
+    null === renderState ? workInProgress.memoizedState = {
+      isBackwards: isBackwards,
+      rendering: null,
+      renderingStartTime: 0,
+      last: lastContentRow,
+      tail: tail,
+      tailMode: tailMode
+    } : (renderState.isBackwards = isBackwards, renderState.rendering = null, renderState.renderingStartTime = 0, renderState.last = lastContentRow, renderState.tail = tail, renderState.tailMode = tailMode);
+  }
+  function updateSuspenseListComponent(current, workInProgress, renderLanes) {
+    var nextProps = workInProgress.pendingProps,
+      revealOrder = nextProps.revealOrder,
+      tailMode = nextProps.tail;
+    reconcileChildren(current, workInProgress, nextProps.children, renderLanes);
+    nextProps = suspenseStackCursor.current;
+    if (0 !== (nextProps & 2)) nextProps = nextProps & 1 | 2, workInProgress.flags |= 128;else {
+      if (null !== current && 0 !== (current.flags & 128)) a: for (current = workInProgress.child; null !== current;) {
+        if (13 === current.tag) null !== current.memoizedState && scheduleSuspenseWorkOnFiber(current, renderLanes, workInProgress);else if (19 === current.tag) scheduleSuspenseWorkOnFiber(current, renderLanes, workInProgress);else if (null !== current.child) {
+          current.child.return = current;
+          current = current.child;
+          continue;
+        }
+        if (current === workInProgress) break a;
+        for (; null === current.sibling;) {
+          if (null === current.return || current.return === workInProgress) break a;
+          current = current.return;
+        }
+        current.sibling.return = current.return;
+        current = current.sibling;
+      }
+      nextProps &= 1;
+    }
+    push(suspenseStackCursor, nextProps);
+    if (0 === (workInProgress.mode & 1)) workInProgress.memoizedState = null;else switch (revealOrder) {
+      case "forwards":
+        renderLanes = workInProgress.child;
+        for (revealOrder = null; null !== renderLanes;) current = renderLanes.alternate, null !== current && null === findFirstSuspended(current) && (revealOrder = renderLanes), renderLanes = renderLanes.sibling;
+        renderLanes = revealOrder;
+        null === renderLanes ? (revealOrder = workInProgress.child, workInProgress.child = null) : (revealOrder = renderLanes.sibling, renderLanes.sibling = null);
+        initSuspenseListRenderState(workInProgress, !1, revealOrder, renderLanes, tailMode);
+        break;
+      case "backwards":
+        renderLanes = null;
+        revealOrder = workInProgress.child;
+        for (workInProgress.child = null; null !== revealOrder;) {
+          current = revealOrder.alternate;
+          if (null !== current && null === findFirstSuspended(current)) {
+            workInProgress.child = revealOrder;
+            break;
+          }
+          current = revealOrder.sibling;
+          revealOrder.sibling = renderLanes;
+          renderLanes = revealOrder;
+          revealOrder = current;
+        }
+        initSuspenseListRenderState(workInProgress, !0, renderLanes, null, tailMode);
+        break;
+      case "together":
+        initSuspenseListRenderState(workInProgress, !1, null, null, void 0);
+        break;
+      default:
+        workInProgress.memoizedState = null;
+    }
+    return workInProgress.child;
+  }
+  function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
+    0 === (workInProgress.mode & 1) && null !== current && (current.alternate = null, workInProgress.alternate = null, workInProgress.flags |= 2);
+  }
+  function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
+    null !== current && (workInProgress.dependencies = current.dependencies);
+    workInProgressRootSkippedLanes |= workInProgress.lanes;
+    if (0 === (renderLanes & workInProgress.childLanes)) if (null !== current) {
+      if (propagateParentContextChanges(current, workInProgress, renderLanes, !1), 0 === (renderLanes & workInProgress.childLanes)) return null;
+    } else return null;
+    if (null !== current && workInProgress.child !== current.child) throw Error("Resuming work not yet implemented.");
+    if (null !== workInProgress.child) {
+      current = workInProgress.child;
+      renderLanes = createWorkInProgress(current, current.pendingProps);
+      workInProgress.child = renderLanes;
+      for (renderLanes.return = workInProgress; null !== current.sibling;) current = current.sibling, renderLanes = renderLanes.sibling = createWorkInProgress(current, current.pendingProps), renderLanes.return = workInProgress;
+      renderLanes.sibling = null;
+    }
+    return workInProgress.child;
+  }
+  function checkScheduledUpdateOrContext(current, renderLanes) {
+    if (0 !== (current.lanes & renderLanes)) return !0;
+    current = current.dependencies;
+    return null !== current && checkIfContextChanged(current) ? !0 : !1;
+  }
+  function attemptEarlyBailoutIfNoScheduledUpdate(current, workInProgress, renderLanes) {
+    switch (workInProgress.tag) {
+      case 3:
+        pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+        pushProvider(workInProgress, CacheContext, current.memoizedState.cache);
+        break;
+      case 27:
+      case 5:
+        pushHostContext(workInProgress);
+        break;
+      case 4:
+        pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+        break;
+      case 10:
+        pushProvider(workInProgress, workInProgress.type, workInProgress.memoizedProps.value);
+        break;
+      case 13:
+        var state = workInProgress.memoizedState;
+        if (null !== state) {
+          if (null !== state.dehydrated) return pushPrimaryTreeSuspenseHandler(workInProgress), workInProgress.flags |= 128, null;
+          if (0 !== (renderLanes & workInProgress.child.childLanes)) return updateSuspenseComponent(current, workInProgress, renderLanes);
+          pushPrimaryTreeSuspenseHandler(workInProgress);
+          current = bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+          return null !== current ? current.sibling : null;
+        }
+        pushPrimaryTreeSuspenseHandler(workInProgress);
+        break;
+      case 19:
+        var didSuspendBefore = 0 !== (current.flags & 128);
+        state = 0 !== (renderLanes & workInProgress.childLanes);
+        state || (propagateParentContextChanges(current, workInProgress, renderLanes, !1), state = 0 !== (renderLanes & workInProgress.childLanes));
+        if (didSuspendBefore) {
+          if (state) return updateSuspenseListComponent(current, workInProgress, renderLanes);
+          workInProgress.flags |= 128;
+        }
+        didSuspendBefore = workInProgress.memoizedState;
+        null !== didSuspendBefore && (didSuspendBefore.rendering = null, didSuspendBefore.tail = null, didSuspendBefore.lastEffect = null);
+        push(suspenseStackCursor, suspenseStackCursor.current);
+        if (state) break;else return null;
+      case 22:
+      case 23:
+        return workInProgress.lanes = 0, updateOffscreenComponent(current, workInProgress, renderLanes);
+      case 24:
+        pushProvider(workInProgress, CacheContext, current.memoizedState.cache);
+    }
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+  function beginWork(current, workInProgress, renderLanes) {
+    if (null !== current) {
+      if (current.memoizedProps !== workInProgress.pendingProps) didReceiveUpdate = !0;else {
+        if (!checkScheduledUpdateOrContext(current, renderLanes) && 0 === (workInProgress.flags & 128)) return didReceiveUpdate = !1, attemptEarlyBailoutIfNoScheduledUpdate(current, workInProgress, renderLanes);
+        didReceiveUpdate = 0 !== (current.flags & 131072) ? !0 : !1;
+      }
+    } else didReceiveUpdate = !1;
+    workInProgress.lanes = 0;
+    switch (workInProgress.tag) {
+      case 16:
+        var elementType = workInProgress.elementType;
+        a: {
+          resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress);
+          current = workInProgress.pendingProps;
+          var init = elementType._init;
+          elementType = init(elementType._payload);
+          workInProgress.type = elementType;
+          if ("function" === typeof elementType) shouldConstruct(elementType) ? (current = resolveClassComponentProps(elementType, current), workInProgress.tag = 1, workInProgress = updateClassComponent(null, workInProgress, elementType, current, renderLanes)) : (workInProgress.tag = 0, workInProgress = updateFunctionComponent(null, workInProgress, elementType, current, renderLanes));else {
+            if (void 0 !== elementType && null !== elementType) if (init = elementType.$$typeof, init === REACT_FORWARD_REF_TYPE) {
+              workInProgress.tag = 11;
+              workInProgress = updateForwardRef(null, workInProgress, elementType, current, renderLanes);
+              break a;
+            } else if (init === REACT_MEMO_TYPE) {
+              workInProgress.tag = 14;
+              workInProgress = updateMemoComponent(null, workInProgress, elementType, current, renderLanes);
+              break a;
+            }
+            workInProgress = getComponentNameFromType(elementType) || elementType;
+            throw Error("Element type is invalid. Received a promise that resolves to: " + workInProgress + ". Lazy element type must resolve to a class or function.");
+          }
+        }
+        return workInProgress;
+      case 0:
+        return updateFunctionComponent(current, workInProgress, workInProgress.type, workInProgress.pendingProps, renderLanes);
+      case 1:
+        return elementType = workInProgress.type, init = resolveClassComponentProps(elementType, workInProgress.pendingProps), updateClassComponent(current, workInProgress, elementType, init, renderLanes);
+      case 3:
+        pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+        if (null === current) throw Error("Should have a current fiber. This is a bug in React.");
+        var nextProps = workInProgress.pendingProps;
+        init = workInProgress.memoizedState;
+        elementType = init.element;
+        cloneUpdateQueue(current, workInProgress);
+        processUpdateQueue(workInProgress, nextProps, null, renderLanes);
+        nextProps = workInProgress.memoizedState;
+        var nextCache = nextProps.cache;
+        pushProvider(workInProgress, CacheContext, nextCache);
+        nextCache !== init.cache && propagateContextChanges(workInProgress, [CacheContext], renderLanes, !0);
+        suspendIfUpdateReadFromEntangledAsyncAction();
+        init = nextProps.element;
+        init === elementType ? workInProgress = bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) : (reconcileChildren(current, workInProgress, init, renderLanes), workInProgress = workInProgress.child);
+        return workInProgress;
+      case 26:
+      case 27:
+      case 5:
+        return pushHostContext(workInProgress), elementType = workInProgress.pendingProps.children, null !== workInProgress.memoizedState && (init = renderWithHooks(current, workInProgress, TransitionAwareHostComponent, null, null, renderLanes), HostTransitionContext._currentValue2 = init), markRef(current, workInProgress), reconcileChildren(current, workInProgress, elementType, renderLanes), workInProgress.child;
+      case 6:
+        return null;
+      case 13:
+        return updateSuspenseComponent(current, workInProgress, renderLanes);
+      case 4:
+        return pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo), elementType = workInProgress.pendingProps, null === current ? workInProgress.child = reconcileChildFibers(workInProgress, null, elementType, renderLanes) : reconcileChildren(current, workInProgress, elementType, renderLanes), workInProgress.child;
+      case 11:
+        return updateForwardRef(current, workInProgress, workInProgress.type, workInProgress.pendingProps, renderLanes);
+      case 7:
+        return reconcileChildren(current, workInProgress, workInProgress.pendingProps, renderLanes), workInProgress.child;
+      case 8:
+        return reconcileChildren(current, workInProgress, workInProgress.pendingProps.children, renderLanes), workInProgress.child;
+      case 12:
+        return reconcileChildren(current, workInProgress, workInProgress.pendingProps.children, renderLanes), workInProgress.child;
+      case 10:
+        return elementType = workInProgress.pendingProps, pushProvider(workInProgress, workInProgress.type, elementType.value), reconcileChildren(current, workInProgress, elementType.children, renderLanes), workInProgress.child;
+      case 9:
+        return init = workInProgress.type._context, elementType = workInProgress.pendingProps.children, prepareToReadContext(workInProgress), init = readContext(init), elementType = elementType(init), workInProgress.flags |= 1, reconcileChildren(current, workInProgress, elementType, renderLanes), workInProgress.child;
+      case 14:
+        return updateMemoComponent(current, workInProgress, workInProgress.type, workInProgress.pendingProps, renderLanes);
+      case 15:
+        return updateSimpleMemoComponent(current, workInProgress, workInProgress.type, workInProgress.pendingProps, renderLanes);
+      case 17:
+        return elementType = workInProgress.type, init = resolveClassComponentProps(elementType, workInProgress.pendingProps), resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress), workInProgress.tag = 1, prepareToReadContext(workInProgress), constructClassInstance(workInProgress, elementType, init), mountClassInstance(workInProgress, elementType, init, renderLanes), finishClassComponent(null, workInProgress, elementType, !0, !1, renderLanes);
+      case 28:
+        return elementType = workInProgress.type, init = resolveClassComponentProps(elementType, workInProgress.pendingProps), resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress), workInProgress.tag = 0, updateFunctionComponent(null, workInProgress, elementType, init, renderLanes);
+      case 19:
+        return updateSuspenseListComponent(current, workInProgress, renderLanes);
+      case 31:
+        return elementType = workInProgress.pendingProps, renderLanes = workInProgress.mode, elementType = {
+          mode: elementType.mode,
+          children: elementType.children
+        }, null === current ? (renderLanes = mountWorkInProgressOffscreenFiber(elementType, renderLanes), renderLanes.ref = workInProgress.ref, workInProgress.child = renderLanes, renderLanes.return = workInProgress, workInProgress = renderLanes) : (renderLanes = createWorkInProgress(current.child, elementType), renderLanes.ref = workInProgress.ref, workInProgress.child = renderLanes, renderLanes.return = workInProgress, workInProgress = renderLanes), workInProgress;
+      case 22:
+        return updateOffscreenComponent(current, workInProgress, renderLanes);
+      case 24:
+        return prepareToReadContext(workInProgress), elementType = readContext(CacheContext), null === current ? (init = peekCacheFromPool(), null === init && (init = workInProgressRoot, nextProps = createCache(), init.pooledCache = nextProps, nextProps.refCount++, null !== nextProps && (init.pooledCacheLanes |= renderLanes), init = nextProps), workInProgress.memoizedState = {
+          parent: elementType,
+          cache: init
+        }, initializeUpdateQueue(workInProgress), pushProvider(workInProgress, CacheContext, init)) : (0 !== (current.lanes & renderLanes) && (cloneUpdateQueue(current, workInProgress), processUpdateQueue(workInProgress, null, null, renderLanes), suspendIfUpdateReadFromEntangledAsyncAction()), init = current.memoizedState, nextProps = workInProgress.memoizedState, init.parent !== elementType ? (init = {
+          parent: elementType,
+          cache: elementType
+        }, workInProgress.memoizedState = init, 0 === workInProgress.lanes && (workInProgress.memoizedState = workInProgress.updateQueue.baseState = init), pushProvider(workInProgress, CacheContext, elementType)) : (elementType = nextProps.cache, pushProvider(workInProgress, CacheContext, elementType), elementType !== init.cache && propagateContextChanges(workInProgress, [CacheContext], renderLanes, !0))), reconcileChildren(current, workInProgress, workInProgress.pendingProps.children, renderLanes), workInProgress.child;
+      case 29:
+        throw workInProgress.pendingProps;
+    }
+    throw Error("Unknown unit of work tag (" + workInProgress.tag + "). This error is likely caused by a bug in React. Please file an issue.");
+  }
+  function doesRequireClone(current, completedWork) {
+    if (null !== current && current.child === completedWork.child) return !1;
+    if (0 !== (completedWork.flags & 16)) return !0;
+    for (current = completedWork.child; null !== current;) {
+      if (0 !== (current.flags & 13878) || 0 !== (current.subtreeFlags & 13878)) return !0;
+      current = current.sibling;
+    }
+    return !1;
+  }
+  function appendAllChildren(parent, workInProgress, needsVisibilityToggle, isHidden) {
+    for (var node = workInProgress.child; null !== node;) {
+      if (5 === node.tag) {
+        var instance = node.stateNode;
+        needsVisibilityToggle && isHidden && (instance = cloneHiddenInstance(instance));
+        appendChildNode(parent.node, instance.node);
+      } else if (6 === node.tag) {
+        instance = node.stateNode;
+        if (needsVisibilityToggle && isHidden) throw Error("Not yet implemented.");
+        appendChildNode(parent.node, instance.node);
+      } else if (4 !== node.tag) if (22 === node.tag && null !== node.memoizedState) instance = node.child, null !== instance && (instance.return = node), appendAllChildren(parent, node, !0, !0);else if (null !== node.child) {
+        node.child.return = node;
+        node = node.child;
+        continue;
+      }
+      if (node === workInProgress) break;
+      for (; null === node.sibling;) {
+        if (null === node.return || node.return === workInProgress) return;
+        node = node.return;
+      }
+      node.sibling.return = node.return;
+      node = node.sibling;
+    }
+  }
+  function appendAllChildrenToContainer(containerChildSet, workInProgress, needsVisibilityToggle, isHidden) {
+    for (var hasOffscreenComponentChild = !1, node = workInProgress.child; null !== node;) {
+      if (5 === node.tag) {
+        var instance = node.stateNode;
+        needsVisibilityToggle && isHidden && (instance = cloneHiddenInstance(instance));
+        appendChildNodeToSet(containerChildSet, instance.node);
+      } else if (6 === node.tag) {
+        instance = node.stateNode;
+        if (needsVisibilityToggle && isHidden) throw Error("Not yet implemented.");
+        appendChildNodeToSet(containerChildSet, instance.node);
+      } else if (4 !== node.tag) if (22 === node.tag && null !== node.memoizedState) hasOffscreenComponentChild = node.child, null !== hasOffscreenComponentChild && (hasOffscreenComponentChild.return = node), appendAllChildrenToContainer(containerChildSet, node, !0, !0), hasOffscreenComponentChild = !0;else if (null !== node.child) {
+        node.child.return = node;
+        node = node.child;
+        continue;
+      }
+      if (node === workInProgress) break;
+      for (; null === node.sibling;) {
+        if (null === node.return || node.return === workInProgress) return hasOffscreenComponentChild;
+        node = node.return;
+      }
+      node.sibling.return = node.return;
+      node = node.sibling;
+    }
+    return hasOffscreenComponentChild;
+  }
+  function updateHostContainer(current, workInProgress) {
+    if (doesRequireClone(current, workInProgress)) {
+      current = workInProgress.stateNode;
+      var container = current.containerInfo,
+        newChildSet = createChildNodeSet();
+      appendAllChildrenToContainer(newChildSet, workInProgress, !1, !1);
+      current.pendingChildren = newChildSet;
+      workInProgress.flags |= 4;
+      completeRoot(container.containerTag, newChildSet);
+    }
+  }
+  function scheduleRetryEffect(workInProgress, retryQueue) {
+    null !== retryQueue && (workInProgress.flags |= 4);
+    workInProgress.flags & 16384 && (retryQueue = 22 !== workInProgress.tag ? claimNextRetryLane() : 536870912, workInProgress.lanes |= retryQueue, workInProgressSuspendedRetryLanes |= retryQueue);
+  }
+  function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
+    switch (renderState.tailMode) {
+      case "hidden":
+        hasRenderedATailFallback = renderState.tail;
+        for (var lastTailNode = null; null !== hasRenderedATailFallback;) null !== hasRenderedATailFallback.alternate && (lastTailNode = hasRenderedATailFallback), hasRenderedATailFallback = hasRenderedATailFallback.sibling;
+        null === lastTailNode ? renderState.tail = null : lastTailNode.sibling = null;
+        break;
+      case "collapsed":
+        lastTailNode = renderState.tail;
+        for (var lastTailNode$94 = null; null !== lastTailNode;) null !== lastTailNode.alternate && (lastTailNode$94 = lastTailNode), lastTailNode = lastTailNode.sibling;
+        null === lastTailNode$94 ? hasRenderedATailFallback || null === renderState.tail ? renderState.tail = null : renderState.tail.sibling = null : lastTailNode$94.sibling = null;
+    }
+  }
+  function bubbleProperties(completedWork) {
+    var didBailout = null !== completedWork.alternate && completedWork.alternate.child === completedWork.child,
+      newChildLanes = 0,
+      subtreeFlags = 0;
+    if (didBailout) for (var child$95 = completedWork.child; null !== child$95;) newChildLanes |= child$95.lanes | child$95.childLanes, subtreeFlags |= child$95.subtreeFlags & 65011712, subtreeFlags |= child$95.flags & 65011712, child$95.return = completedWork, child$95 = child$95.sibling;else for (child$95 = completedWork.child; null !== child$95;) newChildLanes |= child$95.lanes | child$95.childLanes, subtreeFlags |= child$95.subtreeFlags, subtreeFlags |= child$95.flags, child$95.return = completedWork, child$95 = child$95.sibling;
+    completedWork.subtreeFlags |= subtreeFlags;
+    completedWork.childLanes = newChildLanes;
+    return didBailout;
+  }
+  function completeWork(current, workInProgress, renderLanes) {
+    var newProps = workInProgress.pendingProps;
+    switch (workInProgress.tag) {
+      case 28:
+      case 31:
+      case 16:
+      case 15:
+      case 0:
+      case 11:
+      case 7:
+      case 8:
+      case 12:
+      case 9:
+      case 14:
+        return bubbleProperties(workInProgress), null;
+      case 1:
+        return bubbleProperties(workInProgress), null;
+      case 3:
+        return renderLanes = workInProgress.stateNode, newProps = null, null !== current && (newProps = current.memoizedState.cache), workInProgress.memoizedState.cache !== newProps && (workInProgress.flags |= 2048), popProvider(CacheContext), popHostContainer(), renderLanes.pendingContext && (renderLanes.context = renderLanes.pendingContext, renderLanes.pendingContext = null), null !== current && null !== current.child || null === current || current.memoizedState.isDehydrated && 0 === (workInProgress.flags & 256) || (workInProgress.flags |= 1024, upgradeHydrationErrorsToRecoverable()), updateHostContainer(current, workInProgress), bubbleProperties(workInProgress), null;
+      case 26:
+      case 27:
+      case 5:
+        popHostContext(workInProgress);
+        var type = workInProgress.type;
+        if (null !== current && null != workInProgress.stateNode) {
+          if (renderLanes = current.stateNode, type = current.memoizedProps, (current = doesRequireClone(current, workInProgress)) || type !== newProps) {
+            b: {
+              type = diffProperties(null, type, newProps, renderLanes.canonical.viewConfig.validAttributes);
+              renderLanes.canonical.currentProps = newProps;
+              newProps = renderLanes.node;
+              if (current) newProps = null !== type ? cloneNodeWithNewChildrenAndProps(newProps, type) : cloneNodeWithNewChildren(newProps);else if (null !== type) newProps = cloneNodeWithNewProps(newProps, type);else {
+                newProps = renderLanes;
+                break b;
+              }
+              newProps = {
+                node: newProps,
+                canonical: renderLanes.canonical
+              };
+            }
+            newProps === renderLanes ? workInProgress.stateNode = renderLanes : (workInProgress.stateNode = newProps, current ? appendAllChildren(newProps, workInProgress, !1, !1) : workInProgress.flags |= 4);
+          } else workInProgress.stateNode = renderLanes;
+        } else {
+          if (!newProps) {
+            if (null === workInProgress.stateNode) throw Error("We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue.");
+            bubbleProperties(workInProgress);
+            return null;
+          }
+          renderLanes = rootInstanceStackCursor.current;
+          current = nextReactTag;
+          nextReactTag += 2;
+          type = getViewConfigForType(type);
+          var updatePayload = fastAddProperties(null, newProps, type.validAttributes);
+          updatePayload = createNode(current, type.uiViewClassName, renderLanes.containerTag, updatePayload, workInProgress);
+          renderLanes = _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").createPublicInstance(current, type, workInProgress, renderLanes.publicInstance);
+          current = {
+            node: updatePayload,
+            canonical: {
+              nativeTag: current,
+              viewConfig: type,
+              currentProps: newProps,
+              internalInstanceHandle: workInProgress,
+              publicInstance: renderLanes
+            }
+          };
+          appendAllChildren(current, workInProgress, !1, !1);
+          workInProgress.stateNode = current;
+        }
+        bubbleProperties(workInProgress);
+        workInProgress.flags &= -16777217;
+        return null;
+      case 6:
+        if (current && null != workInProgress.stateNode) current.memoizedProps !== newProps ? (workInProgress.stateNode = createTextInstance(newProps, rootInstanceStackCursor.current, contextStackCursor.current, workInProgress), workInProgress.flags |= 4) : workInProgress.stateNode = current.stateNode;else {
+          if ("string" !== typeof newProps && null === workInProgress.stateNode) throw Error("We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue.");
+          workInProgress.stateNode = createTextInstance(newProps, rootInstanceStackCursor.current, contextStackCursor.current, workInProgress);
+        }
+        bubbleProperties(workInProgress);
+        return null;
+      case 13:
+        newProps = workInProgress.memoizedState;
+        if (null === current || null !== current.memoizedState && null !== current.memoizedState.dehydrated) {
+          if (null !== newProps && null !== newProps.dehydrated) {
+            if (null === current) {
+              throw Error("A dehydrated suspense component was completed without a hydrated node. This is probably a bug in React.");
+              throw Error("Expected prepareToHydrateHostSuspenseInstance() to never be called. This error is likely caused by a bug in React. Please file an issue.");
+            }
+            0 === (workInProgress.flags & 128) && (workInProgress.memoizedState = null);
+            workInProgress.flags |= 4;
+            bubbleProperties(workInProgress);
+            type = !1;
+          } else type = upgradeHydrationErrorsToRecoverable(), null !== current && null !== current.memoizedState && (current.memoizedState.hydrationErrors = type), type = !0;
+          if (!type) {
+            if (workInProgress.flags & 256) return popSuspenseHandler(workInProgress), workInProgress;
+            popSuspenseHandler(workInProgress);
+            return null;
+          }
+        }
+        popSuspenseHandler(workInProgress);
+        if (0 !== (workInProgress.flags & 128)) return workInProgress.lanes = renderLanes, workInProgress;
+        renderLanes = null !== newProps;
+        current = null !== current && null !== current.memoizedState;
+        renderLanes && (newProps = workInProgress.child, type = null, null !== newProps.alternate && null !== newProps.alternate.memoizedState && null !== newProps.alternate.memoizedState.cachePool && (type = newProps.alternate.memoizedState.cachePool.pool), updatePayload = null, null !== newProps.memoizedState && null !== newProps.memoizedState.cachePool && (updatePayload = newProps.memoizedState.cachePool.pool), updatePayload !== type && (newProps.flags |= 2048));
+        renderLanes !== current && renderLanes && (workInProgress.child.flags |= 8192);
+        scheduleRetryEffect(workInProgress, workInProgress.updateQueue);
+        bubbleProperties(workInProgress);
+        return null;
+      case 4:
+        return popHostContainer(), updateHostContainer(current, workInProgress), bubbleProperties(workInProgress), null;
+      case 10:
+        return popProvider(workInProgress.type), bubbleProperties(workInProgress), null;
+      case 17:
+        return bubbleProperties(workInProgress), null;
+      case 19:
+        pop(suspenseStackCursor);
+        type = workInProgress.memoizedState;
+        if (null === type) return bubbleProperties(workInProgress), null;
+        newProps = 0 !== (workInProgress.flags & 128);
+        updatePayload = type.rendering;
+        if (null === updatePayload) {
+          if (newProps) cutOffTailIfNeeded(type, !1);else {
+            if (0 !== workInProgressRootExitStatus || null !== current && 0 !== (current.flags & 128)) for (current = workInProgress.child; null !== current;) {
+              updatePayload = findFirstSuspended(current);
+              if (null !== updatePayload) {
+                workInProgress.flags |= 128;
+                cutOffTailIfNeeded(type, !1);
+                current = updatePayload.updateQueue;
+                workInProgress.updateQueue = current;
+                scheduleRetryEffect(workInProgress, current);
+                workInProgress.subtreeFlags = 0;
+                current = renderLanes;
+                for (renderLanes = workInProgress.child; null !== renderLanes;) resetWorkInProgress(renderLanes, current), renderLanes = renderLanes.sibling;
+                push(suspenseStackCursor, suspenseStackCursor.current & 1 | 2);
+                return workInProgress.child;
+              }
+              current = current.sibling;
+            }
+            null !== type.tail && _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_now() > workInProgressRootRenderTargetTime && (workInProgress.flags |= 128, newProps = !0, cutOffTailIfNeeded(type, !1), workInProgress.lanes = 4194304);
+          }
+        } else {
+          if (!newProps) if (current = findFirstSuspended(updatePayload), null !== current) {
+            if (workInProgress.flags |= 128, newProps = !0, current = current.updateQueue, workInProgress.updateQueue = current, scheduleRetryEffect(workInProgress, current), cutOffTailIfNeeded(type, !0), null === type.tail && "hidden" === type.tailMode && !updatePayload.alternate) return bubbleProperties(workInProgress), null;
+          } else 2 * _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_now() - type.renderingStartTime > workInProgressRootRenderTargetTime && 536870912 !== renderLanes && (workInProgress.flags |= 128, newProps = !0, cutOffTailIfNeeded(type, !1), workInProgress.lanes = 4194304);
+          type.isBackwards ? (updatePayload.sibling = workInProgress.child, workInProgress.child = updatePayload) : (current = type.last, null !== current ? current.sibling = updatePayload : workInProgress.child = updatePayload, type.last = updatePayload);
+        }
+        if (null !== type.tail) return workInProgress = type.tail, type.rendering = workInProgress, type.tail = workInProgress.sibling, type.renderingStartTime = _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_now(), workInProgress.sibling = null, current = suspenseStackCursor.current, push(suspenseStackCursor, newProps ? current & 1 | 2 : current & 1), workInProgress;
+        bubbleProperties(workInProgress);
+        return null;
+      case 22:
+      case 23:
+        return popSuspenseHandler(workInProgress), popHiddenContext(), newProps = null !== workInProgress.memoizedState, null !== current ? null !== current.memoizedState !== newProps && (workInProgress.flags |= 8192) : newProps && (workInProgress.flags |= 8192), newProps && 0 !== (workInProgress.mode & 1) ? 0 !== (renderLanes & 536870912) && 0 === (workInProgress.flags & 128) && (bubbleProperties(workInProgress), workInProgress.subtreeFlags & 6 && (workInProgress.flags |= 8192)) : bubbleProperties(workInProgress), renderLanes = workInProgress.updateQueue, null !== renderLanes && scheduleRetryEffect(workInProgress, renderLanes.retryQueue), renderLanes = null, null !== current && null !== current.memoizedState && null !== current.memoizedState.cachePool && (renderLanes = current.memoizedState.cachePool.pool), newProps = null, null !== workInProgress.memoizedState && null !== workInProgress.memoizedState.cachePool && (newProps = workInProgress.memoizedState.cachePool.pool), newProps !== renderLanes && (workInProgress.flags |= 2048), null !== current && pop(resumedCache), null;
+      case 24:
+        return renderLanes = null, null !== current && (renderLanes = current.memoizedState.cache), workInProgress.memoizedState.cache !== renderLanes && (workInProgress.flags |= 2048), popProvider(CacheContext), bubbleProperties(workInProgress), null;
+      case 25:
+        return null;
+      case 30:
+        return null;
+      case 29:
+        return null;
+    }
+    throw Error("Unknown unit of work tag (" + workInProgress.tag + "). This error is likely caused by a bug in React. Please file an issue.");
+  }
+  function unwindWork(current, workInProgress) {
+    switch (workInProgress.tag) {
+      case 1:
+        return current = workInProgress.flags, current & 65536 ? (workInProgress.flags = current & -65537 | 128, workInProgress) : null;
+      case 3:
+        return popProvider(CacheContext), popHostContainer(), current = workInProgress.flags, 0 !== (current & 65536) && 0 === (current & 128) ? (workInProgress.flags = current & -65537 | 128, workInProgress) : null;
+      case 26:
+      case 27:
+      case 5:
+        return popHostContext(workInProgress), null;
+      case 13:
+        popSuspenseHandler(workInProgress);
+        current = workInProgress.memoizedState;
+        if (null !== current && null !== current.dehydrated && null === workInProgress.alternate) throw Error("Threw in newly mounted dehydrated component. This is likely a bug in React. Please file an issue.");
+        current = workInProgress.flags;
+        return current & 65536 ? (workInProgress.flags = current & -65537 | 128, workInProgress) : null;
+      case 19:
+        return pop(suspenseStackCursor), null;
+      case 4:
+        return popHostContainer(), null;
+      case 10:
+        return popProvider(workInProgress.type), null;
+      case 22:
+      case 23:
+        return popSuspenseHandler(workInProgress), popHiddenContext(), null !== current && pop(resumedCache), current = workInProgress.flags, current & 65536 ? (workInProgress.flags = current & -65537 | 128, workInProgress) : null;
+      case 24:
+        return popProvider(CacheContext), null;
+      case 25:
+        return null;
+      default:
+        return null;
+    }
+  }
+  function unwindInterruptedWork(current, interruptedWork) {
+    switch (interruptedWork.tag) {
+      case 3:
+        popProvider(CacheContext);
+        popHostContainer();
+        break;
+      case 26:
+      case 27:
+      case 5:
+        popHostContext(interruptedWork);
+        break;
+      case 4:
+        popHostContainer();
+        break;
+      case 13:
+        popSuspenseHandler(interruptedWork);
+        break;
+      case 19:
+        pop(suspenseStackCursor);
+        break;
+      case 10:
+        popProvider(interruptedWork.type);
+        break;
+      case 22:
+      case 23:
+        popSuspenseHandler(interruptedWork);
+        popHiddenContext();
+        null !== current && pop(resumedCache);
+        break;
+      case 24:
+        popProvider(CacheContext);
+    }
+  }
+  function commitHookEffectListMount(flags, finishedWork) {
+    try {
+      var updateQueue = finishedWork.updateQueue,
+        lastEffect = null !== updateQueue ? updateQueue.lastEffect : null;
+      if (null !== lastEffect) {
+        var firstEffect = lastEffect.next;
+        updateQueue = firstEffect;
+        do {
+          if ((updateQueue.tag & flags) === flags) {
+            lastEffect = void 0;
+            var create$117 = updateQueue.create,
+              inst = updateQueue.inst;
+            lastEffect = create$117();
+            inst.destroy = lastEffect;
+          }
+          updateQueue = updateQueue.next;
+        } while (updateQueue !== firstEffect);
+      }
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+  function commitHookEffectListUnmount(flags, finishedWork, nearestMountedAncestor$jscomp$0) {
+    try {
+      var updateQueue = finishedWork.updateQueue,
+        lastEffect = null !== updateQueue ? updateQueue.lastEffect : null;
+      if (null !== lastEffect) {
+        var firstEffect = lastEffect.next;
+        updateQueue = firstEffect;
+        do {
+          if ((updateQueue.tag & flags) === flags) {
+            var inst = updateQueue.inst,
+              destroy = inst.destroy;
+            if (void 0 !== destroy) {
+              inst.destroy = void 0;
+              lastEffect = finishedWork;
+              var nearestMountedAncestor = nearestMountedAncestor$jscomp$0,
+                destroy_ = destroy;
+              try {
+                destroy_();
+              } catch (error) {
+                captureCommitPhaseError(lastEffect, nearestMountedAncestor, error);
+              }
+            }
+          }
+          updateQueue = updateQueue.next;
+        } while (updateQueue !== firstEffect);
+      }
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+  function commitClassCallbacks(finishedWork) {
+    var updateQueue = finishedWork.updateQueue;
+    if (null !== updateQueue) {
+      var instance = finishedWork.stateNode;
+      try {
+        commitCallbacks(updateQueue, instance);
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+    }
+  }
+  function safelyCallComponentWillUnmount(current, nearestMountedAncestor, instance) {
+    instance.props = resolveClassComponentProps(current.type, current.memoizedProps);
+    instance.state = current.memoizedState;
+    try {
+      instance.componentWillUnmount();
+    } catch (error) {
+      captureCommitPhaseError(current, nearestMountedAncestor, error);
+    }
+  }
+  function safelyAttachRef(current, nearestMountedAncestor) {
+    try {
+      var ref = current.ref;
+      if (null !== ref) {
+        switch (current.tag) {
+          case 26:
+          case 27:
+          case 5:
+            var instanceToUse = getPublicInstance(current.stateNode);
+            break;
+          case 30:
+            instanceToUse = current.stateNode;
+            break;
+          default:
+            instanceToUse = current.stateNode;
+        }
+        "function" === typeof ref ? current.refCleanup = ref(instanceToUse) : ref.current = instanceToUse;
+      }
+    } catch (error) {
+      captureCommitPhaseError(current, nearestMountedAncestor, error);
+    }
+  }
+  function safelyDetachRef(current, nearestMountedAncestor) {
+    var ref = current.ref,
+      refCleanup = current.refCleanup;
+    if (null !== ref) if ("function" === typeof refCleanup) try {
+      refCleanup();
+    } catch (error) {
+      captureCommitPhaseError(current, nearestMountedAncestor, error);
+    } finally {
+      current.refCleanup = null, current = current.alternate, null != current && (current.refCleanup = null);
+    } else if ("function" === typeof ref) try {
+      ref(null);
+    } catch (error$119) {
+      captureCommitPhaseError(current, nearestMountedAncestor, error$119);
+    } else ref.current = null;
+  }
+  function commitHostMount(finishedWork) {
+    try {
+      throw Error("The current renderer does not support mutation. This error is likely caused by a bug in React. Please file an issue.");
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+  var offscreenSubtreeIsHidden = !1,
+    offscreenSubtreeWasHidden = !1,
+    PossiblyWeakSet = "function" === typeof WeakSet ? WeakSet : Set,
+    nextEffect = null;
+  function commitBeforeMutationEffects(root, firstChild) {
+    for (nextEffect = firstChild; null !== nextEffect;) if (root = nextEffect, firstChild = root.child, 0 !== (root.subtreeFlags & 1024) && null !== firstChild) firstChild.return = root, nextEffect = firstChild;else for (; null !== nextEffect;) {
+      root = nextEffect;
+      var current = root.alternate;
+      firstChild = root.flags;
+      switch (root.tag) {
+        case 0:
+          break;
+        case 11:
+        case 15:
+          break;
+        case 1:
+          if (0 !== (firstChild & 1024) && null !== current) {
+            firstChild = void 0;
+            var finishedWork = root,
+              prevProps = current.memoizedProps;
+            current = current.memoizedState;
+            var instance = finishedWork.stateNode;
+            try {
+              var resolvedPrevProps = resolveClassComponentProps(finishedWork.type, prevProps, finishedWork.elementType === finishedWork.type);
+              firstChild = instance.getSnapshotBeforeUpdate(resolvedPrevProps, current);
+              instance.__reactInternalSnapshotBeforeUpdate = firstChild;
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+          break;
+        case 3:
+          break;
+        case 5:
+        case 26:
+        case 27:
+        case 6:
+        case 4:
+        case 17:
+          break;
+        default:
+          if (0 !== (firstChild & 1024)) throw Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue.");
+      }
+      firstChild = root.sibling;
+      if (null !== firstChild) {
+        firstChild.return = root.return;
+        nextEffect = firstChild;
+        break;
+      }
+      nextEffect = root.return;
+    }
+  }
+  function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork) {
+    var flags = finishedWork.flags;
+    switch (finishedWork.tag) {
+      case 0:
+      case 11:
+      case 15:
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        flags & 4 && commitHookEffectListMount(5, finishedWork);
+        break;
+      case 1:
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        if (flags & 4) if (finishedRoot = finishedWork.stateNode, null === current) try {
+          finishedRoot.componentDidMount();
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        } else {
+          var prevProps = resolveClassComponentProps(finishedWork.type, current.memoizedProps);
+          current = current.memoizedState;
+          try {
+            finishedRoot.componentDidUpdate(prevProps, current, finishedRoot.__reactInternalSnapshotBeforeUpdate);
+          } catch (error$118) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error$118);
+          }
+        }
+        flags & 64 && commitClassCallbacks(finishedWork);
+        flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      case 3:
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        if (flags & 64 && (finishedRoot = finishedWork.updateQueue, null !== finishedRoot)) {
+          current = null;
+          if (null !== finishedWork.child) switch (finishedWork.child.tag) {
+            case 27:
+            case 5:
+              current = getPublicInstance(finishedWork.child.stateNode);
+              break;
+            case 1:
+              current = finishedWork.child.stateNode;
+          }
+          try {
+            commitCallbacks(finishedRoot, current);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+        break;
+      case 27:
+      case 26:
+      case 5:
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        null === current && flags & 4 && commitHostMount(finishedWork);
+        flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      case 12:
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        break;
+      case 13:
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        flags & 64 && (finishedRoot = finishedWork.memoizedState, null !== finishedRoot && null !== finishedRoot.dehydrated && (retryDehydratedSuspenseBoundary.bind(null, finishedWork), shim$1()));
+        break;
+      case 22:
+        if (0 !== (finishedWork.mode & 1)) {
+          if (flags = null !== finishedWork.memoizedState || offscreenSubtreeIsHidden, !flags) {
+            current = null !== current && null !== current.memoizedState || offscreenSubtreeWasHidden;
+            prevProps = offscreenSubtreeIsHidden;
+            var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+            offscreenSubtreeIsHidden = flags;
+            (offscreenSubtreeWasHidden = current) && !prevOffscreenSubtreeWasHidden ? recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, 0 !== (finishedWork.subtreeFlags & 8772)) : recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+            offscreenSubtreeIsHidden = prevProps;
+            offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+          }
+        } else recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        break;
+      case 30:
+        break;
+      default:
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+    }
+  }
+  function detachFiberAfterEffects(fiber) {
+    var alternate = fiber.alternate;
+    null !== alternate && (fiber.alternate = null, detachFiberAfterEffects(alternate));
+    fiber.child = null;
+    fiber.deletions = null;
+    fiber.sibling = null;
+    fiber.stateNode = null;
+    fiber.return = null;
+    fiber.dependencies = null;
+    fiber.memoizedProps = null;
+    fiber.memoizedState = null;
+    fiber.pendingProps = null;
+    fiber.stateNode = null;
+    fiber.updateQueue = null;
+  }
+  function recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, parent) {
+    for (parent = parent.child; null !== parent;) commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, parent), parent = parent.sibling;
+  }
+  function commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, deletedFiber) {
+    if (injectedHook && "function" === typeof injectedHook.onCommitFiberUnmount) try {
+      injectedHook.onCommitFiberUnmount(rendererID, deletedFiber);
+    } catch (err) {}
+    switch (deletedFiber.tag) {
+      case 26:
+      case 27:
+      case 5:
+        offscreenSubtreeWasHidden || safelyDetachRef(deletedFiber, nearestMountedAncestor);
+      case 6:
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        break;
+      case 18:
+        break;
+      case 4:
+        createChildNodeSet();
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        break;
+      case 0:
+      case 11:
+      case 14:
+      case 15:
+        offscreenSubtreeWasHidden || commitHookEffectListUnmount(2, deletedFiber, nearestMountedAncestor);
+        offscreenSubtreeWasHidden || commitHookEffectListUnmount(4, deletedFiber, nearestMountedAncestor);
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        break;
+      case 1:
+        if (!offscreenSubtreeWasHidden) {
+          safelyDetachRef(deletedFiber, nearestMountedAncestor);
+          var instance = deletedFiber.stateNode;
+          "function" === typeof instance.componentWillUnmount && safelyCallComponentWillUnmount(deletedFiber, nearestMountedAncestor, instance);
+        }
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        break;
+      case 21:
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        break;
+      case 22:
+        deletedFiber.mode & 1 ? (offscreenSubtreeWasHidden = (instance = offscreenSubtreeWasHidden) || null !== deletedFiber.memoizedState, recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber), offscreenSubtreeWasHidden = instance) : recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        break;
+      default:
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+    }
+  }
+  function getRetryCache(finishedWork) {
+    switch (finishedWork.tag) {
+      case 13:
+      case 19:
+        var retryCache = finishedWork.stateNode;
+        null === retryCache && (retryCache = finishedWork.stateNode = new PossiblyWeakSet());
+        return retryCache;
+      case 22:
+        return finishedWork = finishedWork.stateNode, retryCache = finishedWork._retryCache, null === retryCache && (retryCache = finishedWork._retryCache = new PossiblyWeakSet()), retryCache;
+      default:
+        throw Error("Unexpected Suspense handler tag (" + finishedWork.tag + "). This is a bug in React.");
+    }
+  }
+  function attachSuspenseRetryListeners(finishedWork, wakeables) {
+    var retryCache = getRetryCache(finishedWork);
+    wakeables.forEach(function (wakeable) {
+      var retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
+      retryCache.has(wakeable) || (retryCache.add(wakeable), wakeable.then(retry, retry));
+    });
+  }
+  function recursivelyTraverseMutationEffects(root, parentFiber) {
+    var deletions = parentFiber.deletions;
+    if (null !== deletions) for (var i = 0; i < deletions.length; i++) {
+      var childToDelete = deletions[i];
+      commitDeletionEffectsOnFiber(root, parentFiber, childToDelete);
+      var alternate = childToDelete.alternate;
+      null !== alternate && (alternate.return = null);
+      childToDelete.return = null;
+    }
+    if (parentFiber.subtreeFlags & 13878) for (parentFiber = parentFiber.child; null !== parentFiber;) commitMutationEffectsOnFiber(parentFiber, root), parentFiber = parentFiber.sibling;
+  }
+  function commitMutationEffectsOnFiber(finishedWork, root) {
+    var current = finishedWork.alternate,
+      flags = finishedWork.flags;
+    switch (finishedWork.tag) {
+      case 0:
+      case 11:
+      case 14:
+      case 15:
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        flags & 4 && (commitHookEffectListUnmount(3, finishedWork, finishedWork.return), commitHookEffectListMount(3, finishedWork), commitHookEffectListUnmount(5, finishedWork, finishedWork.return));
+        break;
+      case 1:
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        flags & 512 && (offscreenSubtreeWasHidden || null === current || safelyDetachRef(current, current.return));
+        flags & 64 && offscreenSubtreeIsHidden && (finishedWork = finishedWork.updateQueue, null !== finishedWork && (flags = finishedWork.callbacks, null !== flags && (current = finishedWork.shared.hiddenCallbacks, finishedWork.shared.hiddenCallbacks = null === current ? flags : current.concat(flags))));
+        break;
+      case 26:
+      case 27:
+      case 5:
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        flags & 512 && (offscreenSubtreeWasHidden || null === current || safelyDetachRef(current, current.return));
+        break;
+      case 6:
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        break;
+      case 3:
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        break;
+      case 4:
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        break;
+      case 12:
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        break;
+      case 13:
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        finishedWork.child.flags & 8192 && (current = null !== current && null !== current.memoizedState, null === finishedWork.memoizedState || current || (globalMostRecentFallbackTime = _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_now()));
+        flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (finishedWork.updateQueue = null, attachSuspenseRetryListeners(finishedWork, flags)));
+        break;
+      case 22:
+        var isHidden = null !== finishedWork.memoizedState,
+          wasHidden = null !== current && null !== current.memoizedState;
+        if (finishedWork.mode & 1) {
+          var prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden,
+            prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden || isHidden;
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || wasHidden;
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
+        } else recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        flags & 8192 && (root = finishedWork.stateNode, root._visibility = isHidden ? root._visibility & -2 : root._visibility | 1, isHidden && (null === current || wasHidden || offscreenSubtreeIsHidden || offscreenSubtreeWasHidden || 0 !== (finishedWork.mode & 1) && recursivelyTraverseDisappearLayoutEffects(finishedWork)));
+        flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (current = flags.retryQueue, null !== current && (flags.retryQueue = null, attachSuspenseRetryListeners(finishedWork, current))));
+        break;
+      case 19:
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (finishedWork.updateQueue = null, attachSuspenseRetryListeners(finishedWork, flags)));
+        break;
+      case 30:
+        break;
+      case 21:
+        break;
+      default:
+        recursivelyTraverseMutationEffects(root, finishedWork), commitReconciliationEffects(finishedWork);
+    }
+  }
+  function commitReconciliationEffects(finishedWork) {
+    var flags = finishedWork.flags;
+    flags & 2 && (finishedWork.flags &= -3);
+    flags & 4096 && (finishedWork.flags &= -4097);
+  }
+  function recursivelyTraverseLayoutEffects(root, parentFiber) {
+    if (parentFiber.subtreeFlags & 8772) for (parentFiber = parentFiber.child; null !== parentFiber;) commitLayoutEffectOnFiber(root, parentFiber.alternate, parentFiber), parentFiber = parentFiber.sibling;
+  }
+  function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
+    for (parentFiber = parentFiber.child; null !== parentFiber;) {
+      var finishedWork = parentFiber;
+      switch (finishedWork.tag) {
+        case 0:
+        case 11:
+        case 14:
+        case 15:
+          commitHookEffectListUnmount(4, finishedWork, finishedWork.return);
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+          break;
+        case 1:
+          safelyDetachRef(finishedWork, finishedWork.return);
+          var instance = finishedWork.stateNode;
+          "function" === typeof instance.componentWillUnmount && safelyCallComponentWillUnmount(finishedWork, finishedWork.return, instance);
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+          break;
+        case 27:
+        case 26:
+        case 5:
+          safelyDetachRef(finishedWork, finishedWork.return);
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+          break;
+        case 22:
+          null === finishedWork.memoizedState && recursivelyTraverseDisappearLayoutEffects(finishedWork);
+          break;
+        case 30:
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+          break;
+        default:
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+      }
+      parentFiber = parentFiber.sibling;
+    }
+  }
+  function recursivelyTraverseReappearLayoutEffects(finishedRoot$jscomp$0, parentFiber, includeWorkInProgressEffects) {
+    includeWorkInProgressEffects = includeWorkInProgressEffects && 0 !== (parentFiber.subtreeFlags & 8772);
+    for (parentFiber = parentFiber.child; null !== parentFiber;) {
+      var current = parentFiber.alternate,
+        finishedRoot = finishedRoot$jscomp$0,
+        finishedWork = parentFiber,
+        flags = finishedWork.flags;
+      switch (finishedWork.tag) {
+        case 0:
+        case 11:
+        case 15:
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+          commitHookEffectListMount(4, finishedWork);
+          break;
+        case 1:
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+          current = finishedWork;
+          finishedRoot = current.stateNode;
+          if ("function" === typeof finishedRoot.componentDidMount) try {
+            finishedRoot.componentDidMount();
+          } catch (error) {
+            captureCommitPhaseError(current, current.return, error);
+          }
+          current = finishedWork;
+          finishedRoot = current.updateQueue;
+          if (null !== finishedRoot) {
+            var instance = current.stateNode;
+            try {
+              var hiddenCallbacks = finishedRoot.shared.hiddenCallbacks;
+              if (null !== hiddenCallbacks) for (finishedRoot.shared.hiddenCallbacks = null, finishedRoot = 0; finishedRoot < hiddenCallbacks.length; finishedRoot++) callCallback(hiddenCallbacks[finishedRoot], instance);
+            } catch (error) {
+              captureCommitPhaseError(current, current.return, error);
+            }
+          }
+          includeWorkInProgressEffects && flags & 64 && commitClassCallbacks(finishedWork);
+          safelyAttachRef(finishedWork, finishedWork.return);
+          break;
+        case 27:
+        case 26:
+        case 5:
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+          includeWorkInProgressEffects && null === current && flags & 4 && commitHostMount(finishedWork);
+          safelyAttachRef(finishedWork, finishedWork.return);
+          break;
+        case 12:
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+          break;
+        case 13:
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+          break;
+        case 22:
+          null === finishedWork.memoizedState && recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+          safelyAttachRef(finishedWork, finishedWork.return);
+          break;
+        case 30:
+          break;
+        default:
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+      }
+      parentFiber = parentFiber.sibling;
+    }
+  }
+  function commitOffscreenPassiveMountEffects(current, finishedWork) {
+    var previousCache = null;
+    null !== current && null !== current.memoizedState && null !== current.memoizedState.cachePool && (previousCache = current.memoizedState.cachePool.pool);
+    current = null;
+    null !== finishedWork.memoizedState && null !== finishedWork.memoizedState.cachePool && (current = finishedWork.memoizedState.cachePool.pool);
+    current !== previousCache && (null != current && current.refCount++, null != previousCache && releaseCache(previousCache));
+  }
+  function commitCachePassiveMountEffect(current, finishedWork) {
+    current = null;
+    null !== finishedWork.alternate && (current = finishedWork.alternate.memoizedState.cache);
+    finishedWork = finishedWork.memoizedState.cache;
+    finishedWork !== current && (finishedWork.refCount++, null != current && releaseCache(current));
+  }
+  function recursivelyTraversePassiveMountEffects(root, parentFiber, committedLanes, committedTransitions) {
+    if (parentFiber.subtreeFlags & 10256) for (parentFiber = parentFiber.child; null !== parentFiber;) commitPassiveMountOnFiber(root, parentFiber, committedLanes, committedTransitions), parentFiber = parentFiber.sibling;
+  }
+  function commitPassiveMountOnFiber(finishedRoot, finishedWork, committedLanes, committedTransitions) {
+    var flags = finishedWork.flags;
+    switch (finishedWork.tag) {
+      case 0:
+      case 11:
+      case 15:
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+        flags & 2048 && commitHookEffectListMount(9, finishedWork);
+        break;
+      case 1:
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+        break;
+      case 3:
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+        flags & 2048 && (finishedRoot = null, null !== finishedWork.alternate && (finishedRoot = finishedWork.alternate.memoizedState.cache), finishedWork = finishedWork.memoizedState.cache, finishedWork !== finishedRoot && (finishedWork.refCount++, null != finishedRoot && releaseCache(finishedRoot)));
+        break;
+      case 12:
+        if (flags & 2048) {
+          recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+          finishedRoot = finishedWork.stateNode;
+          try {
+            var _finishedWork$memoize2 = finishedWork.memoizedProps,
+              id = _finishedWork$memoize2.id,
+              onPostCommit = _finishedWork$memoize2.onPostCommit;
+            "function" === typeof onPostCommit && onPostCommit(id, null === finishedWork.alternate ? "mount" : "update", finishedRoot.passiveEffectDuration, -0);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        } else recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+        break;
+      case 13:
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+        break;
+      case 23:
+        break;
+      case 22:
+        _finishedWork$memoize2 = finishedWork.stateNode;
+        id = finishedWork.alternate;
+        null !== finishedWork.memoizedState ? _finishedWork$memoize2._visibility & 2 ? recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions) : finishedWork.mode & 1 ? recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork) : (_finishedWork$memoize2._visibility |= 2, recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions)) : _finishedWork$memoize2._visibility & 2 ? recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions) : (_finishedWork$memoize2._visibility |= 2, recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, 0 !== (finishedWork.subtreeFlags & 10256)));
+        flags & 2048 && commitOffscreenPassiveMountEffects(id, finishedWork);
+        break;
+      case 24:
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+        flags & 2048 && commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
+        break;
+      default:
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+    }
+  }
+  function recursivelyTraverseReconnectPassiveEffects(finishedRoot$jscomp$0, parentFiber, committedLanes$jscomp$0, committedTransitions$jscomp$0, includeWorkInProgressEffects) {
+    includeWorkInProgressEffects = includeWorkInProgressEffects && 0 !== (parentFiber.subtreeFlags & 10256);
+    for (parentFiber = parentFiber.child; null !== parentFiber;) {
+      var finishedRoot = finishedRoot$jscomp$0,
+        finishedWork = parentFiber,
+        committedLanes = committedLanes$jscomp$0,
+        committedTransitions = committedTransitions$jscomp$0,
+        flags = finishedWork.flags;
+      switch (finishedWork.tag) {
+        case 0:
+        case 11:
+        case 15:
+          recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+          commitHookEffectListMount(8, finishedWork);
+          break;
+        case 23:
+          break;
+        case 22:
+          var instance = finishedWork.stateNode;
+          null !== finishedWork.memoizedState ? instance._visibility & 2 ? recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects) : finishedWork.mode & 1 ? recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork) : (instance._visibility |= 2, recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects)) : (instance._visibility |= 2, recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects));
+          includeWorkInProgressEffects && flags & 2048 && commitOffscreenPassiveMountEffects(finishedWork.alternate, finishedWork);
+          break;
+        case 24:
+          recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+          includeWorkInProgressEffects && flags & 2048 && commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
+          break;
+        default:
+          recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+      }
+      parentFiber = parentFiber.sibling;
+    }
+  }
+  function recursivelyTraverseAtomicPassiveEffects(finishedRoot$jscomp$0, parentFiber) {
+    if (parentFiber.subtreeFlags & 10256) for (parentFiber = parentFiber.child; null !== parentFiber;) {
+      var finishedRoot = finishedRoot$jscomp$0,
+        finishedWork = parentFiber,
+        flags = finishedWork.flags;
+      switch (finishedWork.tag) {
+        case 22:
+          recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+          flags & 2048 && commitOffscreenPassiveMountEffects(finishedWork.alternate, finishedWork);
+          break;
+        case 24:
+          recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+          flags & 2048 && commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
+          break;
+        default:
+          recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+      }
+      parentFiber = parentFiber.sibling;
+    }
+  }
+  var suspenseyCommitFlag = 8192;
+  function recursivelyAccumulateSuspenseyCommit(parentFiber) {
+    if (parentFiber.subtreeFlags & suspenseyCommitFlag) for (parentFiber = parentFiber.child; null !== parentFiber;) accumulateSuspenseyCommitOnFiber(parentFiber), parentFiber = parentFiber.sibling;
+  }
+  function accumulateSuspenseyCommitOnFiber(fiber) {
+    switch (fiber.tag) {
+      case 26:
+        recursivelyAccumulateSuspenseyCommit(fiber);
+        fiber.flags & suspenseyCommitFlag && null !== fiber.memoizedState && shim();
+        break;
+      case 5:
+        recursivelyAccumulateSuspenseyCommit(fiber);
+        break;
+      case 3:
+      case 4:
+        recursivelyAccumulateSuspenseyCommit(fiber);
+        break;
+      case 22:
+        if (null === fiber.memoizedState) {
+          var current = fiber.alternate;
+          null !== current && null !== current.memoizedState ? (current = suspenseyCommitFlag, suspenseyCommitFlag = 16777216, recursivelyAccumulateSuspenseyCommit(fiber), suspenseyCommitFlag = current) : recursivelyAccumulateSuspenseyCommit(fiber);
+        }
+        break;
+      default:
+        recursivelyAccumulateSuspenseyCommit(fiber);
+    }
+  }
+  function detachAlternateSiblings(parentFiber) {
+    var previousFiber = parentFiber.alternate;
+    if (null !== previousFiber && (parentFiber = previousFiber.child, null !== parentFiber)) {
+      previousFiber.child = null;
+      do previousFiber = parentFiber.sibling, parentFiber.sibling = null, parentFiber = previousFiber; while (null !== parentFiber);
+    }
+  }
+  function recursivelyTraversePassiveUnmountEffects(parentFiber) {
+    var deletions = parentFiber.deletions;
+    if (0 !== (parentFiber.flags & 16)) {
+      if (null !== deletions) for (var i = 0; i < deletions.length; i++) {
+        var childToDelete = deletions[i];
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(childToDelete, parentFiber);
+      }
+      detachAlternateSiblings(parentFiber);
+    }
+    if (parentFiber.subtreeFlags & 10256) for (parentFiber = parentFiber.child; null !== parentFiber;) commitPassiveUnmountOnFiber(parentFiber), parentFiber = parentFiber.sibling;
+  }
+  function commitPassiveUnmountOnFiber(finishedWork) {
+    switch (finishedWork.tag) {
+      case 0:
+      case 11:
+      case 15:
+        recursivelyTraversePassiveUnmountEffects(finishedWork);
+        finishedWork.flags & 2048 && commitHookEffectListUnmount(9, finishedWork, finishedWork.return);
+        break;
+      case 3:
+        recursivelyTraversePassiveUnmountEffects(finishedWork);
+        break;
+      case 12:
+        recursivelyTraversePassiveUnmountEffects(finishedWork);
+        break;
+      case 22:
+        var instance = finishedWork.stateNode;
+        null !== finishedWork.memoizedState && instance._visibility & 2 && (null === finishedWork.return || 13 !== finishedWork.return.tag) ? (instance._visibility &= -3, recursivelyTraverseDisconnectPassiveEffects(finishedWork)) : recursivelyTraversePassiveUnmountEffects(finishedWork);
+        break;
+      default:
+        recursivelyTraversePassiveUnmountEffects(finishedWork);
+    }
+  }
+  function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
+    var deletions = parentFiber.deletions;
+    if (0 !== (parentFiber.flags & 16)) {
+      if (null !== deletions) for (var i = 0; i < deletions.length; i++) {
+        var childToDelete = deletions[i];
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(childToDelete, parentFiber);
+      }
+      detachAlternateSiblings(parentFiber);
+    }
+    for (parentFiber = parentFiber.child; null !== parentFiber;) {
+      deletions = parentFiber;
+      switch (deletions.tag) {
+        case 0:
+        case 11:
+        case 15:
+          commitHookEffectListUnmount(8, deletions, deletions.return);
+          recursivelyTraverseDisconnectPassiveEffects(deletions);
+          break;
+        case 22:
+          i = deletions.stateNode;
+          i._visibility & 2 && (i._visibility &= -3, recursivelyTraverseDisconnectPassiveEffects(deletions));
+          break;
+        default:
+          recursivelyTraverseDisconnectPassiveEffects(deletions);
+      }
+      parentFiber = parentFiber.sibling;
+    }
+  }
+  function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(deletedSubtreeRoot, nearestMountedAncestor) {
+    for (; null !== nextEffect;) {
+      var fiber = nextEffect;
+      switch (fiber.tag) {
+        case 0:
+        case 11:
+        case 15:
+          commitHookEffectListUnmount(8, fiber, nearestMountedAncestor);
+          break;
+        case 23:
+        case 22:
+          if (null !== fiber.memoizedState && null !== fiber.memoizedState.cachePool) {
+            var cache = fiber.memoizedState.cachePool.pool;
+            null != cache && cache.refCount++;
+          }
+          break;
+        case 24:
+          releaseCache(fiber.memoizedState.cache);
+      }
+      cache = fiber.child;
+      if (null !== cache) cache.return = fiber, nextEffect = cache;else a: for (fiber = deletedSubtreeRoot; null !== nextEffect;) {
+        cache = nextEffect;
+        var sibling = cache.sibling,
+          returnFiber = cache.return;
+        detachFiberAfterEffects(cache);
+        if (cache === fiber) {
+          nextEffect = null;
+          break a;
+        }
+        if (null !== sibling) {
+          sibling.return = returnFiber;
+          nextEffect = sibling;
+          break a;
+        }
+        nextEffect = returnFiber;
+      }
+    }
+  }
+  var DefaultAsyncDispatcher = {
+      getCacheForType: function getCacheForType(resourceType) {
+        var cache = readContext(CacheContext),
+          cacheForType = cache.data.get(resourceType);
+        void 0 === cacheForType && (cacheForType = resourceType(), cache.data.set(resourceType, cacheForType));
+        return cacheForType;
+      }
+    },
+    PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map,
+    executionContext = 0,
+    workInProgressRoot = null,
+    workInProgress = null,
+    workInProgressRootRenderLanes = 0,
+    workInProgressSuspendedReason = 0,
+    workInProgressThrownValue = null,
+    workInProgressRootDidSkipSuspendedSiblings = !1,
+    workInProgressRootIsPrerendering = !1,
+    workInProgressRootDidAttachPingListener = !1,
+    entangledRenderLanes = 0,
+    workInProgressRootExitStatus = 0,
+    workInProgressRootSkippedLanes = 0,
+    workInProgressRootInterleavedUpdatedLanes = 0,
+    workInProgressRootPingedLanes = 0,
+    workInProgressDeferredLane = 0,
+    workInProgressSuspendedRetryLanes = 0,
+    workInProgressRootConcurrentErrors = null,
+    workInProgressRootRecoverableErrors = null,
+    workInProgressRootDidIncludeRecursiveRenderUpdate = !1,
+    globalMostRecentFallbackTime = 0,
+    workInProgressRootRenderTargetTime = Infinity,
+    workInProgressTransitions = null,
+    legacyErrorBoundariesThatAlreadyFailed = null,
+    pendingEffectsStatus = 0,
+    pendingEffectsRoot = null,
+    pendingFinishedWork = null,
+    pendingEffectsLanes = 0,
+    pendingEffectsRemainingLanes = 0,
+    pendingPassiveTransitions = null,
+    pendingRecoverableErrors = null,
+    nestedUpdateCount = 0,
+    rootWithNestedUpdates = null;
+  function requestUpdateLane(fiber) {
+    return 0 === (fiber.mode & 1) ? 2 : 0 !== (executionContext & 2) && 0 !== workInProgressRootRenderLanes ? workInProgressRootRenderLanes & -workInProgressRootRenderLanes : null !== ReactSharedInternals.T ? (fiber = currentEntangledLane, 0 !== fiber ? fiber : requestTransitionLane()) : resolveUpdatePriority();
+  }
+  function requestDeferredLane() {
+    0 === workInProgressDeferredLane && (workInProgressDeferredLane = 0 !== (workInProgressRootRenderLanes & 536870912) ? 536870912 : claimNextTransitionLane());
+    var suspenseHandler = suspenseHandlerStackCursor.current;
+    null !== suspenseHandler && (suspenseHandler.flags |= 32);
+    return workInProgressDeferredLane;
+  }
+  function scheduleUpdateOnFiber(root, fiber, lane) {
+    if (root === workInProgressRoot && (2 === workInProgressSuspendedReason || 9 === workInProgressSuspendedReason) || null !== root.cancelPendingCommit) prepareFreshStack(root, 0), markRootSuspended(root, workInProgressRootRenderLanes, workInProgressDeferredLane, !1);
+    markRootUpdated$1(root, lane);
+    if (0 === (executionContext & 2) || root !== workInProgressRoot) root === workInProgressRoot && (0 === (executionContext & 2) && (workInProgressRootInterleavedUpdatedLanes |= lane), 4 === workInProgressRootExitStatus && markRootSuspended(root, workInProgressRootRenderLanes, workInProgressDeferredLane, !1)), ensureRootIsScheduled(root), 2 === lane && 0 === executionContext && 0 === (fiber.mode & 1) && (workInProgressRootRenderTargetTime = _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_now() + 500, flushSyncWorkAcrossRoots_impl(0, !0));
+  }
+  function performWorkOnRoot(root$jscomp$0, lanes, forceSync) {
+    if (0 !== (executionContext & 6)) throw Error("Should not already be working.");
+    var shouldTimeSlice = !forceSync && 0 === (lanes & 124) && 0 === (lanes & root$jscomp$0.expiredLanes) || checkIfRootIsPrerendering(root$jscomp$0, lanes),
+      exitStatus = shouldTimeSlice ? renderRootConcurrent(root$jscomp$0, lanes) : renderRootSync(root$jscomp$0, lanes, !0),
+      renderWasConcurrent = shouldTimeSlice;
+    do {
+      if (0 === exitStatus) {
+        workInProgressRootIsPrerendering && !shouldTimeSlice && markRootSuspended(root$jscomp$0, lanes, 0, !1);
+        break;
+      } else {
+        forceSync = root$jscomp$0.current.alternate;
+        if (renderWasConcurrent && !isRenderConsistentWithExternalStores(forceSync)) {
+          exitStatus = renderRootSync(root$jscomp$0, lanes, !1);
+          renderWasConcurrent = !1;
+          continue;
+        }
+        if (0 !== root$jscomp$0.tag && 2 === exitStatus) {
+          renderWasConcurrent = lanes;
+          if (root$jscomp$0.errorRecoveryDisabledLanes & renderWasConcurrent) var JSCompiler_inline_result = 0;else JSCompiler_inline_result = root$jscomp$0.pendingLanes & -536870913, JSCompiler_inline_result = 0 !== JSCompiler_inline_result ? JSCompiler_inline_result : JSCompiler_inline_result & 536870912 ? 536870912 : 0;
+          if (0 !== JSCompiler_inline_result) {
+            lanes = JSCompiler_inline_result;
+            a: {
+              var root = root$jscomp$0;
+              exitStatus = workInProgressRootConcurrentErrors;
+              JSCompiler_inline_result = renderRootSync(root, JSCompiler_inline_result, !1);
+              if (2 !== JSCompiler_inline_result) {
+                if (workInProgressRootDidAttachPingListener) {
+                  root.errorRecoveryDisabledLanes |= renderWasConcurrent;
+                  workInProgressRootInterleavedUpdatedLanes |= renderWasConcurrent;
+                  exitStatus = 4;
+                  break a;
+                }
+                renderWasConcurrent = workInProgressRootRecoverableErrors;
+                workInProgressRootRecoverableErrors = exitStatus;
+                null !== renderWasConcurrent && (null === workInProgressRootRecoverableErrors ? workInProgressRootRecoverableErrors = renderWasConcurrent : workInProgressRootRecoverableErrors.push.apply(workInProgressRootRecoverableErrors, renderWasConcurrent));
+              }
+              exitStatus = JSCompiler_inline_result;
+            }
+            renderWasConcurrent = !1;
+            if (2 !== exitStatus) continue;
+          }
+        }
+        if (1 === exitStatus) {
+          prepareFreshStack(root$jscomp$0, 0);
+          markRootSuspended(root$jscomp$0, lanes, 0, !0);
+          break;
+        }
+        a: {
+          shouldTimeSlice = root$jscomp$0;
+          renderWasConcurrent = exitStatus;
+          switch (renderWasConcurrent) {
+            case 0:
+            case 1:
+              throw Error("Root did not complete. This is a bug in React.");
+            case 4:
+              if ((lanes & 4194048) !== lanes) break;
+            case 6:
+              markRootSuspended(shouldTimeSlice, lanes, workInProgressDeferredLane, !workInProgressRootDidSkipSuspendedSiblings);
+              break a;
+            case 2:
+              workInProgressRootRecoverableErrors = null;
+              break;
+            case 3:
+            case 5:
+              break;
+            default:
+              throw Error("Unknown root exit status.");
+          }
+          if ((lanes & 62914560) === lanes && 3 === renderWasConcurrent && (exitStatus = globalMostRecentFallbackTime + 300 - _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_now(), 10 < exitStatus)) {
+            markRootSuspended(shouldTimeSlice, lanes, workInProgressDeferredLane, !workInProgressRootDidSkipSuspendedSiblings);
+            if (0 !== getNextLanes(shouldTimeSlice, 0, !0)) break a;
+            shouldTimeSlice.timeoutHandle = scheduleTimeout(commitRootWhenReady.bind(null, shouldTimeSlice, forceSync, workInProgressRootRecoverableErrors, workInProgressTransitions, workInProgressRootDidIncludeRecursiveRenderUpdate, lanes, workInProgressDeferredLane, workInProgressRootInterleavedUpdatedLanes, workInProgressSuspendedRetryLanes, workInProgressRootDidSkipSuspendedSiblings, renderWasConcurrent, 2, -0, 0), exitStatus);
+            break a;
+          }
+          commitRootWhenReady(shouldTimeSlice, forceSync, workInProgressRootRecoverableErrors, workInProgressTransitions, workInProgressRootDidIncludeRecursiveRenderUpdate, lanes, workInProgressDeferredLane, workInProgressRootInterleavedUpdatedLanes, workInProgressSuspendedRetryLanes);
+        }
+      }
+      break;
+    } while (1);
+    ensureRootIsScheduled(root$jscomp$0);
+  }
+  function commitRootWhenReady(root, finishedWork, recoverableErrors, transitions, didIncludeRenderPhaseUpdate, lanes, spawnedLane, updatedLanes, suspendedRetryLanes) {
+    root.timeoutHandle = -1;
+    var subtreeFlags = finishedWork.subtreeFlags;
+    (subtreeFlags & 8192 || 16785408 === (subtreeFlags & 16785408)) && accumulateSuspenseyCommitOnFiber(finishedWork);
+    commitRoot(root, finishedWork, lanes, recoverableErrors, transitions, didIncludeRenderPhaseUpdate, spawnedLane, updatedLanes, suspendedRetryLanes);
+  }
+  function isRenderConsistentWithExternalStores(finishedWork) {
+    for (var node = finishedWork;;) {
+      var tag = node.tag;
+      if ((0 === tag || 11 === tag || 15 === tag) && node.flags & 16384 && (tag = node.updateQueue, null !== tag && (tag = tag.stores, null !== tag))) for (var i = 0; i < tag.length; i++) {
+        var check = tag[i],
+          getSnapshot = check.getSnapshot;
+        check = check.value;
+        try {
+          if (!objectIs(getSnapshot(), check)) return !1;
+        } catch (error) {
+          return !1;
+        }
+      }
+      tag = node.child;
+      if (node.subtreeFlags & 16384 && null !== tag) tag.return = node, node = tag;else {
+        if (node === finishedWork) break;
+        for (; null === node.sibling;) {
+          if (null === node.return || node.return === finishedWork) return !0;
+          node = node.return;
+        }
+        node.sibling.return = node.return;
+        node = node.sibling;
+      }
+    }
+    return !0;
+  }
+  function markRootSuspended(root, suspendedLanes, spawnedLane, didAttemptEntireTree) {
+    suspendedLanes &= ~workInProgressRootPingedLanes;
+    suspendedLanes &= ~workInProgressRootInterleavedUpdatedLanes;
+    root.suspendedLanes |= suspendedLanes;
+    root.pingedLanes &= ~suspendedLanes;
+    didAttemptEntireTree && (root.warmLanes |= suspendedLanes);
+    didAttemptEntireTree = root.expirationTimes;
+    for (var lanes = suspendedLanes; 0 < lanes;) {
+      var index$10 = 31 - clz32(lanes),
+        lane = 1 << index$10;
+      didAttemptEntireTree[index$10] = -1;
+      lanes &= ~lane;
+    }
+    0 !== spawnedLane && markSpawnedDeferredLane(root, spawnedLane, suspendedLanes);
+  }
+  function resetWorkInProgressStack() {
+    if (null !== workInProgress) {
+      if (0 === workInProgressSuspendedReason) var interruptedWork = workInProgress.return;else interruptedWork = workInProgress, lastContextDependency = currentlyRenderingFiber$1 = null, resetHooksOnUnwind(interruptedWork), thenableState = null, thenableIndexCounter = 0, interruptedWork = workInProgress;
+      for (; null !== interruptedWork;) unwindInterruptedWork(interruptedWork.alternate, interruptedWork), interruptedWork = interruptedWork.return;
+      workInProgress = null;
+    }
+  }
+  function prepareFreshStack(root, lanes) {
+    var timeoutHandle = root.timeoutHandle;
+    -1 !== timeoutHandle && (root.timeoutHandle = -1, cancelTimeout(timeoutHandle));
+    timeoutHandle = root.cancelPendingCommit;
+    null !== timeoutHandle && (root.cancelPendingCommit = null, timeoutHandle());
+    resetWorkInProgressStack();
+    workInProgressRoot = root;
+    workInProgress = timeoutHandle = createWorkInProgress(root.current, null);
+    workInProgressRootRenderLanes = lanes;
+    workInProgressSuspendedReason = 0;
+    workInProgressThrownValue = null;
+    workInProgressRootDidSkipSuspendedSiblings = !1;
+    workInProgressRootIsPrerendering = checkIfRootIsPrerendering(root, lanes);
+    workInProgressRootDidAttachPingListener = !1;
+    workInProgressSuspendedRetryLanes = workInProgressDeferredLane = workInProgressRootPingedLanes = workInProgressRootInterleavedUpdatedLanes = workInProgressRootSkippedLanes = workInProgressRootExitStatus = 0;
+    workInProgressRootRecoverableErrors = workInProgressRootConcurrentErrors = null;
+    workInProgressRootDidIncludeRecursiveRenderUpdate = !1;
+    0 !== (lanes & 8) && (lanes |= lanes & 32);
+    var allEntangledLanes = root.entangledLanes;
+    if (0 !== allEntangledLanes) for (root = root.entanglements, allEntangledLanes &= lanes; 0 < allEntangledLanes;) {
+      var index$8 = 31 - clz32(allEntangledLanes),
+        lane = 1 << index$8;
+      lanes |= root[index$8];
+      allEntangledLanes &= ~lane;
+    }
+    entangledRenderLanes = lanes;
+    finishQueueingConcurrentUpdates();
+    return timeoutHandle;
+  }
+  function handleThrow(root, thrownValue) {
+    currentlyRenderingFiber = null;
+    ReactSharedInternals.H = ContextOnlyDispatcher;
+    thrownValue === SuspenseException || thrownValue === SuspenseActionException ? (thrownValue = getSuspendedThenable(), workInProgressSuspendedReason = 3) : thrownValue === SuspenseyCommitException ? (thrownValue = getSuspendedThenable(), workInProgressSuspendedReason = 4) : workInProgressSuspendedReason = thrownValue === SelectiveHydrationException ? 8 : null !== thrownValue && "object" === typeof thrownValue && "function" === typeof thrownValue.then ? 6 : 1;
+    workInProgressThrownValue = thrownValue;
+    null === workInProgress && (workInProgressRootExitStatus = 1, logUncaughtError(root, createCapturedValueAtFiber(thrownValue, root.current)));
+  }
+  function pushDispatcher() {
+    var prevDispatcher = ReactSharedInternals.H;
+    ReactSharedInternals.H = ContextOnlyDispatcher;
+    return null === prevDispatcher ? ContextOnlyDispatcher : prevDispatcher;
+  }
+  function pushAsyncDispatcher() {
+    var prevAsyncDispatcher = ReactSharedInternals.A;
+    ReactSharedInternals.A = DefaultAsyncDispatcher;
+    return prevAsyncDispatcher;
+  }
+  function renderDidSuspendDelayIfPossible() {
+    workInProgressRootExitStatus = 4;
+    workInProgressRootDidSkipSuspendedSiblings || (workInProgressRootRenderLanes & 4194048) !== workInProgressRootRenderLanes && null !== suspenseHandlerStackCursor.current || (workInProgressRootIsPrerendering = !0);
+    0 === (workInProgressRootSkippedLanes & 134217727) && 0 === (workInProgressRootInterleavedUpdatedLanes & 134217727) || null === workInProgressRoot || markRootSuspended(workInProgressRoot, workInProgressRootRenderLanes, workInProgressDeferredLane, !1);
+  }
+  function renderRootSync(root, lanes, shouldYieldForPrerendering) {
+    var prevExecutionContext = executionContext;
+    executionContext |= 2;
+    var prevDispatcher = pushDispatcher(),
+      prevAsyncDispatcher = pushAsyncDispatcher();
+    if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) workInProgressTransitions = null, prepareFreshStack(root, lanes);
+    lanes = !1;
+    var exitStatus = workInProgressRootExitStatus;
+    a: do try {
+      if (0 !== workInProgressSuspendedReason && null !== workInProgress) {
+        var unitOfWork = workInProgress,
+          thrownValue = workInProgressThrownValue;
+        switch (workInProgressSuspendedReason) {
+          case 8:
+            resetWorkInProgressStack();
+            exitStatus = 6;
+            break a;
+          case 3:
+          case 2:
+          case 9:
+          case 6:
+            null === suspenseHandlerStackCursor.current && (lanes = !0);
+            var reason = workInProgressSuspendedReason;
+            workInProgressSuspendedReason = 0;
+            workInProgressThrownValue = null;
+            throwAndUnwindWorkLoop(root, unitOfWork, thrownValue, reason);
+            if (shouldYieldForPrerendering && workInProgressRootIsPrerendering) {
+              exitStatus = 0;
+              break a;
+            }
+            break;
+          default:
+            reason = workInProgressSuspendedReason, workInProgressSuspendedReason = 0, workInProgressThrownValue = null, throwAndUnwindWorkLoop(root, unitOfWork, thrownValue, reason);
+        }
+      }
+      workLoopSync();
+      exitStatus = workInProgressRootExitStatus;
+      break;
+    } catch (thrownValue$131) {
+      handleThrow(root, thrownValue$131);
+    } while (1);
+    lanes && root.shellSuspendCounter++;
+    lastContextDependency = currentlyRenderingFiber$1 = null;
+    executionContext = prevExecutionContext;
+    ReactSharedInternals.H = prevDispatcher;
+    ReactSharedInternals.A = prevAsyncDispatcher;
+    null === workInProgress && (workInProgressRoot = null, workInProgressRootRenderLanes = 0, finishQueueingConcurrentUpdates());
+    return exitStatus;
+  }
+  function workLoopSync() {
+    for (; null !== workInProgress;) performUnitOfWork(workInProgress);
+  }
+  function renderRootConcurrent(root, lanes) {
+    var prevExecutionContext = executionContext;
+    executionContext |= 2;
+    var prevDispatcher = pushDispatcher(),
+      prevAsyncDispatcher = pushAsyncDispatcher();
+    workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes ? (workInProgressTransitions = null, workInProgressRootRenderTargetTime = _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_now() + 500, prepareFreshStack(root, lanes)) : workInProgressRootIsPrerendering = checkIfRootIsPrerendering(root, lanes);
+    a: do try {
+      if (0 !== workInProgressSuspendedReason && null !== workInProgress) {
+        lanes = workInProgress;
+        var thrownValue = workInProgressThrownValue;
+        b: switch (workInProgressSuspendedReason) {
+          case 1:
+            workInProgressSuspendedReason = 0;
+            workInProgressThrownValue = null;
+            throwAndUnwindWorkLoop(root, lanes, thrownValue, 1);
+            break;
+          case 2:
+          case 9:
+            if (isThenableResolved(thrownValue)) {
+              workInProgressSuspendedReason = 0;
+              workInProgressThrownValue = null;
+              replaySuspendedUnitOfWork(lanes);
+              break;
+            }
+            lanes = function lanes() {
+              2 !== workInProgressSuspendedReason && 9 !== workInProgressSuspendedReason || workInProgressRoot !== root || (workInProgressSuspendedReason = 7);
+              ensureRootIsScheduled(root);
+            };
+            thrownValue.then(lanes, lanes);
+            break a;
+          case 3:
+            workInProgressSuspendedReason = 7;
+            break a;
+          case 4:
+            workInProgressSuspendedReason = 5;
+            break a;
+          case 7:
+            isThenableResolved(thrownValue) ? (workInProgressSuspendedReason = 0, workInProgressThrownValue = null, replaySuspendedUnitOfWork(lanes)) : (workInProgressSuspendedReason = 0, workInProgressThrownValue = null, throwAndUnwindWorkLoop(root, lanes, thrownValue, 7));
+            break;
+          case 5:
+            var resource = null;
+            switch (workInProgress.tag) {
+              case 26:
+                resource = workInProgress.memoizedState;
+              case 5:
+              case 27:
+                var hostFiber = workInProgress;
+                if (resource ? shim(resource) : 1) {
+                  workInProgressSuspendedReason = 0;
+                  workInProgressThrownValue = null;
+                  var sibling = hostFiber.sibling;
+                  if (null !== sibling) workInProgress = sibling;else {
+                    var returnFiber = hostFiber.return;
+                    null !== returnFiber ? (workInProgress = returnFiber, completeUnitOfWork(returnFiber)) : workInProgress = null;
+                  }
+                  break b;
+                }
+            }
+            workInProgressSuspendedReason = 0;
+            workInProgressThrownValue = null;
+            throwAndUnwindWorkLoop(root, lanes, thrownValue, 5);
+            break;
+          case 6:
+            workInProgressSuspendedReason = 0;
+            workInProgressThrownValue = null;
+            throwAndUnwindWorkLoop(root, lanes, thrownValue, 6);
+            break;
+          case 8:
+            resetWorkInProgressStack();
+            workInProgressRootExitStatus = 6;
+            break a;
+          default:
+            throw Error("Unexpected SuspendedReason. This is a bug in React.");
+        }
+      }
+      workLoopConcurrentByScheduler();
+      break;
+    } catch (thrownValue$133) {
+      handleThrow(root, thrownValue$133);
+    } while (1);
+    lastContextDependency = currentlyRenderingFiber$1 = null;
+    ReactSharedInternals.H = prevDispatcher;
+    ReactSharedInternals.A = prevAsyncDispatcher;
+    executionContext = prevExecutionContext;
+    if (null !== workInProgress) return 0;
+    workInProgressRoot = null;
+    workInProgressRootRenderLanes = 0;
+    finishQueueingConcurrentUpdates();
+    return workInProgressRootExitStatus;
+  }
+  function workLoopConcurrentByScheduler() {
+    for (; null !== workInProgress && !_$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_shouldYield();) performUnitOfWork(workInProgress);
+  }
+  function performUnitOfWork(unitOfWork) {
+    var next = beginWork(unitOfWork.alternate, unitOfWork, entangledRenderLanes);
+    unitOfWork.memoizedProps = unitOfWork.pendingProps;
+    null === next ? completeUnitOfWork(unitOfWork) : workInProgress = next;
+  }
+  function replaySuspendedUnitOfWork(unitOfWork) {
+    var next = unitOfWork;
+    var current = next.alternate;
+    switch (next.tag) {
+      case 15:
+      case 0:
+        next = replayFunctionComponent(current, next, next.pendingProps, next.type, void 0, workInProgressRootRenderLanes);
+        break;
+      case 11:
+        next = replayFunctionComponent(current, next, next.pendingProps, next.type.render, next.ref, workInProgressRootRenderLanes);
+        break;
+      case 5:
+        resetHooksOnUnwind(next);
+      default:
+        unwindInterruptedWork(current, next), next = workInProgress = resetWorkInProgress(next, entangledRenderLanes), next = beginWork(current, next, entangledRenderLanes);
+    }
+    unitOfWork.memoizedProps = unitOfWork.pendingProps;
+    null === next ? completeUnitOfWork(unitOfWork) : workInProgress = next;
+  }
+  function throwAndUnwindWorkLoop(root, unitOfWork, thrownValue, suspendedReason) {
+    lastContextDependency = currentlyRenderingFiber$1 = null;
+    resetHooksOnUnwind(unitOfWork);
+    thenableState = null;
+    thenableIndexCounter = 0;
+    var returnFiber = unitOfWork.return;
+    try {
+      if (throwException(root, returnFiber, unitOfWork, thrownValue, workInProgressRootRenderLanes)) {
+        workInProgressRootExitStatus = 1;
+        logUncaughtError(root, createCapturedValueAtFiber(thrownValue, root.current));
+        workInProgress = null;
+        return;
+      }
+    } catch (error) {
+      if (null !== returnFiber) throw workInProgress = returnFiber, error;
+      workInProgressRootExitStatus = 1;
+      logUncaughtError(root, createCapturedValueAtFiber(thrownValue, root.current));
+      workInProgress = null;
+      return;
+    }
+    if (unitOfWork.flags & 32768) {
+      if (1 === suspendedReason) root = !0;else if (workInProgressRootIsPrerendering || 0 !== (workInProgressRootRenderLanes & 536870912)) root = !1;else if (workInProgressRootDidSkipSuspendedSiblings = root = !0, 2 === suspendedReason || 9 === suspendedReason || 3 === suspendedReason || 6 === suspendedReason) suspendedReason = suspenseHandlerStackCursor.current, null !== suspendedReason && 13 === suspendedReason.tag && (suspendedReason.flags |= 16384);
+      unwindUnitOfWork(unitOfWork, root);
+    } else completeUnitOfWork(unitOfWork);
+  }
+  function completeUnitOfWork(unitOfWork) {
+    var completedWork = unitOfWork;
+    do {
+      if (0 !== (completedWork.flags & 32768)) {
+        unwindUnitOfWork(completedWork, workInProgressRootDidSkipSuspendedSiblings);
+        return;
+      }
+      unitOfWork = completedWork.return;
+      var next = completeWork(completedWork.alternate, completedWork, entangledRenderLanes);
+      if (null !== next) {
+        workInProgress = next;
+        return;
+      }
+      completedWork = completedWork.sibling;
+      if (null !== completedWork) {
+        workInProgress = completedWork;
+        return;
+      }
+      workInProgress = completedWork = unitOfWork;
+    } while (null !== completedWork);
+    0 === workInProgressRootExitStatus && (workInProgressRootExitStatus = 5);
+  }
+  function unwindUnitOfWork(unitOfWork, skipSiblings) {
+    do {
+      var next = unwindWork(unitOfWork.alternate, unitOfWork);
+      if (null !== next) {
+        next.flags &= 32767;
+        workInProgress = next;
+        return;
+      }
+      next = unitOfWork.return;
+      null !== next && (next.flags |= 32768, next.subtreeFlags = 0, next.deletions = null);
+      if (!skipSiblings && (unitOfWork = unitOfWork.sibling, null !== unitOfWork)) {
+        workInProgress = unitOfWork;
+        return;
+      }
+      workInProgress = unitOfWork = next;
+    } while (null !== unitOfWork);
+    workInProgressRootExitStatus = 6;
+    workInProgress = null;
+  }
+  function commitRoot(root, finishedWork, lanes, recoverableErrors, transitions, didIncludeRenderPhaseUpdate, spawnedLane, updatedLanes, suspendedRetryLanes) {
+    root.cancelPendingCommit = null;
+    do flushPendingEffects(); while (0 !== pendingEffectsStatus);
+    if (0 !== (executionContext & 6)) throw Error("Should not already be working.");
+    if (null !== finishedWork) {
+      if (finishedWork === root.current) throw Error("Cannot commit the same tree as before. This error is likely caused by a bug in React. Please file an issue.");
+      didIncludeRenderPhaseUpdate = finishedWork.lanes | finishedWork.childLanes;
+      didIncludeRenderPhaseUpdate |= concurrentlyUpdatedLanes;
+      markRootFinished(root, lanes, didIncludeRenderPhaseUpdate, spawnedLane, updatedLanes, suspendedRetryLanes);
+      root === workInProgressRoot && (workInProgress = workInProgressRoot = null, workInProgressRootRenderLanes = 0);
+      pendingFinishedWork = finishedWork;
+      pendingEffectsRoot = root;
+      pendingEffectsLanes = lanes;
+      pendingEffectsRemainingLanes = didIncludeRenderPhaseUpdate;
+      pendingPassiveTransitions = transitions;
+      pendingRecoverableErrors = recoverableErrors;
+      0 !== (finishedWork.subtreeFlags & 10256) || 0 !== (finishedWork.flags & 10256) ? (root.callbackNode = null, root.callbackPriority = 0, scheduleCallback(_$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_NormalPriority, function () {
+        flushPassiveEffects(!0);
+        return null;
+      })) : (root.callbackNode = null, root.callbackPriority = 0);
+      recoverableErrors = 0 !== (finishedWork.flags & 13878);
+      if (0 !== (finishedWork.subtreeFlags & 13878) || recoverableErrors) {
+        recoverableErrors = ReactSharedInternals.T;
+        ReactSharedInternals.T = null;
+        transitions = currentUpdatePriority;
+        currentUpdatePriority = 2;
+        spawnedLane = executionContext;
+        executionContext |= 4;
+        try {
+          commitBeforeMutationEffects(root, finishedWork, lanes);
+        } finally {
+          executionContext = spawnedLane, currentUpdatePriority = transitions, ReactSharedInternals.T = recoverableErrors;
+        }
+      }
+      pendingEffectsStatus = 1;
+      flushMutationEffects();
+      flushLayoutEffects();
+      flushSpawnedWork();
+    }
+  }
+  function flushMutationEffects() {
+    if (1 === pendingEffectsStatus) {
+      pendingEffectsStatus = 0;
+      var root = pendingEffectsRoot,
+        finishedWork = pendingFinishedWork,
+        rootMutationHasEffect = 0 !== (finishedWork.flags & 13878);
+      if (0 !== (finishedWork.subtreeFlags & 13878) || rootMutationHasEffect) {
+        rootMutationHasEffect = ReactSharedInternals.T;
+        ReactSharedInternals.T = null;
+        var previousPriority = currentUpdatePriority;
+        currentUpdatePriority = 2;
+        var prevExecutionContext = executionContext;
+        executionContext |= 4;
+        try {
+          commitMutationEffectsOnFiber(finishedWork, root);
+        } finally {
+          executionContext = prevExecutionContext, currentUpdatePriority = previousPriority, ReactSharedInternals.T = rootMutationHasEffect;
+        }
+      }
+      root.current = finishedWork;
+      pendingEffectsStatus = 2;
+    }
+  }
+  function flushLayoutEffects() {
+    if (2 === pendingEffectsStatus) {
+      pendingEffectsStatus = 0;
+      var root = pendingEffectsRoot,
+        finishedWork = pendingFinishedWork,
+        rootHasLayoutEffect = 0 !== (finishedWork.flags & 8772);
+      if (0 !== (finishedWork.subtreeFlags & 8772) || rootHasLayoutEffect) {
+        rootHasLayoutEffect = ReactSharedInternals.T;
+        ReactSharedInternals.T = null;
+        var previousPriority = currentUpdatePriority;
+        currentUpdatePriority = 2;
+        var prevExecutionContext = executionContext;
+        executionContext |= 4;
+        try {
+          commitLayoutEffectOnFiber(root, finishedWork.alternate, finishedWork);
+        } finally {
+          executionContext = prevExecutionContext, currentUpdatePriority = previousPriority, ReactSharedInternals.T = rootHasLayoutEffect;
+        }
+      }
+      pendingEffectsStatus = 3;
+    }
+  }
+  function flushSpawnedWork() {
+    if (4 === pendingEffectsStatus || 3 === pendingEffectsStatus) {
+      pendingEffectsStatus = 0;
+      _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_requestPaint();
+      var root = pendingEffectsRoot,
+        finishedWork = pendingFinishedWork,
+        lanes = pendingEffectsLanes,
+        recoverableErrors = pendingRecoverableErrors;
+      0 !== (finishedWork.subtreeFlags & 10256) || 0 !== (finishedWork.flags & 10256) ? pendingEffectsStatus = 5 : (pendingEffectsStatus = 0, pendingFinishedWork = pendingEffectsRoot = null, releaseRootPooledCache(root, root.pendingLanes));
+      var remainingLanes = root.pendingLanes;
+      0 === remainingLanes && (legacyErrorBoundariesThatAlreadyFailed = null);
+      lanesToEventPriority(lanes);
+      finishedWork = finishedWork.stateNode;
+      if (injectedHook && "function" === typeof injectedHook.onCommitFiberRoot) try {
+        injectedHook.onCommitFiberRoot(rendererID, finishedWork, void 0, 128 === (finishedWork.current.flags & 128));
+      } catch (err) {}
+      if (null !== recoverableErrors) {
+        finishedWork = ReactSharedInternals.T;
+        remainingLanes = currentUpdatePriority;
+        currentUpdatePriority = 2;
+        ReactSharedInternals.T = null;
+        try {
+          for (var onRecoverableError = root.onRecoverableError, i = 0; i < recoverableErrors.length; i++) {
+            var recoverableError = recoverableErrors[i];
+            onRecoverableError(recoverableError.value, {
+              componentStack: recoverableError.stack
+            });
+          }
+        } finally {
+          ReactSharedInternals.T = finishedWork, currentUpdatePriority = remainingLanes;
+        }
+      }
+      0 !== (pendingEffectsLanes & 3) && 0 !== root.tag && flushPendingEffects();
+      ensureRootIsScheduled(root);
+      remainingLanes = root.pendingLanes;
+      0 !== (lanes & 4194090) && 0 !== (remainingLanes & 42) ? root === rootWithNestedUpdates ? nestedUpdateCount++ : (nestedUpdateCount = 0, rootWithNestedUpdates = root) : nestedUpdateCount = 0;
+      flushSyncWorkAcrossRoots_impl(0, !1);
+    }
+  }
+  function releaseRootPooledCache(root, remainingLanes) {
+    0 === (root.pooledCacheLanes &= remainingLanes) && (remainingLanes = root.pooledCache, null != remainingLanes && (root.pooledCache = null, releaseCache(remainingLanes)));
+  }
+  function flushPendingEffects(wasDelayedCommit) {
+    flushMutationEffects();
+    flushLayoutEffects();
+    flushSpawnedWork();
+    return flushPassiveEffects(wasDelayedCommit);
+  }
+  function flushPassiveEffects() {
+    if (5 !== pendingEffectsStatus) return !1;
+    var root = pendingEffectsRoot,
+      remainingLanes = pendingEffectsRemainingLanes;
+    pendingEffectsRemainingLanes = 0;
+    var renderPriority = lanesToEventPriority(pendingEffectsLanes),
+      prevTransition = ReactSharedInternals.T,
+      previousPriority = currentUpdatePriority;
+    try {
+      currentUpdatePriority = 32 > renderPriority ? 32 : renderPriority;
+      ReactSharedInternals.T = null;
+      renderPriority = pendingPassiveTransitions;
+      pendingPassiveTransitions = null;
+      var root$jscomp$0 = pendingEffectsRoot,
+        lanes = pendingEffectsLanes;
+      pendingEffectsStatus = 0;
+      pendingFinishedWork = pendingEffectsRoot = null;
+      pendingEffectsLanes = 0;
+      if (0 !== (executionContext & 6)) throw Error("Cannot flush passive effects while already rendering.");
+      var prevExecutionContext = executionContext;
+      executionContext |= 4;
+      commitPassiveUnmountOnFiber(root$jscomp$0.current);
+      commitPassiveMountOnFiber(root$jscomp$0, root$jscomp$0.current, lanes, renderPriority);
+      executionContext = prevExecutionContext;
+      flushSyncWorkAcrossRoots_impl(0, !1);
+      if (injectedHook && "function" === typeof injectedHook.onPostCommitFiberRoot) try {
+        injectedHook.onPostCommitFiberRoot(rendererID, root$jscomp$0);
+      } catch (err) {}
+      return !0;
+    } finally {
+      currentUpdatePriority = previousPriority, ReactSharedInternals.T = prevTransition, releaseRootPooledCache(root, remainingLanes);
+    }
+  }
+  function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
+    sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
+    sourceFiber = createRootErrorUpdate(rootFiber.stateNode, sourceFiber, 2);
+    rootFiber = enqueueUpdate(rootFiber, sourceFiber, 2);
+    null !== rootFiber && (markRootUpdated$1(rootFiber, 2), ensureRootIsScheduled(rootFiber));
+  }
+  function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {
+    if (3 === sourceFiber.tag) captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);else for (; null !== nearestMountedAncestor;) {
+      if (3 === nearestMountedAncestor.tag) {
+        captureCommitPhaseErrorOnRoot(nearestMountedAncestor, sourceFiber, error);
+        break;
+      } else if (1 === nearestMountedAncestor.tag) {
+        var instance = nearestMountedAncestor.stateNode;
+        if ("function" === typeof nearestMountedAncestor.type.getDerivedStateFromError || "function" === typeof instance.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(instance))) {
+          sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
+          error = createClassErrorUpdate(2);
+          instance = enqueueUpdate(nearestMountedAncestor, error, 2);
+          null !== instance && (initializeClassErrorUpdate(error, instance, nearestMountedAncestor, sourceFiber), markRootUpdated$1(instance, 2), ensureRootIsScheduled(instance));
+          break;
+        }
+      }
+      nearestMountedAncestor = nearestMountedAncestor.return;
+    }
+  }
+  function attachPingListener(root, wakeable, lanes) {
+    var pingCache = root.pingCache;
+    if (null === pingCache) {
+      pingCache = root.pingCache = new PossiblyWeakMap();
+      var threadIDs = new Set();
+      pingCache.set(wakeable, threadIDs);
+    } else threadIDs = pingCache.get(wakeable), void 0 === threadIDs && (threadIDs = new Set(), pingCache.set(wakeable, threadIDs));
+    threadIDs.has(lanes) || (workInProgressRootDidAttachPingListener = !0, threadIDs.add(lanes), root = pingSuspendedRoot.bind(null, root, wakeable, lanes), wakeable.then(root, root));
+  }
+  function pingSuspendedRoot(root, wakeable, pingedLanes) {
+    var pingCache = root.pingCache;
+    null !== pingCache && pingCache.delete(wakeable);
+    root.pingedLanes |= root.suspendedLanes & pingedLanes;
+    root.warmLanes &= ~pingedLanes;
+    workInProgressRoot === root && (workInProgressRootRenderLanes & pingedLanes) === pingedLanes && (4 === workInProgressRootExitStatus || 3 === workInProgressRootExitStatus && (workInProgressRootRenderLanes & 62914560) === workInProgressRootRenderLanes && 300 > _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_now() - globalMostRecentFallbackTime ? 0 === (executionContext & 2) && prepareFreshStack(root, 0) : workInProgressRootPingedLanes |= pingedLanes, workInProgressSuspendedRetryLanes === workInProgressRootRenderLanes && (workInProgressSuspendedRetryLanes = 0));
+    ensureRootIsScheduled(root);
+  }
+  function retryTimedOutBoundary(boundaryFiber, retryLane) {
+    0 === retryLane && (retryLane = 0 === (boundaryFiber.mode & 1) ? 2 : claimNextRetryLane());
+    boundaryFiber = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
+    null !== boundaryFiber && (markRootUpdated$1(boundaryFiber, retryLane), ensureRootIsScheduled(boundaryFiber));
+  }
+  function retryDehydratedSuspenseBoundary(boundaryFiber) {
+    var suspenseState = boundaryFiber.memoizedState,
+      retryLane = 0;
+    null !== suspenseState && (retryLane = suspenseState.retryLane);
+    retryTimedOutBoundary(boundaryFiber, retryLane);
+  }
+  function resolveRetryWakeable(boundaryFiber, wakeable) {
+    var retryLane = 0;
+    switch (boundaryFiber.tag) {
+      case 13:
+        var retryCache = boundaryFiber.stateNode;
+        var suspenseState = boundaryFiber.memoizedState;
+        null !== suspenseState && (retryLane = suspenseState.retryLane);
+        break;
+      case 19:
+        retryCache = boundaryFiber.stateNode;
+        break;
+      case 22:
+        retryCache = boundaryFiber.stateNode._retryCache;
+        break;
+      default:
+        throw Error("Pinged unknown suspense boundary type. This is probably a bug in React.");
+    }
+    null !== retryCache && retryCache.delete(wakeable);
+    retryTimedOutBoundary(boundaryFiber, retryLane);
+  }
+  function scheduleCallback(priorityLevel, callback) {
+    return _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_scheduleCallback(priorityLevel, callback);
+  }
+  function FiberNode(tag, pendingProps, key, mode) {
+    this.tag = tag;
+    this.key = key;
+    this.sibling = this.child = this.return = this.stateNode = this.type = this.elementType = null;
+    this.index = 0;
+    this.refCleanup = this.ref = null;
+    this.pendingProps = pendingProps;
+    this.dependencies = this.memoizedState = this.updateQueue = this.memoizedProps = null;
+    this.mode = mode;
+    this.subtreeFlags = this.flags = 0;
+    this.deletions = null;
+    this.childLanes = this.lanes = 0;
+    this.alternate = null;
+  }
+  function createFiberImplClass(tag, pendingProps, key, mode) {
+    return new FiberNode(tag, pendingProps, key, mode);
+  }
+  function shouldConstruct(Component) {
+    Component = Component.prototype;
+    return !(!Component || !Component.isReactComponent);
+  }
+  function createWorkInProgress(current, pendingProps) {
+    var workInProgress = current.alternate;
+    null === workInProgress ? (workInProgress = createFiberImplClass(current.tag, pendingProps, current.key, current.mode), workInProgress.elementType = current.elementType, workInProgress.type = current.type, workInProgress.stateNode = current.stateNode, workInProgress.alternate = current, current.alternate = workInProgress) : (workInProgress.pendingProps = pendingProps, workInProgress.type = current.type, workInProgress.flags = 0, workInProgress.subtreeFlags = 0, workInProgress.deletions = null);
+    workInProgress.flags = current.flags & 65011712;
+    workInProgress.childLanes = current.childLanes;
+    workInProgress.lanes = current.lanes;
+    workInProgress.child = current.child;
+    workInProgress.memoizedProps = current.memoizedProps;
+    workInProgress.memoizedState = current.memoizedState;
+    workInProgress.updateQueue = current.updateQueue;
+    pendingProps = current.dependencies;
+    workInProgress.dependencies = null === pendingProps ? null : {
+      lanes: pendingProps.lanes,
+      firstContext: pendingProps.firstContext
+    };
+    workInProgress.sibling = current.sibling;
+    workInProgress.index = current.index;
+    workInProgress.ref = current.ref;
+    workInProgress.refCleanup = current.refCleanup;
+    return workInProgress;
+  }
+  function resetWorkInProgress(workInProgress, renderLanes) {
+    workInProgress.flags &= 65011714;
+    var current = workInProgress.alternate;
+    null === current ? (workInProgress.childLanes = 0, workInProgress.lanes = renderLanes, workInProgress.child = null, workInProgress.subtreeFlags = 0, workInProgress.memoizedProps = null, workInProgress.memoizedState = null, workInProgress.updateQueue = null, workInProgress.dependencies = null, workInProgress.stateNode = null) : (workInProgress.childLanes = current.childLanes, workInProgress.lanes = current.lanes, workInProgress.child = current.child, workInProgress.subtreeFlags = 0, workInProgress.deletions = null, workInProgress.memoizedProps = current.memoizedProps, workInProgress.memoizedState = current.memoizedState, workInProgress.updateQueue = current.updateQueue, workInProgress.type = current.type, renderLanes = current.dependencies, workInProgress.dependencies = null === renderLanes ? null : {
+      lanes: renderLanes.lanes,
+      firstContext: renderLanes.firstContext
+    });
+    return workInProgress;
+  }
+  function createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, lanes) {
+    var fiberTag = 0;
+    owner = type;
+    if ("function" === typeof type) shouldConstruct(type) && (fiberTag = 1);else if ("string" === typeof type) fiberTag = 5;else a: switch (type) {
+      case REACT_ACTIVITY_TYPE:
+        return type = createFiberImplClass(31, pendingProps, key, mode), type.elementType = REACT_ACTIVITY_TYPE, type.lanes = lanes, type;
+      case REACT_FRAGMENT_TYPE:
+        return createFiberFromFragment(pendingProps.children, mode, lanes, key);
+      case REACT_STRICT_MODE_TYPE:
+        fiberTag = 8;
+        mode |= 8;
+        0 !== (mode & 1) && (mode |= 16);
+        break;
+      case REACT_PROFILER_TYPE:
+        return type = createFiberImplClass(12, pendingProps, key, mode | 2), type.elementType = REACT_PROFILER_TYPE, type.lanes = lanes, type;
+      case REACT_SUSPENSE_TYPE:
+        return type = createFiberImplClass(13, pendingProps, key, mode), type.elementType = REACT_SUSPENSE_TYPE, type.lanes = lanes, type;
+      case REACT_SUSPENSE_LIST_TYPE:
+        return type = createFiberImplClass(19, pendingProps, key, mode), type.elementType = REACT_SUSPENSE_LIST_TYPE, type.lanes = lanes, type;
+      default:
+        if ("object" === typeof type && null !== type) switch (type.$$typeof) {
+          case REACT_PROVIDER_TYPE:
+          case REACT_CONTEXT_TYPE:
+            fiberTag = 10;
+            break a;
+          case REACT_CONSUMER_TYPE:
+            fiberTag = 9;
+            break a;
+          case REACT_FORWARD_REF_TYPE:
+            fiberTag = 11;
+            break a;
+          case REACT_MEMO_TYPE:
+            fiberTag = 14;
+            break a;
+          case REACT_LAZY_TYPE:
+            fiberTag = 16;
+            owner = null;
+            break a;
+        }
+        fiberTag = 29;
+        pendingProps = Error("Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: " + ((null === type ? "null" : typeof type) + "."));
+        owner = null;
+    }
+    key = createFiberImplClass(fiberTag, pendingProps, key, mode);
+    key.elementType = type;
+    key.type = owner;
+    key.lanes = lanes;
+    return key;
+  }
+  function createFiberFromFragment(elements, mode, lanes, key) {
+    elements = createFiberImplClass(7, elements, key, mode);
+    elements.lanes = lanes;
+    return elements;
+  }
+  function createFiberFromText(content, mode, lanes) {
+    content = createFiberImplClass(6, content, null, mode);
+    content.lanes = lanes;
+    return content;
+  }
+  function createFiberFromPortal(portal, mode, lanes) {
+    mode = createFiberImplClass(4, null !== portal.children ? portal.children : [], portal.key, mode);
+    mode.lanes = lanes;
+    mode.stateNode = {
+      containerInfo: portal.containerInfo,
+      pendingChildren: null,
+      implementation: portal.implementation
+    };
+    return mode;
+  }
+  function FiberRootNode(containerInfo, tag, hydrate, identifierPrefix, onUncaughtError, onCaughtError, onRecoverableError, formState) {
+    this.tag = tag;
+    this.containerInfo = containerInfo;
+    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 = createLaneMap(-1);
+    this.entangledLanes = this.shellSuspendCounter = this.errorRecoveryDisabledLanes = this.expiredLanes = this.warmLanes = this.pingedLanes = this.suspendedLanes = this.pendingLanes = 0;
+    this.entanglements = createLaneMap(0);
+    this.hiddenUpdates = createLaneMap(null);
+    this.identifierPrefix = identifierPrefix;
+    this.onUncaughtError = onUncaughtError;
+    this.onCaughtError = onCaughtError;
+    this.onRecoverableError = onRecoverableError;
+    this.pooledCache = null;
+    this.pooledCacheLanes = 0;
+    this.formState = formState;
+    this.incompleteTransitions = new Map();
+  }
+  function createPortal$1(children, containerInfo, implementation) {
+    var key = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
+    return {
+      $$typeof: REACT_PORTAL_TYPE,
+      key: null == key ? null : "" + key,
+      children: children,
+      containerInfo: containerInfo,
+      implementation: implementation
+    };
+  }
+  function findHostInstance(component) {
+    var fiber = component._reactInternals;
+    if (void 0 === fiber) {
+      if ("function" === typeof component.render) throw Error("Unable to find node on an unmounted component.");
+      component = Object.keys(component).join(",");
+      throw Error("Argument appears to not be a ReactComponent. Keys: " + component);
+    }
+    component = findCurrentFiberUsingSlowPath(fiber);
+    component = null !== component ? findCurrentHostFiberImpl(component) : null;
+    return null === component ? null : getPublicInstance(component.stateNode);
+  }
+  function updateContainer(element, container, parentComponent, callback) {
+    parentComponent = container.current;
+    var lane = requestUpdateLane(parentComponent);
+    null === container.context ? container.context = emptyContextObject : container.pendingContext = emptyContextObject;
+    container = createUpdate(lane);
+    container.payload = {
+      element: element
+    };
+    callback = void 0 === callback ? null : callback;
+    null !== callback && (container.callback = callback);
+    element = enqueueUpdate(parentComponent, container, lane);
+    null !== element && (scheduleUpdateOnFiber(element, parentComponent, lane), entangleTransitions(element, parentComponent, lane));
+    return lane;
+  }
+  function shim$1() {
+    throw Error("The current renderer does not support hydration. This error is likely caused by a bug in React. Please file an issue.");
+  }
+  function shim() {
+    throw Error("The current renderer does not support Resources. This error is likely caused by a bug in React. Please file an issue.");
+  }
+  var _nativeFabricUIManage = nativeFabricUIManager,
+    createNode = _nativeFabricUIManage.createNode,
+    cloneNodeWithNewChildren = _nativeFabricUIManage.cloneNodeWithNewChildren,
+    cloneNodeWithNewChildrenAndProps = _nativeFabricUIManage.cloneNodeWithNewChildrenAndProps,
+    cloneNodeWithNewProps = _nativeFabricUIManage.cloneNodeWithNewProps,
+    createChildNodeSet = _nativeFabricUIManage.createChildSet,
+    appendChildNode = _nativeFabricUIManage.appendChild,
+    appendChildNodeToSet = _nativeFabricUIManage.appendChildToSet,
+    completeRoot = _nativeFabricUIManage.completeRoot,
+    registerEventHandler = _nativeFabricUIManage.registerEventHandler,
+    FabricDiscretePriority = _nativeFabricUIManage.unstable_DiscreteEventPriority,
+    fabricGetCurrentEventPriority = _nativeFabricUIManage.unstable_getCurrentEventPriority,
+    extraDevToolsConfig = {
+      getInspectorDataForInstance: void 0,
+      getInspectorDataForViewTag: function getInspectorDataForViewTag() {
+        throw Error("getInspectorDataForViewTag() is not available in production");
+      },
+      getInspectorDataForViewAtPoint: function getInspectorDataForViewAtPoint() {
+        throw Error("getInspectorDataForViewAtPoint() is not available in production.");
+      }
+    },
+    getViewConfigForType = _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").ReactNativeViewConfigRegistry.get,
+    nextReactTag = 2;
+  registerEventHandler && registerEventHandler(dispatchEvent);
+  var PROD_HOST_CONTEXT = {
+    isInAParentText: !0
+  };
+  function createTextInstance(text, rootContainerInstance, hostContext, internalInstanceHandle) {
+    hostContext = nextReactTag;
+    nextReactTag += 2;
+    return {
+      node: createNode(hostContext, "RCTRawText", rootContainerInstance.containerTag, {
+        text: text
+      }, internalInstanceHandle)
+    };
+  }
+  function getPublicInstance(instance) {
+    if (null != instance.canonical) {
+      if (null == instance.canonical.publicInstance) {
+        var $jscomp$nullish$tmp0;
+        instance.canonical.publicInstance = _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").createPublicInstance(instance.canonical.nativeTag, instance.canonical.viewConfig, instance.canonical.internalInstanceHandle, null != ($jscomp$nullish$tmp0 = instance.canonical.publicRootInstance) ? $jscomp$nullish$tmp0 : null);
+        instance.canonical.publicRootInstance = null;
+      }
+      return instance.canonical.publicInstance;
+    }
+    return null != instance._nativeTag ? instance : null;
+  }
+  var currentUpdatePriority = 0;
+  function resolveUpdatePriority() {
+    if (0 !== currentUpdatePriority) return currentUpdatePriority;
+    var currentEventPriority = fabricGetCurrentEventPriority ? fabricGetCurrentEventPriority() : null;
+    if (null != currentEventPriority) switch (currentEventPriority) {
+      case FabricDiscretePriority:
+        return 2;
+    }
+    return 32;
+  }
+  var scheduleTimeout = setTimeout,
+    cancelTimeout = clearTimeout;
+  function cloneHiddenInstance(instance) {
+    var node = instance.node;
+    var JSCompiler_inline_result = fastAddProperties(null, {
+      style: {
+        display: "none"
+      }
+    }, instance.canonical.viewConfig.validAttributes);
+    return {
+      node: cloneNodeWithNewProps(node, JSCompiler_inline_result),
+      canonical: instance.canonical
+    };
+  }
+  var HostTransitionContext = {
+      $$typeof: REACT_CONTEXT_TYPE,
+      Provider: null,
+      Consumer: null,
+      _currentValue: null,
+      _currentValue2: null,
+      _threadCount: 0
+    },
+    supportsMicrotasks = "undefined" !== typeof RN$enableMicrotasksInReact && !!RN$enableMicrotasksInReact,
+    scheduleMicrotask = "function" === typeof queueMicrotask ? queueMicrotask : scheduleTimeout;
+  getFiberCurrentPropsFromNode$1 = function getFiberCurrentPropsFromNode$1(instance) {
+    return instance.canonical.currentProps;
+  };
+  getInstanceFromNode$1 = function getInstanceFromNode$1(node) {
+    return null != node.canonical && null != node.canonical.internalInstanceHandle ? node.canonical.internalInstanceHandle : node;
+  };
+  getNodeFromInstance$1 = function getNodeFromInstance$1(fiber) {
+    fiber = getPublicInstance(fiber.stateNode);
+    if (null == fiber) throw Error("Could not find host instance from fiber");
+    return fiber;
+  };
+  ResponderEventPlugin.injection.injectGlobalResponderHandler({
+    onChange: function onChange(from, to, blockNativeResponder) {
+      from && from.stateNode && nativeFabricUIManager.setIsJSResponder(from.stateNode.node, !1, blockNativeResponder || !1);
+      to && to.stateNode && nativeFabricUIManager.setIsJSResponder(to.stateNode.node, !0, blockNativeResponder || !1);
+    }
+  });
+  if ("function" !== typeof _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").ReactFiberErrorDialog.showErrorDialog) throw Error("Expected ReactFiberErrorDialog.showErrorDialog to be a function.");
+  function nativeOnUncaughtError(error, errorInfo) {
+    !1 !== _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").ReactFiberErrorDialog.showErrorDialog({
+      errorBoundary: null,
+      error: error,
+      componentStack: null != errorInfo.componentStack ? errorInfo.componentStack : ""
+    }) && reportGlobalError(error);
+  }
+  function nativeOnCaughtError(error, errorInfo) {
+    !1 !== _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").ReactFiberErrorDialog.showErrorDialog({
+      errorBoundary: errorInfo.errorBoundary,
+      error: error,
+      componentStack: null != errorInfo.componentStack ? errorInfo.componentStack : ""
+    }) && console.error(error);
+  }
+  batchedUpdatesImpl = function batchedUpdatesImpl(fn, a) {
+    var prevExecutionContext = executionContext;
+    executionContext |= 1;
+    try {
+      return fn(a);
+    } finally {
+      executionContext = prevExecutionContext, 0 === executionContext && (workInProgressRootRenderTargetTime = _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_now() + 500, flushSyncWorkAcrossRoots_impl(0, !0));
+    }
+  };
+  var roots = new Map(),
+    internals$jscomp$inline_1206 = {
+      bundleType: 0,
+      version: "19.1.0",
+      rendererPackageName: "react-native-renderer",
+      currentDispatcherRef: ReactSharedInternals,
+      reconcilerVersion: "19.1.0"
+    };
+  null !== extraDevToolsConfig && (internals$jscomp$inline_1206.rendererConfig = extraDevToolsConfig);
+  if ("undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) {
+    var hook$jscomp$inline_1519 = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+    if (!hook$jscomp$inline_1519.isDisabled && hook$jscomp$inline_1519.supportsFiber) try {
+      rendererID = hook$jscomp$inline_1519.inject(internals$jscomp$inline_1206), injectedHook = hook$jscomp$inline_1519;
+    } catch (err) {}
+  }
+  exports.createPortal = function (children, containerTag) {
+    return createPortal$1(children, containerTag, null, 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null);
+  };
+  exports.dispatchCommand = function (handle, command, args) {
+    var nativeTag = null != handle._nativeTag ? handle._nativeTag : _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").getNativeTagFromPublicInstance(handle);
+    null != nativeTag && (handle = _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").getNodeFromPublicInstance(handle), null != handle ? nativeFabricUIManager.dispatchCommand(handle, command, args) : _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").UIManager.dispatchViewManagerCommand(nativeTag, command, args));
+  };
+  exports.findHostInstance_DEPRECATED = function (componentOrHandle) {
+    return null == componentOrHandle ? null : componentOrHandle.canonical && componentOrHandle.canonical.publicInstance ? componentOrHandle.canonical.publicInstance : componentOrHandle._nativeTag ? componentOrHandle : findHostInstance(componentOrHandle);
+  };
+  exports.findNodeHandle = function (componentOrHandle) {
+    if (null == componentOrHandle) return null;
+    if ("number" === typeof componentOrHandle) return componentOrHandle;
+    if (componentOrHandle._nativeTag) return componentOrHandle._nativeTag;
+    if (null != componentOrHandle.canonical && null != componentOrHandle.canonical.nativeTag) return componentOrHandle.canonical.nativeTag;
+    var nativeTag = _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").getNativeTagFromPublicInstance(componentOrHandle);
+    if (nativeTag) return nativeTag;
+    componentOrHandle = findHostInstance(componentOrHandle);
+    return null == componentOrHandle ? componentOrHandle : null != componentOrHandle._nativeTag ? componentOrHandle._nativeTag : _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").getNativeTagFromPublicInstance(componentOrHandle);
+  };
+  exports.getNodeFromInternalInstanceHandle = function (internalInstanceHandle) {
+    return internalInstanceHandle && internalInstanceHandle.stateNode && internalInstanceHandle.stateNode.node;
+  };
+  exports.getPublicInstanceFromInternalInstanceHandle = function (internalInstanceHandle) {
+    var instance = internalInstanceHandle.stateNode;
+    return null == instance ? null : 6 === internalInstanceHandle.tag ? (null == instance.publicInstance && (instance.publicInstance = _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").createPublicTextInstance(internalInstanceHandle)), instance.publicInstance) : getPublicInstance(internalInstanceHandle.stateNode);
+  };
+  exports.getPublicInstanceFromRootTag = function (rootTag) {
+    return (rootTag = roots.get(rootTag)) ? rootTag.containerInfo.publicInstance : null;
+  };
+  exports.isChildPublicInstance = function () {
+    throw Error("isChildPublicInstance() is not available in production.");
+  };
+  exports.render = function (element, containerTag, callback, concurrentRoot, options) {
+    var root = roots.get(containerTag);
+    if (!root) {
+      root = nativeOnUncaughtError;
+      var onCaughtError = nativeOnCaughtError,
+        onRecoverableError = defaultOnRecoverableError;
+      options && void 0 !== options.onUncaughtError && (root = options.onUncaughtError);
+      options && void 0 !== options.onCaughtError && (onCaughtError = options.onCaughtError);
+      options && void 0 !== options.onRecoverableError && (onRecoverableError = options.onRecoverableError);
+      options = {
+        publicInstance: _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").createPublicRootInstance(containerTag),
+        containerTag: containerTag
+      };
+      concurrentRoot = concurrentRoot ? 1 : 0;
+      root = new FiberRootNode(options, concurrentRoot, !1, "", root, onCaughtError, onRecoverableError, null);
+      concurrentRoot = createFiberImplClass(3, null, null, 1 === concurrentRoot ? 1 : 0);
+      root.current = concurrentRoot;
+      concurrentRoot.stateNode = root;
+      onCaughtError = createCache();
+      onCaughtError.refCount++;
+      root.pooledCache = onCaughtError;
+      onCaughtError.refCount++;
+      concurrentRoot.memoizedState = {
+        element: null,
+        isDehydrated: !1,
+        cache: onCaughtError
+      };
+      initializeUpdateQueue(concurrentRoot);
+      roots.set(containerTag, root);
+    }
+    updateContainer(element, root, null, callback);
+    a: if (element = root.current, element.child) switch (element.child.tag) {
+      case 27:
+      case 5:
+        element = getPublicInstance(element.child.stateNode);
+        break a;
+      default:
+        element = element.child.stateNode;
+    } else element = null;
+    return element;
+  };
+  exports.sendAccessibilityEvent = function (handle, eventType) {
+    var nativeTag = null != handle._nativeTag ? handle._nativeTag : _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").getNativeTagFromPublicInstance(handle);
+    null != nativeTag && (handle = _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").getNodeFromPublicInstance(handle), null != handle ? nativeFabricUIManager.sendAccessibilityEvent(handle, eventType) : _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").legacySendAccessibilityEvent(nativeTag, eventType));
+  };
+  exports.stopSurface = function (containerTag) {
+    var root = roots.get(containerTag);
+    root && updateContainer(null, root, null, function () {
+      root.containerInfo.publicInstance = null;
+      roots.delete(containerTag);
+    });
+  };
+  exports.unmountComponentAtNode = function (containerTag) {
+    this.stopSurface(containerTag);
+  };
+},519,[110,73,322,516],"../../node_modules/react-native/Libraries/Renderer/implementations/ReactFabric-prod.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.onCaughtError = onCaughtError;
+  exports.onRecoverableError = onRecoverableError;
+  exports.onUncaughtError = onUncaughtError;
+  var _ExceptionsManager = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/Core/ExceptionsManager"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function getExtendedError(errorValue, errorInfo) {
+    var error;
+    if (errorValue instanceof Error) {
+      error = errorValue;
+    } else if (typeof errorValue === 'string') {
+      error = new _ExceptionsManager.SyntheticError(errorValue);
+    } else {
+      error = new _ExceptionsManager.SyntheticError('Unspecified error');
+    }
+    try {
+      error.componentStack = errorInfo.componentStack;
+      error.isComponentError = true;
+    } catch (_unused) {}
+    return error;
+  }
+  function onUncaughtError(errorValue, errorInfo) {
+    var error = getExtendedError(errorValue, errorInfo);
+    _ExceptionsManager.default.handleException(error, true);
+  }
+  function onCaughtError(errorValue, errorInfo) {
+    var error = getExtendedError(errorValue, errorInfo);
+    _ExceptionsManager.default.handleException(error, false);
+  }
+  function onRecoverableError(errorValue, errorInfo) {
+    var error = getExtendedError(errorValue, errorInfo);
+    console.warn(error);
+  }
+},520,[174,73],"../../node_modules/react-native/src/private/renderer/errorhandling/ErrorHandlers.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var ReactNative;
+  if (__DEV__) {
+    ReactNative = _$$_REQUIRE(_dependencyMap[0], "../implementations/ReactNativeRenderer-dev");
+  } else {
+    ReactNative = _$$_REQUIRE(_dependencyMap[1], "../implementations/ReactNativeRenderer-prod");
+  }
+  var _default = exports.default = ReactNative;
+},521,[522,523],"../../node_modules/react-native/Libraries/Renderer/shims/ReactNative.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  /**
+   * 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.
+   *
+   * 
+   * @nolint
+   * @preventMunge
+   * @generated SignedSource<<cff8afb4533b426f7c26ccb0475bdf8c>>
+   *
+   * This file was sync'd from the facebook/react repository.
+   */
+
+  "use strict";
+
+  __DEV__ && function () {
+    function findHook(fiber, id) {
+      for (fiber = fiber.memoizedState; null !== fiber && 0 < id;) fiber = fiber.next, id--;
+      return fiber;
+    }
+    function copyWithSetImpl(obj, path, index, value) {
+      if (index >= path.length) return value;
+      var key = path[index],
+        updated = isArrayImpl(obj) ? obj.slice() : assign({}, obj);
+      updated[key] = copyWithSetImpl(obj[key], path, index + 1, value);
+      return updated;
+    }
+    function copyWithRename(obj, oldPath, newPath) {
+      if (oldPath.length !== newPath.length) console.warn("copyWithRename() expects paths of the same length");else {
+        for (var i = 0; i < newPath.length - 1; i++) if (oldPath[i] !== newPath[i]) {
+          console.warn("copyWithRename() expects paths to be the same except for the deepest key");
+          return;
+        }
+        return copyWithRenameImpl(obj, oldPath, newPath, 0);
+      }
+    }
+    function copyWithRenameImpl(obj, oldPath, newPath, index) {
+      var oldKey = oldPath[index],
+        updated = isArrayImpl(obj) ? obj.slice() : assign({}, obj);
+      index + 1 === oldPath.length ? (updated[newPath[index]] = updated[oldKey], isArrayImpl(updated) ? updated.splice(oldKey, 1) : delete updated[oldKey]) : updated[oldKey] = copyWithRenameImpl(obj[oldKey], oldPath, newPath, index + 1);
+      return updated;
+    }
+    function copyWithDeleteImpl(obj, path, index) {
+      var key = path[index],
+        updated = isArrayImpl(obj) ? obj.slice() : assign({}, obj);
+      if (index + 1 === path.length) return isArrayImpl(updated) ? updated.splice(key, 1) : delete updated[key], updated;
+      updated[key] = copyWithDeleteImpl(obj[key], path, index + 1);
+      return updated;
+    }
+    function shouldSuspendImpl() {
+      return !1;
+    }
+    function shouldErrorImpl() {
+      return null;
+    }
+    function createFiber(tag, pendingProps, key, mode) {
+      return new FiberNode(tag, pendingProps, key, mode);
+    }
+    function scheduleRoot(root, element) {
+      root.context === emptyContextObject && (0 === root.tag && flushPendingEffects(), updateContainerImpl(root.current, 2, element, root, null, null), flushSyncWork());
+    }
+    function scheduleRefresh(root, update) {
+      if (null !== resolveFamily) {
+        var staleFamilies = update.staleFamilies;
+        update = update.updatedFamilies;
+        flushPendingEffects();
+        scheduleFibersWithFamiliesRecursively(root.current, update, staleFamilies);
+        flushSyncWork();
+      }
+    }
+    function setRefreshHandler(handler) {
+      resolveFamily = handler;
+    }
+    function warnForMissingKey() {}
+    function warnInvalidHookAccess() {
+      console.error("Do not call Hooks inside useEffect(...), useMemo(...), or other built-in Hooks. You can only call Hooks at the top level of your React function. For more information, see https://react.dev/link/rules-of-hooks");
+    }
+    function warnInvalidContextAccess() {
+      console.error("Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo().");
+    }
+    function setToSortedString(set) {
+      var array = [];
+      set.forEach(function (value) {
+        array.push(value);
+      });
+      return array.sort().join(", ");
+    }
+    function traverseOwnerTreeUp(hierarchy, instance) {
+      hierarchy.unshift(instance);
+      instance = instance._debugOwner;
+      null != instance && "number" === typeof instance.tag && traverseOwnerTreeUp(hierarchy, instance);
+    }
+    function getHostProps(fiber) {
+      return (fiber = findCurrentHostFiber(fiber)) ? fiber.memoizedProps || emptyObject : emptyObject;
+    }
+    function createHierarchy(fiberHierarchy) {
+      return fiberHierarchy.map(function (fiber$jscomp$0) {
+        return {
+          name: getComponentNameFromType(fiber$jscomp$0.type),
+          getInspectorData: function getInspectorData() {
+            return {
+              props: getHostProps(fiber$jscomp$0),
+              measure: function measure(callback) {
+                var hostFiber = findCurrentHostFiber(fiber$jscomp$0);
+                if (hostFiber = null != hostFiber && null !== hostFiber.stateNode && hostFiber.stateNode.node) nativeFabricUIManager.measure(hostFiber, callback);else {
+                  hostFiber = ReactNativePrivateInterface.UIManager;
+                  var JSCompiler_temp_const = hostFiber.measure,
+                    JSCompiler_inline_result;
+                  a: {
+                    for (var fiber = fiber$jscomp$0; fiber;) {
+                      null !== fiber.stateNode && 5 === fiber.tag && (JSCompiler_inline_result = findNodeHandle(fiber.stateNode));
+                      if (JSCompiler_inline_result) break a;
+                      fiber = fiber.child;
+                    }
+                    JSCompiler_inline_result = null;
+                  }
+                  return JSCompiler_temp_const.call(hostFiber, JSCompiler_inline_result, callback);
+                }
+              }
+            };
+          }
+        };
+      });
+    }
+    function batchedUpdatesImpl(fn, bookkeeping) {
+      return fn(bookkeeping);
+    }
+    function disabledLog() {}
+    function disableLogs() {
+      if (0 === disabledDepth) {
+        prevLog = console.log;
+        prevInfo = console.info;
+        prevWarn = console.warn;
+        prevError = console.error;
+        prevGroup = console.group;
+        prevGroupCollapsed = console.groupCollapsed;
+        prevGroupEnd = console.groupEnd;
+        var props = {
+          configurable: !0,
+          enumerable: !0,
+          value: disabledLog,
+          writable: !0
+        };
+        Object.defineProperties(console, {
+          info: props,
+          log: props,
+          warn: props,
+          error: props,
+          group: props,
+          groupCollapsed: props,
+          groupEnd: props
+        });
+      }
+      disabledDepth++;
+    }
+    function reenableLogs() {
+      disabledDepth--;
+      if (0 === disabledDepth) {
+        var props = {
+          configurable: !0,
+          enumerable: !0,
+          writable: !0
+        };
+        Object.defineProperties(console, {
+          log: assign({}, props, {
+            value: prevLog
+          }),
+          info: assign({}, props, {
+            value: prevInfo
+          }),
+          warn: assign({}, props, {
+            value: prevWarn
+          }),
+          error: assign({}, props, {
+            value: prevError
+          }),
+          group: assign({}, props, {
+            value: prevGroup
+          }),
+          groupCollapsed: assign({}, props, {
+            value: prevGroupCollapsed
+          }),
+          groupEnd: assign({}, props, {
+            value: prevGroupEnd
+          })
+        });
+      }
+      0 > disabledDepth && console.error("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+    }
+    function describeBuiltInComponentFrame(name) {
+      if (void 0 === prefix) try {
+        throw Error();
+      } catch (x) {
+        var match = x.stack.trim().match(/\n( *(at )?)/);
+        prefix = match && match[1] || "";
+        suffix = -1 < x.stack.indexOf("\n    at") ? " (<anonymous>)" : -1 < x.stack.indexOf("@") ? "@unknown:0:0" : "";
+      }
+      return "\n" + prefix + name + suffix;
+    }
+    function describeNativeComponentFrame(fn, construct) {
+      if (!fn || reentry) return "";
+      var frame = componentFrameCache.get(fn);
+      if (void 0 !== frame) return frame;
+      reentry = !0;
+      frame = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var previousDispatcher = null;
+      previousDispatcher = ReactSharedInternals.H;
+      ReactSharedInternals.H = null;
+      disableLogs();
+      try {
+        var RunInRootFrame = {
+          DetermineComponentFrameRoot: function DetermineComponentFrameRoot() {
+            try {
+              if (construct) {
+                var Fake = function Fake() {
+                  throw Error();
+                };
+                Object.defineProperty(Fake.prototype, "props", {
+                  set: function set() {
+                    throw Error();
+                  }
+                });
+                if ("object" === typeof Reflect && Reflect.construct) {
+                  try {
+                    Reflect.construct(Fake, []);
+                  } catch (x) {
+                    var control = x;
+                  }
+                  Reflect.construct(fn, [], Fake);
+                } else {
+                  try {
+                    Fake.call();
+                  } catch (x$0) {
+                    control = x$0;
+                  }
+                  fn.call(Fake.prototype);
+                }
+              } else {
+                try {
+                  throw Error();
+                } catch (x$1) {
+                  control = x$1;
+                }
+                (Fake = fn()) && "function" === typeof Fake.catch && Fake.catch(function () {});
+              }
+            } catch (sample) {
+              if (sample && control && "string" === typeof sample.stack) return [sample.stack, control.stack];
+            }
+            return [null, null];
+          }
+        };
+        RunInRootFrame.DetermineComponentFrameRoot.displayName = "DetermineComponentFrameRoot";
+        var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, "name");
+        namePropDescriptor && namePropDescriptor.configurable && Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, "name", {
+          value: "DetermineComponentFrameRoot"
+        });
+        var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+          sampleStack = _RunInRootFrame$Deter[0],
+          controlStack = _RunInRootFrame$Deter[1];
+        if (sampleStack && controlStack) {
+          var sampleLines = sampleStack.split("\n"),
+            controlLines = controlStack.split("\n");
+          for (_RunInRootFrame$Deter = namePropDescriptor = 0; namePropDescriptor < sampleLines.length && !sampleLines[namePropDescriptor].includes("DetermineComponentFrameRoot");) namePropDescriptor++;
+          for (; _RunInRootFrame$Deter < controlLines.length && !controlLines[_RunInRootFrame$Deter].includes("DetermineComponentFrameRoot");) _RunInRootFrame$Deter++;
+          if (namePropDescriptor === sampleLines.length || _RunInRootFrame$Deter === controlLines.length) for (namePropDescriptor = sampleLines.length - 1, _RunInRootFrame$Deter = controlLines.length - 1; 1 <= namePropDescriptor && 0 <= _RunInRootFrame$Deter && sampleLines[namePropDescriptor] !== controlLines[_RunInRootFrame$Deter];) _RunInRootFrame$Deter--;
+          for (; 1 <= namePropDescriptor && 0 <= _RunInRootFrame$Deter; namePropDescriptor--, _RunInRootFrame$Deter--) if (sampleLines[namePropDescriptor] !== controlLines[_RunInRootFrame$Deter]) {
+            if (1 !== namePropDescriptor || 1 !== _RunInRootFrame$Deter) {
+              do if (namePropDescriptor--, _RunInRootFrame$Deter--, 0 > _RunInRootFrame$Deter || sampleLines[namePropDescriptor] !== controlLines[_RunInRootFrame$Deter]) {
+                var _frame = "\n" + sampleLines[namePropDescriptor].replace(" at new ", " at ");
+                fn.displayName && _frame.includes("<anonymous>") && (_frame = _frame.replace("<anonymous>", fn.displayName));
+                "function" === typeof fn && componentFrameCache.set(fn, _frame);
+                return _frame;
+              } while (1 <= namePropDescriptor && 0 <= _RunInRootFrame$Deter);
+            }
+            break;
+          }
+        }
+      } finally {
+        reentry = !1, ReactSharedInternals.H = previousDispatcher, reenableLogs(), Error.prepareStackTrace = frame;
+      }
+      sampleLines = (sampleLines = fn ? fn.displayName || fn.name : "") ? describeBuiltInComponentFrame(sampleLines) : "";
+      "function" === typeof fn && componentFrameCache.set(fn, sampleLines);
+      return sampleLines;
+    }
+    function formatOwnerStack(error) {
+      var prevPrepareStackTrace = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      error = error.stack;
+      Error.prepareStackTrace = prevPrepareStackTrace;
+      error.startsWith("Error: react-stack-top-frame\n") && (error = error.slice(29));
+      prevPrepareStackTrace = error.indexOf("\n");
+      -1 !== prevPrepareStackTrace && (error = error.slice(prevPrepareStackTrace + 1));
+      prevPrepareStackTrace = error.indexOf("react-stack-bottom-frame");
+      -1 !== prevPrepareStackTrace && (prevPrepareStackTrace = error.lastIndexOf("\n", prevPrepareStackTrace));
+      if (-1 !== prevPrepareStackTrace) error = error.slice(0, prevPrepareStackTrace);else return "";
+      return error;
+    }
+    function describeFiber(fiber) {
+      switch (fiber.tag) {
+        case 26:
+        case 27:
+        case 5:
+          return describeBuiltInComponentFrame(fiber.type);
+        case 16:
+          return describeBuiltInComponentFrame("Lazy");
+        case 13:
+          return describeBuiltInComponentFrame("Suspense");
+        case 19:
+          return describeBuiltInComponentFrame("SuspenseList");
+        case 0:
+        case 15:
+          return describeNativeComponentFrame(fiber.type, !1);
+        case 11:
+          return describeNativeComponentFrame(fiber.type.render, !1);
+        case 1:
+          return describeNativeComponentFrame(fiber.type, !0);
+        case 31:
+          return describeBuiltInComponentFrame("Activity");
+        default:
+          return "";
+      }
+    }
+    function getStackByFiberInDevAndProd(workInProgress) {
+      try {
+        var info = "";
+        do {
+          info += describeFiber(workInProgress);
+          var debugInfo = workInProgress._debugInfo;
+          if (debugInfo) for (var i = debugInfo.length - 1; 0 <= i; i--) {
+            var entry = debugInfo[i];
+            if ("string" === typeof entry.name) {
+              var JSCompiler_temp_const = info,
+                env = entry.env;
+              var JSCompiler_inline_result = describeBuiltInComponentFrame(entry.name + (env ? " [" + env + "]" : ""));
+              info = JSCompiler_temp_const + JSCompiler_inline_result;
+            }
+          }
+          workInProgress = workInProgress.return;
+        } while (workInProgress);
+        return info;
+      } catch (x) {
+        return "\nError generating stack: " + x.message + "\n" + x.stack;
+      }
+    }
+    function describeFunctionComponentFrameWithoutLineNumber(fn) {
+      return (fn = fn ? fn.displayName || fn.name : "") ? describeBuiltInComponentFrame(fn) : "";
+    }
+    function getIteratorFn(maybeIterable) {
+      if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
+      maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
+      return "function" === typeof maybeIterable ? maybeIterable : null;
+    }
+    function getComponentNameFromType(type) {
+      if (null == type) return null;
+      if ("function" === typeof type) return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+      if ("string" === typeof type) return type;
+      switch (type) {
+        case REACT_FRAGMENT_TYPE:
+          return "Fragment";
+        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_ACTIVITY_TYPE:
+          return "Activity";
+      }
+      if ("object" === typeof type) switch ("number" === typeof type.tag && console.error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), type.$$typeof) {
+        case REACT_PORTAL_TYPE:
+          return "Portal";
+        case REACT_CONTEXT_TYPE:
+          return (type.displayName || "Context") + ".Provider";
+        case REACT_CONSUMER_TYPE:
+          return (type._context.displayName || "Context") + ".Consumer";
+        case REACT_FORWARD_REF_TYPE:
+          var innerType = type.render;
+          type = type.displayName;
+          type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
+          return type;
+        case REACT_MEMO_TYPE:
+          return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
+        case REACT_LAZY_TYPE:
+          innerType = type._payload;
+          type = type._init;
+          try {
+            return getComponentNameFromType(type(innerType));
+          } catch (x) {}
+      }
+      return null;
+    }
+    function getComponentNameFromFiber(fiber) {
+      var type = fiber.type;
+      switch (fiber.tag) {
+        case 31:
+          return "Activity";
+        case 24:
+          return "Cache";
+        case 9:
+          return (type._context.displayName || "Context") + ".Consumer";
+        case 10:
+          return (type.displayName || "Context") + ".Provider";
+        case 18:
+          return "DehydratedFragment";
+        case 11:
+          return fiber = type.render, fiber = fiber.displayName || fiber.name || "", type.displayName || ("" !== fiber ? "ForwardRef(" + fiber + ")" : "ForwardRef");
+        case 7:
+          return "Fragment";
+        case 26:
+        case 27:
+        case 5:
+          return type;
+        case 4:
+          return "Portal";
+        case 3:
+          return "Root";
+        case 6:
+          return "Text";
+        case 16:
+          return getComponentNameFromType(type);
+        case 8:
+          return type === REACT_STRICT_MODE_TYPE ? "StrictMode" : "Mode";
+        case 22:
+          return "Offscreen";
+        case 12:
+          return "Profiler";
+        case 21:
+          return "Scope";
+        case 13:
+          return "Suspense";
+        case 19:
+          return "SuspenseList";
+        case 25:
+          return "TracingMarker";
+        case 30:
+        case 17:
+        case 28:
+        case 1:
+        case 0:
+        case 14:
+        case 15:
+          if ("function" === typeof type) return type.displayName || type.name || null;
+          if ("string" === typeof type) return type;
+          break;
+        case 29:
+          type = fiber._debugInfo;
+          if (null != type) for (var i = type.length - 1; 0 <= i; i--) if ("string" === typeof type[i].name) return type[i].name;
+          if (null !== fiber.return) return getComponentNameFromFiber(fiber.return);
+      }
+      return null;
+    }
+    function getCurrentFiberStackInDev() {
+      if (null === current) return "";
+      var workInProgress = current;
+      try {
+        var info = "";
+        6 === workInProgress.tag && (workInProgress = workInProgress.return);
+        switch (workInProgress.tag) {
+          case 26:
+          case 27:
+          case 5:
+            info += describeBuiltInComponentFrame(workInProgress.type);
+            break;
+          case 13:
+            info += describeBuiltInComponentFrame("Suspense");
+            break;
+          case 19:
+            info += describeBuiltInComponentFrame("SuspenseList");
+            break;
+          case 31:
+            info += describeBuiltInComponentFrame("Activity");
+            break;
+          case 30:
+          case 0:
+          case 15:
+          case 1:
+            workInProgress._debugOwner || "" !== info || (info += describeFunctionComponentFrameWithoutLineNumber(workInProgress.type));
+            break;
+          case 11:
+            workInProgress._debugOwner || "" !== info || (info += describeFunctionComponentFrameWithoutLineNumber(workInProgress.type.render));
+        }
+        for (; workInProgress;) if ("number" === typeof workInProgress.tag) {
+          var fiber = workInProgress;
+          workInProgress = fiber._debugOwner;
+          var debugStack = fiber._debugStack;
+          workInProgress && debugStack && ("string" !== typeof debugStack && (fiber._debugStack = debugStack = formatOwnerStack(debugStack)), "" !== debugStack && (info += "\n" + debugStack));
+        } else if (null != workInProgress.debugStack) {
+          var ownerStack = workInProgress.debugStack;
+          (workInProgress = workInProgress.owner) && ownerStack && (info += "\n" + formatOwnerStack(ownerStack));
+        } else break;
+        var JSCompiler_inline_result = info;
+      } catch (x) {
+        JSCompiler_inline_result = "\nError generating stack: " + x.message + "\n" + x.stack;
+      }
+      return JSCompiler_inline_result;
+    }
+    function runWithFiberInDEV(fiber, callback, arg0, arg1, arg2, arg3, arg4) {
+      var previousFiber = current;
+      setCurrentFiber(fiber);
+      try {
+        return null !== fiber && fiber._debugTask ? fiber._debugTask.run(callback.bind(null, arg0, arg1, arg2, arg3, arg4)) : callback(arg0, arg1, arg2, arg3, arg4);
+      } finally {
+        setCurrentFiber(previousFiber);
+      }
+      throw Error("runWithFiberInDEV should never be called in production. This is a bug in React.");
+    }
+    function setCurrentFiber(fiber) {
+      ReactSharedInternals.getCurrentStack = null === fiber ? null : getCurrentFiberStackInDev;
+      isRendering = !1;
+      current = fiber;
+    }
+    function validateEventDispatches(event) {
+      var dispatchListeners = event._dispatchListeners,
+        dispatchInstances = event._dispatchInstances;
+      dispatchListeners = (event = isArrayImpl(dispatchListeners)) ? dispatchListeners.length : dispatchListeners ? 1 : 0;
+      var instancesIsArr = isArrayImpl(dispatchInstances);
+      dispatchInstances = instancesIsArr ? dispatchInstances.length : dispatchInstances ? 1 : 0;
+      instancesIsArr === event && dispatchInstances === dispatchListeners || console.error("EventPluginUtils: Invalid `event`.");
+    }
+    function executeDispatch(event, listener, inst) {
+      event.currentTarget = getNodeFromInstance(inst);
+      try {
+        listener(event);
+      } catch (error) {
+        hasError || (hasError = !0, caughtError = error);
+      }
+      event.currentTarget = null;
+    }
+    function executeDirectDispatch(event) {
+      validateEventDispatches(event);
+      var dispatchListener = event._dispatchListeners,
+        dispatchInstance = event._dispatchInstances;
+      if (isArrayImpl(dispatchListener)) throw Error("Invalid `event`.");
+      event.currentTarget = dispatchListener ? getNodeFromInstance(dispatchInstance) : null;
+      dispatchListener = dispatchListener ? dispatchListener(event) : null;
+      event.currentTarget = null;
+      event._dispatchListeners = null;
+      event._dispatchInstances = null;
+      return dispatchListener;
+    }
+    function functionThatReturnsTrue() {
+      return !0;
+    }
+    function functionThatReturnsFalse() {
+      return !1;
+    }
+    function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
+      delete this.nativeEvent;
+      delete this.preventDefault;
+      delete this.stopPropagation;
+      delete this.isDefaultPrevented;
+      delete this.isPropagationStopped;
+      this.dispatchConfig = dispatchConfig;
+      this._targetInst = targetInst;
+      this.nativeEvent = nativeEvent;
+      this._dispatchInstances = this._dispatchListeners = null;
+      dispatchConfig = this.constructor.Interface;
+      for (var propName in dispatchConfig) dispatchConfig.hasOwnProperty(propName) && (delete this[propName], (targetInst = dispatchConfig[propName]) ? this[propName] = targetInst(nativeEvent) : "target" === propName ? this.target = nativeEventTarget : this[propName] = nativeEvent[propName]);
+      this.isDefaultPrevented = (null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : !1 === nativeEvent.returnValue) ? functionThatReturnsTrue : functionThatReturnsFalse;
+      this.isPropagationStopped = functionThatReturnsFalse;
+      return this;
+    }
+    function getPooledWarningPropertyDefinition(propName, getVal) {
+      function warn(action, result) {
+        console.error("This synthetic event is reused for performance reasons. If you're seeing this, you're %s `%s` on a released/nullified synthetic event. %s. If you must keep the original synthetic event around, use event.persist(). See https://react.dev/link/event-pooling for more information.", action, propName, result);
+      }
+      var isFunction = "function" === typeof getVal;
+      return {
+        configurable: !0,
+        set: function set(val) {
+          warn(isFunction ? "setting the method" : "setting the property", "This is effectively a no-op");
+          return val;
+        },
+        get: function get() {
+          warn(isFunction ? "accessing the method" : "accessing the property", isFunction ? "This is a no-op function" : "This is set to null");
+          return getVal;
+        }
+      };
+    }
+    function createOrGetPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
+      if (this.eventPool.length) {
+        var instance = this.eventPool.pop();
+        this.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst);
+        return instance;
+      }
+      return new this(dispatchConfig, targetInst, nativeEvent, nativeInst);
+    }
+    function releasePooledEvent(event) {
+      if (!(event instanceof this)) throw Error("Trying to release an event instance into a pool of a different type.");
+      event.destructor();
+      10 > this.eventPool.length && this.eventPool.push(event);
+    }
+    function addEventPoolingTo(EventConstructor) {
+      EventConstructor.getPooled = createOrGetPooledEvent;
+      EventConstructor.eventPool = [];
+      EventConstructor.release = releasePooledEvent;
+    }
+    function isStartish(topLevelType) {
+      return "topTouchStart" === topLevelType;
+    }
+    function isMoveish(topLevelType) {
+      return "topTouchMove" === topLevelType;
+    }
+    function timestampForTouch(touch) {
+      return touch.timeStamp || touch.timestamp;
+    }
+    function getTouchIdentifier(_ref) {
+      _ref = _ref.identifier;
+      if (null == _ref) throw Error("Touch object is missing identifier.");
+      20 < _ref && console.error("Touch identifier %s is greater than maximum supported %s which causes performance issues backfilling array locations for all of the indices.", _ref, 20);
+      return _ref;
+    }
+    function recordTouchStart(touch) {
+      var identifier = getTouchIdentifier(touch),
+        touchRecord = touchBank[identifier];
+      touchRecord ? (touchRecord.touchActive = !0, touchRecord.startPageX = touch.pageX, touchRecord.startPageY = touch.pageY, touchRecord.startTimeStamp = timestampForTouch(touch), touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), touchRecord.previousPageX = touch.pageX, touchRecord.previousPageY = touch.pageY, touchRecord.previousTimeStamp = timestampForTouch(touch)) : (touchRecord = {
+        touchActive: !0,
+        startPageX: touch.pageX,
+        startPageY: touch.pageY,
+        startTimeStamp: timestampForTouch(touch),
+        currentPageX: touch.pageX,
+        currentPageY: touch.pageY,
+        currentTimeStamp: timestampForTouch(touch),
+        previousPageX: touch.pageX,
+        previousPageY: touch.pageY,
+        previousTimeStamp: timestampForTouch(touch)
+      }, touchBank[identifier] = touchRecord);
+      touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+    }
+    function recordTouchMove(touch) {
+      var touchRecord = touchBank[getTouchIdentifier(touch)];
+      touchRecord ? (touchRecord.touchActive = !0, touchRecord.previousPageX = touchRecord.currentPageX, touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.warn("Cannot record touch move without a touch start.\nTouch Move: %s\nTouch Bank: %s", printTouch(touch), printTouchBank());
+    }
+    function recordTouchEnd(touch) {
+      var touchRecord = touchBank[getTouchIdentifier(touch)];
+      touchRecord ? (touchRecord.touchActive = !1, touchRecord.previousPageX = touchRecord.currentPageX, touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.warn("Cannot record touch end without a touch start.\nTouch End: %s\nTouch Bank: %s", printTouch(touch), printTouchBank());
+    }
+    function printTouch(touch) {
+      return JSON.stringify({
+        identifier: touch.identifier,
+        pageX: touch.pageX,
+        pageY: touch.pageY,
+        timestamp: timestampForTouch(touch)
+      });
+    }
+    function printTouchBank() {
+      var printed = JSON.stringify(touchBank.slice(0, 20));
+      20 < touchBank.length && (printed += " (original size: " + touchBank.length + ")");
+      return printed;
+    }
+    function accumulate(current, next) {
+      if (null == next) throw Error("Accumulated items must not be null or undefined.");
+      return null == current ? next : isArrayImpl(current) ? current.concat(next) : isArrayImpl(next) ? [current].concat(next) : [current, next];
+    }
+    function accumulateInto(current, next) {
+      if (null == next) throw Error("Accumulated items must not be null or undefined.");
+      if (null == current) return next;
+      if (isArrayImpl(current)) {
+        if (isArrayImpl(next)) return current.push.apply(current, next), current;
+        current.push(next);
+        return current;
+      }
+      return isArrayImpl(next) ? [current].concat(next) : [current, next];
+    }
+    function forEachAccumulated(arr, cb, scope) {
+      Array.isArray(arr) ? arr.forEach(cb, scope) : arr && cb.call(scope, arr);
+    }
+    function changeResponder(nextResponderInst, blockHostResponder) {
+      var oldResponderInst = responderInst;
+      responderInst = nextResponderInst;
+      if (null !== ResponderEventPlugin.GlobalResponderHandler) ResponderEventPlugin.GlobalResponderHandler.onChange(oldResponderInst, nextResponderInst, blockHostResponder);
+    }
+    function getParent$1(inst) {
+      do inst = inst.return; while (inst && 5 !== inst.tag);
+      return inst ? inst : null;
+    }
+    function traverseTwoPhase$1(inst, fn, arg) {
+      for (var path = []; inst;) path.push(inst), inst = getParent$1(inst);
+      for (inst = path.length; 0 < inst--;) fn(path[inst], "captured", arg);
+      for (inst = 0; inst < path.length; inst++) fn(path[inst], "bubbled", arg);
+    }
+    function getListener$1(inst, registrationName) {
+      inst = inst.stateNode;
+      if (null === inst) return null;
+      inst = getFiberCurrentPropsFromNode$1(inst);
+      if (null === inst) return null;
+      if ((inst = inst[registrationName]) && "function" !== typeof inst) throw Error("Expected `" + registrationName + "` listener to be a function, instead got a value of `" + typeof inst + "` type.");
+      return inst;
+    }
+    function accumulateDirectionalDispatches$1(inst, phase, event) {
+      inst || console.error("Dispatching inst must not be null");
+      if (phase = getListener$1(inst, event.dispatchConfig.phasedRegistrationNames[phase])) event._dispatchListeners = accumulateInto(event._dispatchListeners, phase), event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
+    }
+    function accumulateDirectDispatchesSingle$1(event) {
+      if (event && event.dispatchConfig.registrationName) {
+        var inst = event._targetInst;
+        if (inst && event && event.dispatchConfig.registrationName) {
+          var listener = getListener$1(inst, event.dispatchConfig.registrationName);
+          listener && (event._dispatchListeners = accumulateInto(event._dispatchListeners, listener), event._dispatchInstances = accumulateInto(event._dispatchInstances, inst));
+        }
+      }
+    }
+    function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
+      if (event && event.dispatchConfig.phasedRegistrationNames) {
+        var targetInst = event._targetInst;
+        targetInst = targetInst ? getParent$1(targetInst) : null;
+        traverseTwoPhase$1(targetInst, accumulateDirectionalDispatches$1, event);
+      }
+    }
+    function accumulateTwoPhaseDispatchesSingle$1(event) {
+      event && event.dispatchConfig.phasedRegistrationNames && traverseTwoPhase$1(event._targetInst, accumulateDirectionalDispatches$1, event);
+    }
+    function recomputePluginOrdering() {
+      if (eventPluginOrder) for (var pluginName in namesToPlugins) {
+        var pluginModule = namesToPlugins[pluginName],
+          pluginIndex = eventPluginOrder.indexOf(pluginName);
+        if (-1 >= pluginIndex) throw Error("EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `" + (pluginName + "`."));
+        if (!plugins[pluginIndex]) {
+          if (!pluginModule.extractEvents) throw Error("EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `" + (pluginName + "` does not."));
+          plugins[pluginIndex] = pluginModule;
+          pluginIndex = pluginModule.eventTypes;
+          for (var eventName in pluginIndex) {
+            var JSCompiler_inline_result = void 0;
+            var dispatchConfig = pluginIndex[eventName],
+              pluginModule$jscomp$0 = pluginModule,
+              eventName$jscomp$0 = eventName;
+            if (eventNameDispatchConfigs.hasOwnProperty(eventName$jscomp$0)) throw Error("EventPluginRegistry: More than one plugin attempted to publish the same event name, `" + (eventName$jscomp$0 + "`."));
+            eventNameDispatchConfigs[eventName$jscomp$0] = dispatchConfig;
+            if (eventName$jscomp$0 = dispatchConfig.phasedRegistrationNames) {
+              for (JSCompiler_inline_result in eventName$jscomp$0) eventName$jscomp$0.hasOwnProperty(JSCompiler_inline_result) && publishRegistrationName(eventName$jscomp$0[JSCompiler_inline_result], pluginModule$jscomp$0);
+              JSCompiler_inline_result = !0;
+            } else dispatchConfig.registrationName ? (publishRegistrationName(dispatchConfig.registrationName, pluginModule$jscomp$0), JSCompiler_inline_result = !0) : JSCompiler_inline_result = !1;
+            if (!JSCompiler_inline_result) throw Error("EventPluginRegistry: Failed to publish event `" + eventName + "` for plugin `" + pluginName + "`.");
+          }
+        }
+      }
+    }
+    function publishRegistrationName(registrationName, pluginModule) {
+      if (registrationNameModules[registrationName]) throw Error("EventPluginRegistry: More than one plugin attempted to publish the same registration name, `" + (registrationName + "`."));
+      registrationNameModules[registrationName] = pluginModule;
+      registrationName.toLowerCase();
+    }
+    function getListener(inst, registrationName) {
+      inst = inst.stateNode;
+      if (null === inst) return null;
+      inst = getFiberCurrentPropsFromNode$1(inst);
+      if (null === inst) return null;
+      if ((inst = inst[registrationName]) && "function" !== typeof inst) throw Error("Expected `" + registrationName + "` listener to be a function, instead got a value of `" + typeof inst + "` type.");
+      return inst;
+    }
+    function accumulateDirectionalDispatches(inst, phase, event) {
+      inst || console.error("Dispatching inst must not be null");
+      if (phase = getListener(inst, event.dispatchConfig.phasedRegistrationNames[phase])) event._dispatchListeners = accumulateInto(event._dispatchListeners, phase), event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
+    }
+    function traverseTwoPhase(inst, fn, arg, skipBubbling) {
+      for (var path = []; inst;) {
+        path.push(inst);
+        do inst = inst.return; while (inst && 5 !== inst.tag);
+        inst = inst ? inst : null;
+      }
+      for (inst = path.length; 0 < inst--;) fn(path[inst], "captured", arg);
+      if (skipBubbling) fn(path[0], "bubbled", arg);else for (inst = 0; inst < path.length; inst++) fn(path[inst], "bubbled", arg);
+    }
+    function accumulateTwoPhaseDispatchesSingle(event) {
+      event && event.dispatchConfig.phasedRegistrationNames && traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event, !1);
+    }
+    function accumulateDirectDispatchesSingle(event) {
+      if (event && event.dispatchConfig.registrationName) {
+        var inst = event._targetInst;
+        if (inst && event && event.dispatchConfig.registrationName) {
+          var listener = getListener(inst, event.dispatchConfig.registrationName);
+          listener && (event._dispatchListeners = accumulateInto(event._dispatchListeners, listener), event._dispatchInstances = accumulateInto(event._dispatchInstances, inst));
+        }
+      }
+    }
+    function getInstanceFromTag(tag) {
+      return instanceCache.get(tag) || null;
+    }
+    function batchedUpdates$1(fn, bookkeeping) {
+      if (isInsideEventHandler) return fn(bookkeeping);
+      isInsideEventHandler = !0;
+      try {
+        return batchedUpdatesImpl(fn, bookkeeping);
+      } finally {
+        isInsideEventHandler = !1;
+      }
+    }
+    function executeDispatchesAndReleaseTopLevel(e) {
+      if (e) {
+        var dispatchListeners = e._dispatchListeners,
+          dispatchInstances = e._dispatchInstances;
+        validateEventDispatches(e);
+        if (isArrayImpl(dispatchListeners)) for (var i = 0; i < dispatchListeners.length && !e.isPropagationStopped(); i++) {
+          var listener = dispatchListeners[i],
+            instance = dispatchInstances[i];
+          null !== instance ? runWithFiberInDEV(instance, executeDispatch, e, listener, instance) : executeDispatch(e, listener, instance);
+        } else dispatchListeners && (null !== dispatchInstances ? runWithFiberInDEV(dispatchInstances, executeDispatch, e, dispatchListeners, dispatchInstances) : executeDispatch(e, dispatchListeners, dispatchInstances));
+        e._dispatchListeners = null;
+        e._dispatchInstances = null;
+        e.isPersistent() || e.constructor.release(e);
+      }
+    }
+    function _receiveRootNodeIDEvent(rootNodeID, topLevelType, nativeEventParam) {
+      var nativeEvent = nativeEventParam || EMPTY_NATIVE_EVENT,
+        inst = getInstanceFromTag(rootNodeID),
+        target = null;
+      null != inst && (target = inst.stateNode);
+      batchedUpdates$1(function () {
+        var events = target;
+        for (var events$jscomp$0 = null, legacyPlugins = plugins, i = 0; i < legacyPlugins.length; i++) {
+          var possiblePlugin = legacyPlugins[i];
+          possiblePlugin && (possiblePlugin = possiblePlugin.extractEvents(topLevelType, inst, nativeEvent, events)) && (events$jscomp$0 = accumulateInto(events$jscomp$0, possiblePlugin));
+        }
+        events = events$jscomp$0;
+        null !== events && (eventQueue = accumulateInto(eventQueue, events));
+        events = eventQueue;
+        eventQueue = null;
+        if (events) {
+          forEachAccumulated(events, executeDispatchesAndReleaseTopLevel);
+          if (eventQueue) throw Error("processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented.");
+          if (hasError) throw events = caughtError, hasError = !1, caughtError = null, events;
+        }
+      });
+    }
+    function getNearestMountedFiber(fiber) {
+      var node = fiber,
+        nearestMounted = fiber;
+      if (fiber.alternate) for (; node.return;) node = node.return;else {
+        fiber = node;
+        do node = fiber, 0 !== (node.flags & 4098) && (nearestMounted = node.return), fiber = node.return; while (fiber);
+      }
+      return 3 === node.tag ? nearestMounted : null;
+    }
+    function assertIsMounted(fiber) {
+      if (getNearestMountedFiber(fiber) !== fiber) throw Error("Unable to find node on an unmounted component.");
+    }
+    function findCurrentFiberUsingSlowPath(fiber) {
+      var alternate = fiber.alternate;
+      if (!alternate) {
+        alternate = getNearestMountedFiber(fiber);
+        if (null === alternate) throw Error("Unable to find node on an unmounted component.");
+        return alternate !== fiber ? null : fiber;
+      }
+      for (var a = fiber, b = alternate;;) {
+        var parentA = a.return;
+        if (null === parentA) break;
+        var parentB = parentA.alternate;
+        if (null === parentB) {
+          b = parentA.return;
+          if (null !== b) {
+            a = b;
+            continue;
+          }
+          break;
+        }
+        if (parentA.child === parentB.child) {
+          for (parentB = parentA.child; parentB;) {
+            if (parentB === a) return assertIsMounted(parentA), fiber;
+            if (parentB === b) return assertIsMounted(parentA), alternate;
+            parentB = parentB.sibling;
+          }
+          throw Error("Unable to find node on an unmounted component.");
+        }
+        if (a.return !== b.return) a = parentA, b = parentB;else {
+          for (var didFindChild = !1, _child = parentA.child; _child;) {
+            if (_child === a) {
+              didFindChild = !0;
+              a = parentA;
+              b = parentB;
+              break;
+            }
+            if (_child === b) {
+              didFindChild = !0;
+              b = parentA;
+              a = parentB;
+              break;
+            }
+            _child = _child.sibling;
+          }
+          if (!didFindChild) {
+            for (_child = parentB.child; _child;) {
+              if (_child === a) {
+                didFindChild = !0;
+                a = parentB;
+                b = parentA;
+                break;
+              }
+              if (_child === b) {
+                didFindChild = !0;
+                b = parentB;
+                a = parentA;
+                break;
+              }
+              _child = _child.sibling;
+            }
+            if (!didFindChild) throw 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 Error("Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue.");
+      }
+      if (3 !== a.tag) throw Error("Unable to find node on an unmounted component.");
+      return a.stateNode.current === a ? fiber : alternate;
+    }
+    function findCurrentHostFiber(parent) {
+      parent = findCurrentFiberUsingSlowPath(parent);
+      return null !== parent ? findCurrentHostFiberImpl(parent) : null;
+    }
+    function findCurrentHostFiberImpl(node) {
+      var tag = node.tag;
+      if (5 === tag || 26 === tag || 27 === tag || 6 === tag) return node;
+      for (node = node.child; null !== node;) {
+        tag = findCurrentHostFiberImpl(node);
+        if (null !== tag) return tag;
+        node = node.sibling;
+      }
+      return null;
+    }
+    function doesFiberContain(parentFiber, childFiber) {
+      for (var parentFiberAlternate = parentFiber.alternate; null !== childFiber;) {
+        if (childFiber === parentFiber || childFiber === parentFiberAlternate) return !0;
+        childFiber = childFiber.return;
+      }
+      return !1;
+    }
+    function defaultDiffer(prevProp, nextProp) {
+      return "object" !== typeof nextProp || null === nextProp ? !0 : ReactNativePrivateInterface.deepDiffer(prevProp, nextProp, deepDifferOptions);
+    }
+    function restoreDeletedValuesInNestedArray(updatePayload, node, validAttributes) {
+      if (isArrayImpl(node)) for (var i = node.length; i-- && 0 < removedKeyCount;) restoreDeletedValuesInNestedArray(updatePayload, node[i], validAttributes);else if (node && 0 < removedKeyCount) for (i in removedKeys) if (removedKeys[i]) {
+        var nextProp = node[i];
+        if (void 0 !== nextProp) {
+          var attributeConfig = validAttributes[i];
+          if (attributeConfig) {
+            "function" === typeof nextProp && (nextProp = !0);
+            "undefined" === typeof nextProp && (nextProp = null);
+            if ("object" !== typeof attributeConfig) updatePayload[i] = nextProp;else if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) nextProp = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, updatePayload[i] = nextProp;
+            removedKeys[i] = !1;
+            removedKeyCount--;
+          }
+        }
+      }
+    }
+    function diffNestedProperty(updatePayload, prevProp, nextProp, validAttributes) {
+      if (!updatePayload && prevProp === nextProp) return updatePayload;
+      if (!prevProp || !nextProp) return nextProp ? addNestedProperty(updatePayload, nextProp, validAttributes) : prevProp ? clearNestedProperty(updatePayload, prevProp, validAttributes) : updatePayload;
+      if (!isArrayImpl(prevProp) && !isArrayImpl(nextProp)) return diffProperties(updatePayload, prevProp, nextProp, validAttributes);
+      if (isArrayImpl(prevProp) && isArrayImpl(nextProp)) {
+        var minLength = prevProp.length < nextProp.length ? prevProp.length : nextProp.length,
+          i;
+        for (i = 0; i < minLength; i++) updatePayload = diffNestedProperty(updatePayload, prevProp[i], nextProp[i], validAttributes);
+        for (; i < prevProp.length; i++) updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
+        for (; i < nextProp.length; i++) updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
+        return updatePayload;
+      }
+      return isArrayImpl(prevProp) ? diffProperties(updatePayload, ReactNativePrivateInterface.flattenStyle(prevProp), nextProp, validAttributes) : diffProperties(updatePayload, prevProp, ReactNativePrivateInterface.flattenStyle(nextProp), validAttributes);
+    }
+    function addNestedProperty(updatePayload, nextProp, validAttributes) {
+      if (!nextProp) return updatePayload;
+      if (!isArrayImpl(nextProp)) return diffProperties(updatePayload, emptyObject$1, nextProp, validAttributes);
+      for (var i = 0; i < nextProp.length; i++) updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
+      return updatePayload;
+    }
+    function clearNestedProperty(updatePayload, prevProp, validAttributes) {
+      if (!prevProp) return updatePayload;
+      if (!isArrayImpl(prevProp)) return diffProperties(updatePayload, prevProp, emptyObject$1, validAttributes);
+      for (var i = 0; i < prevProp.length; i++) updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
+      return updatePayload;
+    }
+    function diffProperties(updatePayload, prevProps, nextProps, validAttributes) {
+      var attributeConfig, propKey;
+      for (propKey in nextProps) if (attributeConfig = validAttributes[propKey]) {
+        var prevProp = prevProps[propKey];
+        var nextProp = nextProps[propKey];
+        "function" === typeof nextProp && (nextProp = !0, "function" === typeof prevProp && (prevProp = !0));
+        "undefined" === typeof nextProp && (nextProp = null, "undefined" === typeof prevProp && (prevProp = null));
+        removedKeys && (removedKeys[propKey] = !1);
+        if (updatePayload && void 0 !== updatePayload[propKey]) {
+          if ("object" !== typeof attributeConfig) updatePayload[propKey] = nextProp;else {
+            if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) attributeConfig = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, updatePayload[propKey] = attributeConfig;
+          }
+        } else if (prevProp !== nextProp) if ("object" !== typeof attributeConfig) defaultDiffer(prevProp, nextProp) && ((updatePayload || (updatePayload = {}))[propKey] = nextProp);else if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) {
+          if (void 0 === prevProp || ("function" === typeof attributeConfig.diff ? attributeConfig.diff(prevProp, nextProp) : defaultDiffer(prevProp, nextProp))) attributeConfig = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, (updatePayload || (updatePayload = {}))[propKey] = attributeConfig;
+        } else removedKeys = null, removedKeyCount = 0, updatePayload = diffNestedProperty(updatePayload, prevProp, nextProp, attributeConfig), 0 < removedKeyCount && updatePayload && (restoreDeletedValuesInNestedArray(updatePayload, nextProp, attributeConfig), removedKeys = null);
+      }
+      for (var _propKey in prevProps) void 0 === nextProps[_propKey] && (!(attributeConfig = validAttributes[_propKey]) || updatePayload && void 0 !== updatePayload[_propKey] || (prevProp = prevProps[_propKey], void 0 !== prevProp && ("object" !== typeof attributeConfig || "function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process ? ((updatePayload || (updatePayload = {}))[_propKey] = null, removedKeys || (removedKeys = {}), removedKeys[_propKey] || (removedKeys[_propKey] = !0, removedKeyCount++)) : updatePayload = clearNestedProperty(updatePayload, prevProp, attributeConfig))));
+      return updatePayload;
+    }
+    function mountSafeCallback_NOT_REALLY_SAFE(context, callback) {
+      return function () {
+        if (callback && ("boolean" !== typeof context.__isMounted || context.__isMounted)) return callback.apply(context, arguments);
+      };
+    }
+    function injectInternals(internals) {
+      if ("undefined" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) return !1;
+      var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+      if (hook.isDisabled) return !0;
+      if (!hook.supportsFiber) return console.error("The installed version of React DevTools is too old and will not work with the current version of React. Please update React DevTools. https://react.dev/link/react-devtools"), !0;
+      try {
+        rendererID = hook.inject(internals), injectedHook = hook;
+      } catch (err) {
+        console.error("React instrumentation encountered an error: %s.", err);
+      }
+      return hook.checkDCE ? !0 : !1;
+    }
+    function setIsStrictModeForDevtools(newIsStrictMode) {
+      "function" === typeof log$1 && unstable_setDisableYieldValue(newIsStrictMode);
+      if (injectedHook && "function" === typeof injectedHook.setStrictMode) try {
+        injectedHook.setStrictMode(rendererID, newIsStrictMode);
+      } catch (err) {
+        hasLoggedError || (hasLoggedError = !0, console.error("React instrumentation encountered an error: %s", err));
+      }
+    }
+    function injectProfilingHooks(profilingHooks) {
+      injectedProfilingHooks = profilingHooks;
+    }
+    function markCommitStopped() {
+      null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markCommitStopped && injectedProfilingHooks.markCommitStopped();
+    }
+    function markComponentRenderStarted(fiber) {
+      null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markComponentRenderStarted && injectedProfilingHooks.markComponentRenderStarted(fiber);
+    }
+    function markComponentRenderStopped() {
+      null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markComponentRenderStopped && injectedProfilingHooks.markComponentRenderStopped();
+    }
+    function markRenderStarted(lanes) {
+      null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markRenderStarted && injectedProfilingHooks.markRenderStarted(lanes);
+    }
+    function markRenderStopped() {
+      null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markRenderStopped && injectedProfilingHooks.markRenderStopped();
+    }
+    function markStateUpdateScheduled(fiber, lane) {
+      null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markStateUpdateScheduled && injectedProfilingHooks.markStateUpdateScheduled(fiber, lane);
+    }
+    function clz32Fallback(x) {
+      x >>>= 0;
+      return 0 === x ? 32 : 31 - (log(x) / LN2 | 0) | 0;
+    }
+    function getLabelForLane(lane) {
+      if (lane & 1) return "SyncHydrationLane";
+      if (lane & 2) return "Sync";
+      if (lane & 4) return "InputContinuousHydration";
+      if (lane & 8) return "InputContinuous";
+      if (lane & 16) return "DefaultHydration";
+      if (lane & 32) return "Default";
+      if (lane & 128) return "TransitionHydration";
+      if (lane & 4194048) return "Transition";
+      if (lane & 62914560) return "Retry";
+      if (lane & 67108864) return "SelectiveHydration";
+      if (lane & 134217728) return "IdleHydration";
+      if (lane & 268435456) return "Idle";
+      if (lane & 536870912) return "Offscreen";
+      if (lane & 1073741824) return "Deferred";
+    }
+    function getHighestPriorityLanes(lanes) {
+      var pendingSyncLanes = lanes & 42;
+      if (0 !== pendingSyncLanes) return pendingSyncLanes;
+      switch (lanes & -lanes) {
+        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:
+          return 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 lanes & 4194048;
+        case 4194304:
+        case 8388608:
+        case 16777216:
+        case 33554432:
+          return lanes & 62914560;
+        case 67108864:
+          return 67108864;
+        case 134217728:
+          return 134217728;
+        case 268435456:
+          return 268435456;
+        case 536870912:
+          return 536870912;
+        case 1073741824:
+          return 0;
+        default:
+          return console.error("Should have found matching lanes. This is a bug in React."), lanes;
+      }
+    }
+    function getNextLanes(root, wipLanes, rootHasPendingCommit) {
+      var pendingLanes = root.pendingLanes;
+      if (0 === pendingLanes) return 0;
+      var nextLanes = 0,
+        suspendedLanes = root.suspendedLanes,
+        pingedLanes = root.pingedLanes;
+      root = root.warmLanes;
+      var nonIdlePendingLanes = pendingLanes & 134217727;
+      0 !== nonIdlePendingLanes ? (pendingLanes = nonIdlePendingLanes & ~suspendedLanes, 0 !== pendingLanes ? nextLanes = getHighestPriorityLanes(pendingLanes) : (pingedLanes &= nonIdlePendingLanes, 0 !== pingedLanes ? nextLanes = getHighestPriorityLanes(pingedLanes) : rootHasPendingCommit || (rootHasPendingCommit = nonIdlePendingLanes & ~root, 0 !== rootHasPendingCommit && (nextLanes = getHighestPriorityLanes(rootHasPendingCommit))))) : (nonIdlePendingLanes = pendingLanes & ~suspendedLanes, 0 !== nonIdlePendingLanes ? nextLanes = getHighestPriorityLanes(nonIdlePendingLanes) : 0 !== pingedLanes ? nextLanes = getHighestPriorityLanes(pingedLanes) : rootHasPendingCommit || (rootHasPendingCommit = pendingLanes & ~root, 0 !== rootHasPendingCommit && (nextLanes = getHighestPriorityLanes(rootHasPendingCommit))));
+      return 0 === nextLanes ? 0 : 0 !== wipLanes && wipLanes !== nextLanes && 0 === (wipLanes & suspendedLanes) && (suspendedLanes = nextLanes & -nextLanes, rootHasPendingCommit = wipLanes & -wipLanes, suspendedLanes >= rootHasPendingCommit || 32 === suspendedLanes && 0 !== (rootHasPendingCommit & 4194048)) ? wipLanes : nextLanes;
+    }
+    function checkIfRootIsPrerendering(root, renderLanes) {
+      return 0 === (root.pendingLanes & ~(root.suspendedLanes & ~root.pingedLanes) & renderLanes);
+    }
+    function computeExpirationTime(lane, currentTime) {
+      switch (lane) {
+        case 1:
+        case 2:
+        case 4:
+        case 8:
+        case 64:
+          return currentTime + 250;
+        case 16:
+        case 32:
+        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 currentTime + 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 console.error("Should have found matching lanes. This is a bug in React."), -1;
+      }
+    }
+    function claimNextTransitionLane() {
+      var lane = nextTransitionLane;
+      nextTransitionLane <<= 1;
+      0 === (nextTransitionLane & 4194048) && (nextTransitionLane = 256);
+      return lane;
+    }
+    function claimNextRetryLane() {
+      var lane = nextRetryLane;
+      nextRetryLane <<= 1;
+      0 === (nextRetryLane & 62914560) && (nextRetryLane = 4194304);
+      return lane;
+    }
+    function createLaneMap(initial) {
+      for (var laneMap = [], i = 0; 31 > i; i++) laneMap.push(initial);
+      return laneMap;
+    }
+    function markRootUpdated$1(root, updateLane) {
+      root.pendingLanes |= updateLane;
+      268435456 !== updateLane && (root.suspendedLanes = 0, root.pingedLanes = 0, root.warmLanes = 0);
+    }
+    function markRootFinished(root, finishedLanes, remainingLanes, spawnedLane, updatedLanes, suspendedRetryLanes) {
+      var previouslyPendingLanes = root.pendingLanes;
+      root.pendingLanes = remainingLanes;
+      root.suspendedLanes = 0;
+      root.pingedLanes = 0;
+      root.warmLanes = 0;
+      root.expiredLanes &= remainingLanes;
+      root.entangledLanes &= remainingLanes;
+      root.errorRecoveryDisabledLanes &= remainingLanes;
+      root.shellSuspendCounter = 0;
+      var entanglements = root.entanglements,
+        expirationTimes = root.expirationTimes,
+        hiddenUpdates = root.hiddenUpdates;
+      for (remainingLanes = previouslyPendingLanes & ~remainingLanes; 0 < remainingLanes;) {
+        var index = 31 - clz32(remainingLanes),
+          lane = 1 << index;
+        entanglements[index] = 0;
+        expirationTimes[index] = -1;
+        var hiddenUpdatesForLane = hiddenUpdates[index];
+        if (null !== hiddenUpdatesForLane) for (hiddenUpdates[index] = null, index = 0; index < hiddenUpdatesForLane.length; index++) {
+          var update = hiddenUpdatesForLane[index];
+          null !== update && (update.lane &= -536870913);
+        }
+        remainingLanes &= ~lane;
+      }
+      0 !== spawnedLane && markSpawnedDeferredLane(root, spawnedLane, 0);
+      0 !== suspendedRetryLanes && 0 === updatedLanes && (root.suspendedLanes |= suspendedRetryLanes & ~(previouslyPendingLanes & ~finishedLanes));
+    }
+    function markSpawnedDeferredLane(root, spawnedLane, entangledLanes) {
+      root.pendingLanes |= spawnedLane;
+      root.suspendedLanes &= ~spawnedLane;
+      var spawnedLaneIndex = 31 - clz32(spawnedLane);
+      root.entangledLanes |= spawnedLane;
+      root.entanglements[spawnedLaneIndex] = root.entanglements[spawnedLaneIndex] | 1073741824 | entangledLanes & 4194090;
+    }
+    function markRootEntangled(root, entangledLanes) {
+      var rootEntangledLanes = root.entangledLanes |= entangledLanes;
+      for (root = root.entanglements; rootEntangledLanes;) {
+        var index = 31 - clz32(rootEntangledLanes),
+          lane = 1 << index;
+        lane & entangledLanes | root[index] & entangledLanes && (root[index] |= entangledLanes);
+        rootEntangledLanes &= ~lane;
+      }
+    }
+    function addFiberToLanesMap(root, fiber, lanes) {
+      if (isDevToolsPresent) for (root = root.pendingUpdatersLaneMap; 0 < lanes;) {
+        var index = 31 - clz32(lanes),
+          lane = 1 << index;
+        root[index].add(fiber);
+        lanes &= ~lane;
+      }
+    }
+    function movePendingFibersToMemoized(root, lanes) {
+      if (isDevToolsPresent) for (var pendingUpdatersLaneMap = root.pendingUpdatersLaneMap, memoizedUpdaters = root.memoizedUpdaters; 0 < lanes;) {
+        var index = 31 - clz32(lanes);
+        root = 1 << index;
+        index = pendingUpdatersLaneMap[index];
+        0 < index.size && (index.forEach(function (fiber) {
+          var alternate = fiber.alternate;
+          null !== alternate && memoizedUpdaters.has(alternate) || memoizedUpdaters.add(fiber);
+        }), index.clear());
+        lanes &= ~root;
+      }
+    }
+    function lanesToEventPriority(lanes) {
+      lanes &= -lanes;
+      return 0 !== DiscreteEventPriority && DiscreteEventPriority < lanes ? 0 !== ContinuousEventPriority && ContinuousEventPriority < lanes ? 0 !== (lanes & 134217727) ? DefaultEventPriority : IdleEventPriority : ContinuousEventPriority : DiscreteEventPriority;
+    }
+    function findNodeHandle(componentOrHandle) {
+      var owner = current;
+      null !== owner && isRendering && null !== owner.stateNode && (owner.stateNode._warnedAboutRefsInRender || console.error("%s is accessing findNodeHandle inside its render(). render() should be a pure function of props and state. It should never access something that requires stale data from the previous render, such as refs. Move this logic to componentDidMount and componentDidUpdate instead.", getComponentNameFromType(owner.type) || "A component"), owner.stateNode._warnedAboutRefsInRender = !0);
+      if (null == componentOrHandle) return null;
+      if ("number" === typeof componentOrHandle) return componentOrHandle;
+      if (componentOrHandle._nativeTag) return componentOrHandle._nativeTag;
+      if (null != componentOrHandle.canonical && null != componentOrHandle.canonical.nativeTag) return componentOrHandle.canonical.nativeTag;
+      if (owner = ReactNativePrivateInterface.getNativeTagFromPublicInstance(componentOrHandle)) return owner;
+      componentOrHandle = findHostInstanceWithWarning(componentOrHandle, "findNodeHandle");
+      return null == componentOrHandle ? componentOrHandle : null != componentOrHandle._nativeTag ? componentOrHandle._nativeTag : ReactNativePrivateInterface.getNativeTagFromPublicInstance(componentOrHandle);
+    }
+    function shim$1() {
+      throw Error("The current renderer does not support hydration. This error is likely caused by a bug in React. Please file an issue.");
+    }
+    function shim() {
+      throw Error("The current renderer does not support Resources. This error is likely caused by a bug in React. Please file an issue.");
+    }
+    function allocateTag() {
+      var tag = nextReactTag;
+      1 === tag % 10 && (tag += 2);
+      nextReactTag = tag + 2;
+      return tag;
+    }
+    function recursivelyUncacheFiberNode(node) {
+      if ("number" === typeof node) instanceCache.delete(node), instanceProps.delete(node);else {
+        var tag = node._nativeTag;
+        instanceCache.delete(tag);
+        instanceProps.delete(tag);
+        node._children.forEach(recursivelyUncacheFiberNode);
+      }
+    }
+    function finalizeInitialChildren(parentInstance) {
+      if (0 === parentInstance._children.length) return !1;
+      var nativeTags = parentInstance._children.map(function (child) {
+        return "number" === typeof child ? child : child._nativeTag;
+      });
+      ReactNativePrivateInterface.UIManager.setChildren(parentInstance._nativeTag, nativeTags);
+      return !1;
+    }
+    function getPublicInstance(instance) {
+      return null != instance.canonical && null != instance.canonical.publicInstance ? instance.canonical.publicInstance : instance;
+    }
+    function commitTextUpdate(textInstance, oldText, newText) {
+      ReactNativePrivateInterface.UIManager.updateView(textInstance, "RCTRawText", {
+        text: newText
+      });
+    }
+    function commitMount() {}
+    function commitUpdate(instance, type, oldProps, newProps) {
+      type = instance.viewConfig;
+      instanceProps.set(instance._nativeTag, newProps);
+      oldProps = diffProperties(null, oldProps, newProps, type.validAttributes);
+      null != oldProps && ReactNativePrivateInterface.UIManager.updateView(instance._nativeTag, type.uiViewClassName, oldProps);
+    }
+    function removeChild(parentInstance, child) {
+      recursivelyUncacheFiberNode(child);
+      var children = parentInstance._children;
+      child = children.indexOf(child);
+      children.splice(child, 1);
+      ReactNativePrivateInterface.UIManager.manageChildren(parentInstance._nativeTag, [], [], [], [], [child]);
+    }
+    function removeChildFromContainer(parentInstance, child) {
+      recursivelyUncacheFiberNode(child);
+      ReactNativePrivateInterface.UIManager.manageChildren(parentInstance.containerTag, [], [], [], [], [0]);
+    }
+    function resetTextContent() {}
+    function hideInstance(instance) {
+      var viewConfig = instance.viewConfig;
+      var updatePayload = diffProperties(null, emptyObject$1, {
+        style: {
+          display: "none"
+        }
+      }, viewConfig.validAttributes);
+      ReactNativePrivateInterface.UIManager.updateView(instance._nativeTag, viewConfig.uiViewClassName, updatePayload);
+    }
+    function hideTextInstance() {
+      throw Error("Not yet implemented.");
+    }
+    function unhideInstance(instance, props) {
+      var viewConfig = instance.viewConfig,
+        prevProps = assign({}, props, {
+          style: [props.style, {
+            display: "none"
+          }]
+        });
+      props = diffProperties(null, prevProps, props, viewConfig.validAttributes);
+      ReactNativePrivateInterface.UIManager.updateView(instance._nativeTag, viewConfig.uiViewClassName, props);
+    }
+    function unhideTextInstance() {
+      throw Error("Not yet implemented.");
+    }
+    function createCursor(defaultValue) {
+      return {
+        current: defaultValue
+      };
+    }
+    function pop(cursor, fiber) {
+      0 > index$jscomp$0 ? console.error("Unexpected pop.") : (fiber !== fiberStack[index$jscomp$0] && console.error("Unexpected Fiber popped."), cursor.current = valueStack[index$jscomp$0], valueStack[index$jscomp$0] = null, fiberStack[index$jscomp$0] = null, index$jscomp$0--);
+    }
+    function push(cursor, value, fiber) {
+      index$jscomp$0++;
+      valueStack[index$jscomp$0] = cursor.current;
+      fiberStack[index$jscomp$0] = fiber;
+      cursor.current = value;
+    }
+    function createCapturedValueAtFiber(value, source) {
+      if ("object" === typeof value && null !== value) {
+        var existing = CapturedStacks.get(value);
+        if (void 0 !== existing) return existing;
+        source = {
+          value: value,
+          source: source,
+          stack: getStackByFiberInDevAndProd(source)
+        };
+        CapturedStacks.set(value, source);
+        return source;
+      }
+      return {
+        value: value,
+        source: source,
+        stack: getStackByFiberInDevAndProd(source)
+      };
+    }
+    function requiredContext(c) {
+      null === c && console.error("Expected host context to exist. This error is likely caused by a bug in React. Please file an issue.");
+      return c;
+    }
+    function pushHostContainer(fiber, nextRootInstance) {
+      push(rootInstanceStackCursor, nextRootInstance, fiber);
+      push(contextFiberStackCursor, fiber, fiber);
+      push(contextStackCursor, null, fiber);
+      pop(contextStackCursor, fiber);
+      push(contextStackCursor, {
+        isInAParentText: !1
+      }, fiber);
+    }
+    function popHostContainer(fiber) {
+      pop(contextStackCursor, fiber);
+      pop(contextFiberStackCursor, fiber);
+      pop(rootInstanceStackCursor, fiber);
+    }
+    function pushHostContext(fiber) {
+      null !== fiber.memoizedState && push(hostTransitionProviderCursor, fiber, fiber);
+      var context = requiredContext(contextStackCursor.current);
+      var nextContext = fiber.type;
+      nextContext = "AndroidTextInput" === nextContext || "RCTMultilineTextInputView" === nextContext || "RCTSinglelineTextInputView" === nextContext || "RCTText" === nextContext || "RCTVirtualText" === nextContext;
+      nextContext = context.isInAParentText !== nextContext ? {
+        isInAParentText: nextContext
+      } : context;
+      context !== nextContext && (push(contextFiberStackCursor, fiber, fiber), push(contextStackCursor, nextContext, fiber));
+    }
+    function popHostContext(fiber) {
+      contextFiberStackCursor.current === fiber && (pop(contextStackCursor, fiber), pop(contextFiberStackCursor, fiber));
+      hostTransitionProviderCursor.current === fiber && (pop(hostTransitionProviderCursor, fiber), HostTransitionContext._currentValue = null);
+    }
+    function findNotableNode(node, indent) {
+      return void 0 === node.serverProps && 0 === node.serverTail.length && 1 === node.children.length && 3 < node.distanceFromLeaf && node.distanceFromLeaf > 15 - indent ? findNotableNode(node.children[0], indent) : node;
+    }
+    function indentation(indent) {
+      return "  " + "  ".repeat(indent);
+    }
+    function added(indent) {
+      return "+ " + "  ".repeat(indent);
+    }
+    function removed(indent) {
+      return "- " + "  ".repeat(indent);
+    }
+    function describeFiberType(fiber) {
+      switch (fiber.tag) {
+        case 26:
+        case 27:
+        case 5:
+          return fiber.type;
+        case 16:
+          return "Lazy";
+        case 13:
+          return "Suspense";
+        case 19:
+          return "SuspenseList";
+        case 0:
+        case 15:
+          return fiber = fiber.type, fiber.displayName || fiber.name || null;
+        case 11:
+          return fiber = fiber.type.render, fiber.displayName || fiber.name || null;
+        case 1:
+          return fiber = fiber.type, fiber.displayName || fiber.name || null;
+        default:
+          return null;
+      }
+    }
+    function describeTextNode(content, maxLength) {
+      return needsEscaping.test(content) ? (content = JSON.stringify(content), content.length > maxLength - 2 ? 8 > maxLength ? '{"..."}' : "{" + content.slice(0, maxLength - 7) + '..."}' : "{" + content + "}") : content.length > maxLength ? 5 > maxLength ? '{"..."}' : content.slice(0, maxLength - 3) + "..." : content;
+    }
+    function describeTextDiff(clientText, serverProps, indent) {
+      var maxLength = 120 - 2 * indent;
+      if (null === serverProps) return added(indent) + describeTextNode(clientText, maxLength) + "\n";
+      if ("string" === typeof serverProps) {
+        for (var firstDiff = 0; firstDiff < serverProps.length && firstDiff < clientText.length && serverProps.charCodeAt(firstDiff) === clientText.charCodeAt(firstDiff); firstDiff++);
+        firstDiff > maxLength - 8 && 10 < firstDiff && (clientText = "..." + clientText.slice(firstDiff - 8), serverProps = "..." + serverProps.slice(firstDiff - 8));
+        return added(indent) + describeTextNode(clientText, maxLength) + "\n" + removed(indent) + describeTextNode(serverProps, maxLength) + "\n";
+      }
+      return indentation(indent) + describeTextNode(clientText, maxLength) + "\n";
+    }
+    function objectName(object) {
+      return Object.prototype.toString.call(object).replace(/^\[object (.*)\]$/, function (m, p0) {
+        return p0;
+      });
+    }
+    function describeValue(value, maxLength) {
+      switch (typeof value) {
+        case "string":
+          return value = JSON.stringify(value), value.length > maxLength ? 5 > maxLength ? '"..."' : value.slice(0, maxLength - 4) + '..."' : value;
+        case "object":
+          if (null === value) return "null";
+          if (isArrayImpl(value)) return "[...]";
+          if (value.$$typeof === REACT_ELEMENT_TYPE) return (maxLength = getComponentNameFromType(value.type)) ? "<" + maxLength + ">" : "<...>";
+          var name = objectName(value);
+          if ("Object" === name) {
+            name = "";
+            maxLength -= 2;
+            for (var propName in value) if (value.hasOwnProperty(propName)) {
+              var jsonPropName = JSON.stringify(propName);
+              jsonPropName !== '"' + propName + '"' && (propName = jsonPropName);
+              maxLength -= propName.length - 2;
+              jsonPropName = describeValue(value[propName], 15 > maxLength ? maxLength : 15);
+              maxLength -= jsonPropName.length;
+              if (0 > maxLength) {
+                name += "" === name ? "..." : ", ...";
+                break;
+              }
+              name += ("" === name ? "" : ",") + propName + ":" + jsonPropName;
+            }
+            return "{" + name + "}";
+          }
+          return name;
+        case "function":
+          return (maxLength = value.displayName || value.name) ? "function " + maxLength : "function";
+        default:
+          return String(value);
+      }
+    }
+    function describePropValue(value, maxLength) {
+      return "string" !== typeof value || needsEscaping.test(value) ? "{" + describeValue(value, maxLength - 2) + "}" : value.length > maxLength - 2 ? 5 > maxLength ? '"..."' : '"' + value.slice(0, maxLength - 5) + '..."' : '"' + value + '"';
+    }
+    function describeExpandedElement(type, props, rowPrefix) {
+      var remainingRowLength = 120 - rowPrefix.length - type.length,
+        properties = [],
+        propName;
+      for (propName in props) if (props.hasOwnProperty(propName) && "children" !== propName) {
+        var propValue = describePropValue(props[propName], 120 - rowPrefix.length - propName.length - 1);
+        remainingRowLength -= propName.length + propValue.length + 2;
+        properties.push(propName + "=" + propValue);
+      }
+      return 0 === properties.length ? rowPrefix + "<" + type + ">\n" : 0 < remainingRowLength ? rowPrefix + "<" + type + " " + properties.join(" ") + ">\n" : rowPrefix + "<" + type + "\n" + rowPrefix + "  " + properties.join("\n" + rowPrefix + "  ") + "\n" + rowPrefix + ">\n";
+    }
+    function describePropertiesDiff(clientObject, serverObject, indent) {
+      var properties = "",
+        remainingServerProperties = assign({}, serverObject),
+        propName;
+      for (propName in clientObject) if (clientObject.hasOwnProperty(propName)) {
+        delete remainingServerProperties[propName];
+        var maxLength = 120 - 2 * indent - propName.length - 2,
+          clientPropValue = describeValue(clientObject[propName], maxLength);
+        serverObject.hasOwnProperty(propName) ? (maxLength = describeValue(serverObject[propName], maxLength), properties += added(indent) + propName + ": " + clientPropValue + "\n", properties += removed(indent) + propName + ": " + maxLength + "\n") : properties += added(indent) + propName + ": " + clientPropValue + "\n";
+      }
+      for (var _propName in remainingServerProperties) remainingServerProperties.hasOwnProperty(_propName) && (clientObject = describeValue(remainingServerProperties[_propName], 120 - 2 * indent - _propName.length - 2), properties += removed(indent) + _propName + ": " + clientObject + "\n");
+      return properties;
+    }
+    function describeElementDiff(type, clientProps, serverProps, indent) {
+      var content = "",
+        serverPropNames = new Map();
+      for (propName$jscomp$0 in serverProps) serverProps.hasOwnProperty(propName$jscomp$0) && serverPropNames.set(propName$jscomp$0.toLowerCase(), propName$jscomp$0);
+      if (1 === serverPropNames.size && serverPropNames.has("children")) content += describeExpandedElement(type, clientProps, indentation(indent));else {
+        for (var _propName2 in clientProps) if (clientProps.hasOwnProperty(_propName2) && "children" !== _propName2) {
+          var maxLength$jscomp$0 = 120 - 2 * (indent + 1) - _propName2.length - 1,
+            serverPropName = serverPropNames.get(_propName2.toLowerCase());
+          if (void 0 !== serverPropName) {
+            serverPropNames.delete(_propName2.toLowerCase());
+            var propName$jscomp$0 = clientProps[_propName2];
+            serverPropName = serverProps[serverPropName];
+            var clientPropValue = describePropValue(propName$jscomp$0, maxLength$jscomp$0);
+            maxLength$jscomp$0 = describePropValue(serverPropName, maxLength$jscomp$0);
+            "object" === typeof propName$jscomp$0 && null !== propName$jscomp$0 && "object" === typeof serverPropName && null !== serverPropName && "Object" === objectName(propName$jscomp$0) && "Object" === objectName(serverPropName) && (2 < Object.keys(propName$jscomp$0).length || 2 < Object.keys(serverPropName).length || -1 < clientPropValue.indexOf("...") || -1 < maxLength$jscomp$0.indexOf("...")) ? content += indentation(indent + 1) + _propName2 + "={{\n" + describePropertiesDiff(propName$jscomp$0, serverPropName, indent + 2) + indentation(indent + 1) + "}}\n" : (content += added(indent + 1) + _propName2 + "=" + clientPropValue + "\n", content += removed(indent + 1) + _propName2 + "=" + maxLength$jscomp$0 + "\n");
+          } else content += indentation(indent + 1) + _propName2 + "=" + describePropValue(clientProps[_propName2], maxLength$jscomp$0) + "\n";
+        }
+        serverPropNames.forEach(function (propName) {
+          if ("children" !== propName) {
+            var maxLength = 120 - 2 * (indent + 1) - propName.length - 1;
+            content += removed(indent + 1) + propName + "=" + describePropValue(serverProps[propName], maxLength) + "\n";
+          }
+        });
+        content = "" === content ? indentation(indent) + "<" + type + ">\n" : indentation(indent) + "<" + type + "\n" + content + indentation(indent) + ">\n";
+      }
+      type = serverProps.children;
+      clientProps = clientProps.children;
+      if ("string" === typeof type || "number" === typeof type || "bigint" === typeof type) {
+        serverPropNames = "";
+        if ("string" === typeof clientProps || "number" === typeof clientProps || "bigint" === typeof clientProps) serverPropNames = "" + clientProps;
+        content += describeTextDiff(serverPropNames, "" + type, indent + 1);
+      } else if ("string" === typeof clientProps || "number" === typeof clientProps || "bigint" === typeof clientProps) content = null == type ? content + describeTextDiff("" + clientProps, null, indent + 1) : content + describeTextDiff("" + clientProps, void 0, indent + 1);
+      return content;
+    }
+    function describeSiblingFiber(fiber, indent) {
+      var type = describeFiberType(fiber);
+      if (null === type) {
+        type = "";
+        for (fiber = fiber.child; fiber;) type += describeSiblingFiber(fiber, indent), fiber = fiber.sibling;
+        return type;
+      }
+      return indentation(indent) + "<" + type + ">\n";
+    }
+    function describeNode(node, indent) {
+      var skipToNode = findNotableNode(node, indent);
+      if (skipToNode !== node && (1 !== node.children.length || node.children[0] !== skipToNode)) return indentation(indent) + "...\n" + describeNode(skipToNode, indent + 1);
+      skipToNode = "";
+      var debugInfo = node.fiber._debugInfo;
+      if (debugInfo) for (var i = 0; i < debugInfo.length; i++) {
+        var serverComponentName = debugInfo[i].name;
+        "string" === typeof serverComponentName && (skipToNode += indentation(indent) + "<" + serverComponentName + ">\n", indent++);
+      }
+      debugInfo = "";
+      i = node.fiber.pendingProps;
+      if (6 === node.fiber.tag) debugInfo = describeTextDiff(i, node.serverProps, indent), indent++;else if (serverComponentName = describeFiberType(node.fiber), null !== serverComponentName) if (void 0 === node.serverProps) {
+        debugInfo = indent;
+        var maxLength = 120 - 2 * debugInfo - serverComponentName.length - 2,
+          content = "";
+        for (propName in i) if (i.hasOwnProperty(propName) && "children" !== propName) {
+          var propValue = describePropValue(i[propName], 15);
+          maxLength -= propName.length + propValue.length + 2;
+          if (0 > maxLength) {
+            content += " ...";
+            break;
+          }
+          content += " " + propName + "=" + propValue;
+        }
+        debugInfo = indentation(debugInfo) + "<" + serverComponentName + content + ">\n";
+        indent++;
+      } else null === node.serverProps ? (debugInfo = describeExpandedElement(serverComponentName, i, added(indent)), indent++) : "string" === typeof node.serverProps ? console.error("Should not have matched a non HostText fiber to a Text node. This is a bug in React.") : (debugInfo = describeElementDiff(serverComponentName, i, node.serverProps, indent), indent++);
+      var propName = "";
+      i = node.fiber.child;
+      for (serverComponentName = 0; i && serverComponentName < node.children.length;) maxLength = node.children[serverComponentName], maxLength.fiber === i ? (propName += describeNode(maxLength, indent), serverComponentName++) : propName += describeSiblingFiber(i, indent), i = i.sibling;
+      i && 0 < node.children.length && (propName += indentation(indent) + "...\n");
+      i = node.serverTail;
+      null === node.serverProps && indent--;
+      for (node = 0; node < i.length; node++) serverComponentName = i[node], propName = "string" === typeof serverComponentName ? propName + (removed(indent) + describeTextNode(serverComponentName, 120 - 2 * indent) + "\n") : propName + describeExpandedElement(serverComponentName.type, serverComponentName.props, removed(indent));
+      return skipToNode + debugInfo + propName;
+    }
+    function upgradeHydrationErrorsToRecoverable() {
+      var queuedErrors = hydrationErrors;
+      null !== queuedErrors && (null === workInProgressRootRecoverableErrors ? workInProgressRootRecoverableErrors = queuedErrors : workInProgressRootRecoverableErrors.push.apply(workInProgressRootRecoverableErrors, queuedErrors), hydrationErrors = null);
+      return queuedErrors;
+    }
+    function emitPendingHydrationWarnings() {
+      var diffRoot = hydrationDiffRootDEV;
+      if (null !== diffRoot) {
+        hydrationDiffRootDEV = null;
+        try {
+          var diff = "\n\n" + describeNode(diffRoot, 0);
+        } catch (x) {
+          diff = "";
+        }
+        for (; 0 < diffRoot.children.length;) diffRoot = diffRoot.children[0];
+        runWithFiberInDEV(diffRoot.fiber, function () {
+          console.error("A tree hydrated but some attributes of the server rendered HTML didn't match the client properties. This won't be patched up. This can happen if a SSR-ed Client Component used:\n\n- A server/client branch `if (typeof window !== 'undefined')`.\n- Variable input such as `Date.now()` or `Math.random()` which changes each time it's called.\n- Date formatting in a user's locale which doesn't match the server.\n- External changing data without sending a snapshot of it along with the HTML.\n- Invalid HTML tag nesting.\n\nIt can also happen if the client has a browser extension installed which messes with the HTML before React loaded.\n\n%s%s", "https://react.dev/link/hydration-mismatch", diff);
+        });
+      }
+    }
+    function is(x, y) {
+      return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+    }
+    function resetContextDependencies() {
+      lastContextDependency = currentlyRenderingFiber$1 = null;
+      isDisallowedContextReadInDEV = !1;
+    }
+    function pushProvider(providerFiber, context, nextValue) {
+      push(valueCursor, context._currentValue, providerFiber);
+      context._currentValue = nextValue;
+      push(rendererCursorDEV, context._currentRenderer, providerFiber);
+      void 0 !== context._currentRenderer && null !== context._currentRenderer && context._currentRenderer !== rendererSigil && console.error("Detected multiple renderers concurrently rendering the same context provider. This is currently unsupported.");
+      context._currentRenderer = rendererSigil;
+    }
+    function popProvider(context, providerFiber) {
+      context._currentValue = valueCursor.current;
+      var currentRenderer = rendererCursorDEV.current;
+      pop(rendererCursorDEV, providerFiber);
+      context._currentRenderer = currentRenderer;
+      pop(valueCursor, providerFiber);
+    }
+    function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
+      for (; null !== parent;) {
+        var alternate = parent.alternate;
+        (parent.childLanes & renderLanes) !== renderLanes ? (parent.childLanes |= renderLanes, null !== alternate && (alternate.childLanes |= renderLanes)) : null !== alternate && (alternate.childLanes & renderLanes) !== renderLanes && (alternate.childLanes |= renderLanes);
+        if (parent === propagationRoot) break;
+        parent = parent.return;
+      }
+      parent !== propagationRoot && console.error("Expected to find the propagation root when scheduling context work. This error is likely caused by a bug in React. Please file an issue.");
+    }
+    function propagateContextChanges(workInProgress, contexts, renderLanes, forcePropagateEntireTree) {
+      var fiber = workInProgress.child;
+      null !== fiber && (fiber.return = workInProgress);
+      for (; null !== fiber;) {
+        var list = fiber.dependencies;
+        if (null !== list) {
+          var nextFiber = fiber.child;
+          list = list.firstContext;
+          a: for (; null !== list;) {
+            var dependency = list;
+            list = fiber;
+            for (var i = 0; i < contexts.length; i++) if (dependency.context === contexts[i]) {
+              list.lanes |= renderLanes;
+              dependency = list.alternate;
+              null !== dependency && (dependency.lanes |= renderLanes);
+              scheduleContextWorkOnParentPath(list.return, renderLanes, workInProgress);
+              forcePropagateEntireTree || (nextFiber = null);
+              break a;
+            }
+            list = dependency.next;
+          }
+        } else if (18 === fiber.tag) {
+          nextFiber = fiber.return;
+          if (null === nextFiber) throw Error("We just came from a parent so we must have had a parent. This is a bug in React.");
+          nextFiber.lanes |= renderLanes;
+          list = nextFiber.alternate;
+          null !== list && (list.lanes |= renderLanes);
+          scheduleContextWorkOnParentPath(nextFiber, renderLanes, workInProgress);
+          nextFiber = null;
+        } else nextFiber = fiber.child;
+        if (null !== nextFiber) nextFiber.return = fiber;else for (nextFiber = fiber; null !== nextFiber;) {
+          if (nextFiber === workInProgress) {
+            nextFiber = null;
+            break;
+          }
+          fiber = nextFiber.sibling;
+          if (null !== fiber) {
+            fiber.return = nextFiber.return;
+            nextFiber = fiber;
+            break;
+          }
+          nextFiber = nextFiber.return;
+        }
+        fiber = nextFiber;
+      }
+    }
+    function propagateParentContextChanges(current, workInProgress, renderLanes, forcePropagateEntireTree) {
+      current = null;
+      for (var parent = workInProgress, isInsidePropagationBailout = !1; null !== parent;) {
+        if (!isInsidePropagationBailout) if (0 !== (parent.flags & 524288)) isInsidePropagationBailout = !0;else if (0 !== (parent.flags & 262144)) break;
+        if (10 === parent.tag) {
+          var currentParent = parent.alternate;
+          if (null === currentParent) throw Error("Should have a current fiber. This is a bug in React.");
+          currentParent = currentParent.memoizedProps;
+          if (null !== currentParent) {
+            var context = parent.type;
+            objectIs(parent.pendingProps.value, currentParent.value) || (null !== current ? current.push(context) : current = [context]);
+          }
+        } else if (parent === hostTransitionProviderCursor.current) {
+          currentParent = parent.alternate;
+          if (null === currentParent) throw Error("Should have a current fiber. This is a bug in React.");
+          currentParent.memoizedState.memoizedState !== parent.memoizedState.memoizedState && (null !== current ? current.push(HostTransitionContext) : current = [HostTransitionContext]);
+        }
+        parent = parent.return;
+      }
+      null !== current && propagateContextChanges(workInProgress, current, renderLanes, forcePropagateEntireTree);
+      workInProgress.flags |= 262144;
+    }
+    function checkIfContextChanged(currentDependencies) {
+      for (currentDependencies = currentDependencies.firstContext; null !== currentDependencies;) {
+        if (!objectIs(currentDependencies.context._currentValue, currentDependencies.memoizedValue)) return !0;
+        currentDependencies = currentDependencies.next;
+      }
+      return !1;
+    }
+    function prepareToReadContext(workInProgress) {
+      currentlyRenderingFiber$1 = workInProgress;
+      lastContextDependency = null;
+      workInProgress = workInProgress.dependencies;
+      null !== workInProgress && (workInProgress.firstContext = null);
+    }
+    function _readContext(context) {
+      isDisallowedContextReadInDEV && console.error("Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo().");
+      return readContextForConsumer(currentlyRenderingFiber$1, context);
+    }
+    function readContextDuringReconciliation(consumer, context) {
+      null === currentlyRenderingFiber$1 && prepareToReadContext(consumer);
+      return readContextForConsumer(consumer, context);
+    }
+    function readContextForConsumer(consumer, context) {
+      var value = context._currentValue;
+      context = {
+        context: context,
+        memoizedValue: value,
+        next: null
+      };
+      if (null === lastContextDependency) {
+        if (null === consumer) throw Error("Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo().");
+        lastContextDependency = context;
+        consumer.dependencies = {
+          lanes: 0,
+          firstContext: context,
+          _debugThenableState: null
+        };
+        consumer.flags |= 524288;
+      } else lastContextDependency = lastContextDependency.next = context;
+      return value;
+    }
+    function createCache() {
+      return {
+        controller: new AbortControllerLocal(),
+        data: new Map(),
+        refCount: 0
+      };
+    }
+    function retainCache(cache) {
+      cache.controller.signal.aborted && console.warn("A cache instance was retained after it was already freed. This likely indicates a bug in React.");
+      cache.refCount++;
+    }
+    function releaseCache(cache) {
+      cache.refCount--;
+      0 > cache.refCount && console.warn("A cache instance was released after it was already freed. This likely indicates a bug in React.");
+      0 === cache.refCount && scheduleCallback$2(NormalPriority, function () {
+        cache.controller.abort();
+      });
+    }
+    function pushNestedEffectDurations() {
+      var prevEffectDuration = profilerEffectDuration;
+      profilerEffectDuration = 0;
+      return prevEffectDuration;
+    }
+    function popNestedEffectDurations(prevEffectDuration) {
+      var elapsedTime = profilerEffectDuration;
+      profilerEffectDuration = prevEffectDuration;
+      return elapsedTime;
+    }
+    function bubbleNestedEffectDurations(prevEffectDuration) {
+      var elapsedTime = profilerEffectDuration;
+      profilerEffectDuration += prevEffectDuration;
+      return elapsedTime;
+    }
+    function startProfilerTimer(fiber) {
+      profilerStartTime = now();
+      0 > fiber.actualStartTime && (fiber.actualStartTime = profilerStartTime);
+    }
+    function stopProfilerTimerIfRunningAndRecordDuration(fiber) {
+      if (0 <= profilerStartTime) {
+        var elapsedTime = now() - profilerStartTime;
+        fiber.actualDuration += elapsedTime;
+        fiber.selfBaseDuration = elapsedTime;
+        profilerStartTime = -1;
+      }
+    }
+    function stopProfilerTimerIfRunningAndRecordIncompleteDuration(fiber) {
+      if (0 <= profilerStartTime) {
+        var elapsedTime = now() - profilerStartTime;
+        fiber.actualDuration += elapsedTime;
+        profilerStartTime = -1;
+      }
+    }
+    function recordEffectDuration() {
+      if (0 <= profilerStartTime) {
+        var elapsedTime = now() - profilerStartTime;
+        profilerStartTime = -1;
+        profilerEffectDuration += elapsedTime;
+      }
+    }
+    function startEffectTimer() {
+      profilerStartTime = now();
+    }
+    function transferActualDuration(fiber) {
+      for (var child = fiber.child; child;) fiber.actualDuration += child.actualDuration, child = child.sibling;
+    }
+    function ensureRootIsScheduled(root) {
+      root !== lastScheduledRoot && null === root.next && (null === lastScheduledRoot ? firstScheduledRoot = lastScheduledRoot = root : lastScheduledRoot = lastScheduledRoot.next = root);
+      mightHavePendingSyncWork = !0;
+      null !== ReactSharedInternals.actQueue ? didScheduleMicrotask_act || (didScheduleMicrotask_act = !0, scheduleImmediateRootScheduleTask()) : didScheduleMicrotask || (didScheduleMicrotask = !0, scheduleImmediateRootScheduleTask());
+      ReactSharedInternals.isBatchingLegacy && 0 === root.tag && (ReactSharedInternals.didScheduleLegacyUpdate = !0);
+    }
+    function flushSyncWorkAcrossRoots_impl(syncTransitionLanes, onlyLegacy) {
+      if (!isFlushingWork && mightHavePendingSyncWork) {
+        isFlushingWork = !0;
+        do {
+          var didPerformSomeWork = !1;
+          for (var root = firstScheduledRoot; null !== root;) {
+            if (!onlyLegacy || 0 === root.tag) if (0 !== syncTransitionLanes) {
+              var pendingLanes = root.pendingLanes;
+              if (0 === pendingLanes) var nextLanes = 0;else {
+                var suspendedLanes = root.suspendedLanes,
+                  pingedLanes = root.pingedLanes;
+                nextLanes = (1 << 31 - clz32(42 | syncTransitionLanes) + 1) - 1;
+                nextLanes &= pendingLanes & ~(suspendedLanes & ~pingedLanes);
+                nextLanes = nextLanes & 201326741 ? nextLanes & 201326741 | 1 : nextLanes ? nextLanes | 2 : 0;
+              }
+              0 !== nextLanes && (didPerformSomeWork = !0, performSyncWorkOnRoot(root, nextLanes));
+            } else nextLanes = workInProgressRootRenderLanes, nextLanes = getNextLanes(root, root === workInProgressRoot ? nextLanes : 0, null !== root.cancelPendingCommit || -1 !== root.timeoutHandle), 0 === (nextLanes & 3) || checkIfRootIsPrerendering(root, nextLanes) || (didPerformSomeWork = !0, performSyncWorkOnRoot(root, nextLanes));
+            root = root.next;
+          }
+        } while (didPerformSomeWork);
+        isFlushingWork = !1;
+      }
+    }
+    function processRootScheduleInImmediateTask() {
+      processRootScheduleInMicrotask();
+    }
+    function processRootScheduleInMicrotask() {
+      mightHavePendingSyncWork = didScheduleMicrotask_act = didScheduleMicrotask = !1;
+      0 !== currentEventTransitionLane && (currentEventTransitionLane = 0);
+      for (var currentTime = now$1(), prev = null, root = firstScheduledRoot; null !== root;) {
+        var next = root.next,
+          nextLanes = scheduleTaskForRootDuringMicrotask(root, currentTime);
+        0 === nextLanes ? (root.next = null, null === prev ? firstScheduledRoot = next : prev.next = next, null === next && (lastScheduledRoot = prev)) : (prev = root, 0 !== (nextLanes & 3) && (mightHavePendingSyncWork = !0));
+        root = next;
+      }
+      flushSyncWorkAcrossRoots_impl(0, !1);
+    }
+    function scheduleTaskForRootDuringMicrotask(root, currentTime) {
+      for (var suspendedLanes = root.suspendedLanes, pingedLanes = root.pingedLanes, expirationTimes = root.expirationTimes, lanes = root.pendingLanes & -62914561; 0 < lanes;) {
+        var index = 31 - clz32(lanes),
+          lane = 1 << index,
+          expirationTime = expirationTimes[index];
+        if (-1 === expirationTime) {
+          if (0 === (lane & suspendedLanes) || 0 !== (lane & pingedLanes)) expirationTimes[index] = computeExpirationTime(lane, currentTime);
+        } else expirationTime <= currentTime && (root.expiredLanes |= lane);
+        lanes &= ~lane;
+      }
+      currentTime = workInProgressRoot;
+      suspendedLanes = workInProgressRootRenderLanes;
+      suspendedLanes = getNextLanes(root, root === currentTime ? suspendedLanes : 0, null !== root.cancelPendingCommit || -1 !== root.timeoutHandle);
+      pingedLanes = root.callbackNode;
+      if (0 === suspendedLanes || root === currentTime && (workInProgressSuspendedReason === SuspendedOnData || workInProgressSuspendedReason === SuspendedOnAction) || null !== root.cancelPendingCommit) return null !== pingedLanes && cancelCallback(pingedLanes), root.callbackNode = null, root.callbackPriority = 0;
+      if (0 === (suspendedLanes & 3) || checkIfRootIsPrerendering(root, suspendedLanes)) {
+        currentTime = suspendedLanes & -suspendedLanes;
+        if (currentTime !== root.callbackPriority || null !== ReactSharedInternals.actQueue && pingedLanes !== fakeActCallbackNode$1) cancelCallback(pingedLanes);else return currentTime;
+        switch (lanesToEventPriority(suspendedLanes)) {
+          case DiscreteEventPriority:
+          case ContinuousEventPriority:
+            suspendedLanes = UserBlockingPriority;
+            break;
+          case DefaultEventPriority:
+            suspendedLanes = NormalPriority$1;
+            break;
+          case IdleEventPriority:
+            suspendedLanes = IdlePriority;
+            break;
+          default:
+            suspendedLanes = NormalPriority$1;
+        }
+        pingedLanes = performWorkOnRootViaSchedulerTask.bind(null, root);
+        null !== ReactSharedInternals.actQueue ? (ReactSharedInternals.actQueue.push(pingedLanes), suspendedLanes = fakeActCallbackNode$1) : suspendedLanes = scheduleCallback$3(suspendedLanes, pingedLanes);
+        root.callbackPriority = currentTime;
+        root.callbackNode = suspendedLanes;
+        return currentTime;
+      }
+      null !== pingedLanes && cancelCallback(pingedLanes);
+      root.callbackPriority = 2;
+      root.callbackNode = null;
+      return 2;
+    }
+    function performWorkOnRootViaSchedulerTask(root, didTimeout) {
+      nestedUpdateScheduled = currentUpdateIsNested = !1;
+      if (pendingEffectsStatus !== NO_PENDING_EFFECTS && pendingEffectsStatus !== PENDING_PASSIVE_PHASE) return root.callbackNode = null, root.callbackPriority = 0, null;
+      var originalCallbackNode = root.callbackNode;
+      if (flushPendingEffects(!0) && root.callbackNode !== originalCallbackNode) return null;
+      var workInProgressRootRenderLanes$jscomp$0 = workInProgressRootRenderLanes;
+      workInProgressRootRenderLanes$jscomp$0 = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes$jscomp$0 : 0, null !== root.cancelPendingCommit || -1 !== root.timeoutHandle);
+      if (0 === workInProgressRootRenderLanes$jscomp$0) return null;
+      performWorkOnRoot(root, workInProgressRootRenderLanes$jscomp$0, didTimeout);
+      scheduleTaskForRootDuringMicrotask(root, now$1());
+      return null != root.callbackNode && root.callbackNode === originalCallbackNode ? performWorkOnRootViaSchedulerTask.bind(null, root) : null;
+    }
+    function performSyncWorkOnRoot(root, lanes) {
+      if (flushPendingEffects()) return null;
+      currentUpdateIsNested = nestedUpdateScheduled;
+      nestedUpdateScheduled = !1;
+      performWorkOnRoot(root, lanes, !0);
+    }
+    function cancelCallback(callbackNode) {
+      callbackNode !== fakeActCallbackNode$1 && null !== callbackNode && cancelCallback$1(callbackNode);
+    }
+    function scheduleImmediateRootScheduleTask() {
+      null !== ReactSharedInternals.actQueue && ReactSharedInternals.actQueue.push(function () {
+        processRootScheduleInMicrotask();
+        return null;
+      });
+      scheduleCallback$3(ImmediatePriority, processRootScheduleInImmediateTask);
+    }
+    function requestTransitionLane() {
+      0 === currentEventTransitionLane && (currentEventTransitionLane = claimNextTransitionLane());
+      return currentEventTransitionLane;
+    }
+    function entangleAsyncAction(transition, thenable) {
+      if (null === currentEntangledListeners) {
+        var entangledListeners = currentEntangledListeners = [];
+        currentEntangledPendingCount = 0;
+        currentEntangledLane = requestTransitionLane();
+        currentEntangledActionThenable = {
+          status: "pending",
+          value: void 0,
+          then: function then(resolve) {
+            entangledListeners.push(resolve);
+          }
+        };
+      }
+      currentEntangledPendingCount++;
+      thenable.then(pingEngtangledActionScope, pingEngtangledActionScope);
+      return thenable;
+    }
+    function pingEngtangledActionScope() {
+      if (0 === --currentEntangledPendingCount && null !== currentEntangledListeners) {
+        null !== currentEntangledActionThenable && (currentEntangledActionThenable.status = "fulfilled");
+        var listeners = currentEntangledListeners;
+        currentEntangledListeners = null;
+        currentEntangledLane = 0;
+        currentEntangledActionThenable = null;
+        for (var i = 0; i < listeners.length; i++) (0, listeners[i])();
+      }
+    }
+    function chainThenableValue(thenable, result) {
+      var listeners = [],
+        thenableWithOverride = {
+          status: "pending",
+          value: null,
+          reason: null,
+          then: function then(resolve) {
+            listeners.push(resolve);
+          }
+        };
+      thenable.then(function () {
+        thenableWithOverride.status = "fulfilled";
+        thenableWithOverride.value = result;
+        for (var i = 0; i < listeners.length; i++) (0, listeners[i])(result);
+      }, function (error) {
+        thenableWithOverride.status = "rejected";
+        thenableWithOverride.reason = error;
+        for (error = 0; error < listeners.length; error++) (0, listeners[error])(void 0);
+      });
+      return thenableWithOverride;
+    }
+    function peekCacheFromPool() {
+      var cacheResumedFromPreviousRender = resumedCache.current;
+      return null !== cacheResumedFromPreviousRender ? cacheResumedFromPreviousRender : workInProgressRoot.pooledCache;
+    }
+    function pushTransition(offscreenWorkInProgress, prevCachePool) {
+      null === prevCachePool ? push(resumedCache, resumedCache.current, offscreenWorkInProgress) : push(resumedCache, prevCachePool.pool, offscreenWorkInProgress);
+    }
+    function getSuspendedCache() {
+      var cacheFromPool = peekCacheFromPool();
+      return null === cacheFromPool ? null : {
+        parent: CacheContext._currentValue,
+        pool: cacheFromPool
+      };
+    }
+    function shallowEqual(objA, objB) {
+      if (objectIs(objA, objB)) return !0;
+      if ("object" !== typeof objA || null === objA || "object" !== typeof objB || null === objB) return !1;
+      var keysA = Object.keys(objA),
+        keysB = Object.keys(objB);
+      if (keysA.length !== keysB.length) return !1;
+      for (keysB = 0; keysB < keysA.length; keysB++) {
+        var currentKey = keysA[keysB];
+        if (!hasOwnProperty.call(objB, currentKey) || !objectIs(objA[currentKey], objB[currentKey])) return !1;
+      }
+      return !0;
+    }
+    function createThenableState() {
+      return {
+        didWarnAboutUncachedPromise: !1,
+        thenables: []
+      };
+    }
+    function isThenableResolved(thenable) {
+      thenable = thenable.status;
+      return "fulfilled" === thenable || "rejected" === thenable;
+    }
+    function noop() {}
+    function trackUsedThenable(thenableState, thenable, index) {
+      null !== ReactSharedInternals.actQueue && (ReactSharedInternals.didUsePromise = !0);
+      var trackedThenables = thenableState.thenables;
+      index = trackedThenables[index];
+      void 0 === index ? trackedThenables.push(thenable) : index !== thenable && (thenableState.didWarnAboutUncachedPromise || (thenableState.didWarnAboutUncachedPromise = !0, console.error("A component was suspended by an uncached promise. Creating promises inside a Client Component or hook is not yet supported, except via a Suspense-compatible library or framework.")), thenable.then(noop, noop), thenable = index);
+      switch (thenable.status) {
+        case "fulfilled":
+          return thenable.value;
+        case "rejected":
+          throw thenableState = thenable.reason, checkIfUseWrappedInAsyncCatch(thenableState), thenableState;
+        default:
+          if ("string" === typeof thenable.status) thenable.then(noop, noop);else {
+            thenableState = workInProgressRoot;
+            if (null !== thenableState && 100 < thenableState.shellSuspendCounter) throw Error("An unknown Component is an async Client Component. Only Server Components can be async at the moment. This error is often caused by accidentally adding `'use client'` to a module that was originally written for the server.");
+            thenableState = thenable;
+            thenableState.status = "pending";
+            thenableState.then(function (fulfilledValue) {
+              if ("pending" === thenable.status) {
+                var fulfilledThenable = thenable;
+                fulfilledThenable.status = "fulfilled";
+                fulfilledThenable.value = fulfilledValue;
+              }
+            }, function (error) {
+              if ("pending" === thenable.status) {
+                var rejectedThenable = thenable;
+                rejectedThenable.status = "rejected";
+                rejectedThenable.reason = error;
+              }
+            });
+          }
+          switch (thenable.status) {
+            case "fulfilled":
+              return thenable.value;
+            case "rejected":
+              throw thenableState = thenable.reason, checkIfUseWrappedInAsyncCatch(thenableState), thenableState;
+          }
+          suspendedThenable = thenable;
+          needsToResetSuspendedThenableDEV = !0;
+          throw SuspenseException;
+      }
+    }
+    function getSuspendedThenable() {
+      if (null === suspendedThenable) throw Error("Expected a suspended thenable. This is a bug in React. Please file an issue.");
+      var thenable = suspendedThenable;
+      suspendedThenable = null;
+      needsToResetSuspendedThenableDEV = !1;
+      return thenable;
+    }
+    function checkIfUseWrappedInAsyncCatch(rejectedReason) {
+      if (rejectedReason === SuspenseException || rejectedReason === SuspenseActionException) throw Error("Hooks are not supported inside an async component. This error is often caused by accidentally adding `'use client'` to a module that was originally written for the server.");
+    }
+    function finishQueueingConcurrentUpdates() {
+      for (var endIndex = concurrentQueuesIndex, i = concurrentlyUpdatedLanes = concurrentQueuesIndex = 0; i < endIndex;) {
+        var fiber = concurrentQueues[i];
+        concurrentQueues[i++] = null;
+        var queue = concurrentQueues[i];
+        concurrentQueues[i++] = null;
+        var update = concurrentQueues[i];
+        concurrentQueues[i++] = null;
+        var lane = concurrentQueues[i];
+        concurrentQueues[i++] = null;
+        if (null !== queue && null !== update) {
+          var pending = queue.pending;
+          null === pending ? update.next = update : (update.next = pending.next, pending.next = update);
+          queue.pending = update;
+        }
+        0 !== lane && markUpdateLaneFromFiberToRoot(fiber, update, lane);
+      }
+    }
+    function enqueueUpdate$1(fiber, queue, update, lane) {
+      concurrentQueues[concurrentQueuesIndex++] = fiber;
+      concurrentQueues[concurrentQueuesIndex++] = queue;
+      concurrentQueues[concurrentQueuesIndex++] = update;
+      concurrentQueues[concurrentQueuesIndex++] = lane;
+      concurrentlyUpdatedLanes |= lane;
+      fiber.lanes |= lane;
+      fiber = fiber.alternate;
+      null !== fiber && (fiber.lanes |= lane);
+    }
+    function enqueueConcurrentHookUpdate(fiber, queue, update, lane) {
+      enqueueUpdate$1(fiber, queue, update, lane);
+      return getRootForUpdatedFiber(fiber);
+    }
+    function enqueueConcurrentRenderForLane(fiber, lane) {
+      enqueueUpdate$1(fiber, null, null, lane);
+      return getRootForUpdatedFiber(fiber);
+    }
+    function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
+      sourceFiber.lanes |= lane;
+      var alternate = sourceFiber.alternate;
+      null !== alternate && (alternate.lanes |= lane);
+      for (var isHidden = !1, parent = sourceFiber.return; null !== parent;) parent.childLanes |= lane, alternate = parent.alternate, null !== alternate && (alternate.childLanes |= lane), 22 === parent.tag && (sourceFiber = parent.stateNode, null === sourceFiber || sourceFiber._visibility & 1 || (isHidden = !0)), sourceFiber = parent, parent = parent.return;
+      return 3 === sourceFiber.tag ? (parent = sourceFiber.stateNode, isHidden && null !== update && (isHidden = 31 - clz32(lane), sourceFiber = parent.hiddenUpdates, alternate = sourceFiber[isHidden], null === alternate ? sourceFiber[isHidden] = [update] : alternate.push(update), update.lane = lane | 536870912), parent) : null;
+    }
+    function getRootForUpdatedFiber(sourceFiber) {
+      if (nestedUpdateCount > NESTED_UPDATE_LIMIT) throw nestedPassiveUpdateCount = nestedUpdateCount = 0, rootWithPassiveNestedUpdates = rootWithNestedUpdates = null, Error("Maximum update depth exceeded. This can happen when a component repeatedly calls setState inside componentWillUpdate or componentDidUpdate. React limits the number of nested updates to prevent infinite loops.");
+      nestedPassiveUpdateCount > NESTED_PASSIVE_UPDATE_LIMIT && (nestedPassiveUpdateCount = 0, rootWithPassiveNestedUpdates = null, console.error("Maximum update depth exceeded. This can happen when a component calls setState inside useEffect, but useEffect either doesn't have a dependency array, or one of the dependencies changes on every render."));
+      null === sourceFiber.alternate && 0 !== (sourceFiber.flags & 4098) && warnAboutUpdateOnNotYetMountedFiberInDEV(sourceFiber);
+      for (var node = sourceFiber, parent = node.return; null !== parent;) null === node.alternate && 0 !== (node.flags & 4098) && warnAboutUpdateOnNotYetMountedFiberInDEV(sourceFiber), node = parent, parent = node.return;
+      return 3 === node.tag ? node.stateNode : null;
+    }
+    function initializeUpdateQueue(fiber) {
+      fiber.updateQueue = {
+        baseState: fiber.memoizedState,
+        firstBaseUpdate: null,
+        lastBaseUpdate: null,
+        shared: {
+          pending: null,
+          lanes: 0,
+          hiddenCallbacks: null
+        },
+        callbacks: null
+      };
+    }
+    function cloneUpdateQueue(current, workInProgress) {
+      current = current.updateQueue;
+      workInProgress.updateQueue === current && (workInProgress.updateQueue = {
+        baseState: current.baseState,
+        firstBaseUpdate: current.firstBaseUpdate,
+        lastBaseUpdate: current.lastBaseUpdate,
+        shared: current.shared,
+        callbacks: null
+      });
+    }
+    function createUpdate(lane) {
+      return {
+        lane: lane,
+        tag: UpdateState,
+        payload: null,
+        callback: null,
+        next: null
+      };
+    }
+    function enqueueUpdate(fiber, update, lane) {
+      var updateQueue = fiber.updateQueue;
+      if (null === updateQueue) return null;
+      updateQueue = updateQueue.shared;
+      if (currentlyProcessingQueue === updateQueue && !didWarnUpdateInsideUpdate) {
+        var componentName = getComponentNameFromFiber(fiber);
+        console.error("An update (setState, replaceState, or forceUpdate) was scheduled from inside an update function. Update functions should be pure, with zero side-effects. Consider using componentDidUpdate or a callback.\n\nPlease update the following component: %s", componentName);
+        didWarnUpdateInsideUpdate = !0;
+      }
+      if ((executionContext & RenderContext) !== NoContext) return componentName = updateQueue.pending, null === componentName ? update.next = update : (update.next = componentName.next, componentName.next = update), updateQueue.pending = update, update = getRootForUpdatedFiber(fiber), markUpdateLaneFromFiberToRoot(fiber, null, lane), update;
+      enqueueUpdate$1(fiber, updateQueue, update, lane);
+      return getRootForUpdatedFiber(fiber);
+    }
+    function entangleTransitions(root, fiber, lane) {
+      fiber = fiber.updateQueue;
+      if (null !== fiber && (fiber = fiber.shared, 0 !== (lane & 4194048))) {
+        var queueLanes = fiber.lanes;
+        queueLanes &= root.pendingLanes;
+        lane |= queueLanes;
+        fiber.lanes = lane;
+        markRootEntangled(root, lane);
+      }
+    }
+    function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
+      var queue = workInProgress.updateQueue,
+        current = workInProgress.alternate;
+      if (null !== current && (current = current.updateQueue, queue === current)) {
+        var newFirst = null,
+          newLast = null;
+        queue = queue.firstBaseUpdate;
+        if (null !== queue) {
+          do {
+            var clone = {
+              lane: queue.lane,
+              tag: queue.tag,
+              payload: queue.payload,
+              callback: null,
+              next: null
+            };
+            null === newLast ? newFirst = newLast = clone : newLast = newLast.next = clone;
+            queue = queue.next;
+          } while (null !== queue);
+          null === newLast ? newFirst = newLast = capturedUpdate : newLast = newLast.next = capturedUpdate;
+        } else newFirst = newLast = capturedUpdate;
+        queue = {
+          baseState: current.baseState,
+          firstBaseUpdate: newFirst,
+          lastBaseUpdate: newLast,
+          shared: current.shared,
+          callbacks: current.callbacks
+        };
+        workInProgress.updateQueue = queue;
+        return;
+      }
+      workInProgress = queue.lastBaseUpdate;
+      null === workInProgress ? queue.firstBaseUpdate = capturedUpdate : workInProgress.next = capturedUpdate;
+      queue.lastBaseUpdate = capturedUpdate;
+    }
+    function suspendIfUpdateReadFromEntangledAsyncAction() {
+      if (didReadFromEntangledAsyncAction) {
+        var entangledActionThenable = currentEntangledActionThenable;
+        if (null !== entangledActionThenable) throw entangledActionThenable;
+      }
+    }
+    function processUpdateQueue(workInProgress, props, instance$jscomp$0, renderLanes) {
+      didReadFromEntangledAsyncAction = !1;
+      var queue = workInProgress.updateQueue;
+      hasForceUpdate = !1;
+      currentlyProcessingQueue = queue.shared;
+      var firstBaseUpdate = queue.firstBaseUpdate,
+        lastBaseUpdate = queue.lastBaseUpdate,
+        pendingQueue = queue.shared.pending;
+      if (null !== pendingQueue) {
+        queue.shared.pending = null;
+        var lastPendingUpdate = pendingQueue,
+          firstPendingUpdate = lastPendingUpdate.next;
+        lastPendingUpdate.next = null;
+        null === lastBaseUpdate ? firstBaseUpdate = firstPendingUpdate : lastBaseUpdate.next = firstPendingUpdate;
+        lastBaseUpdate = lastPendingUpdate;
+        var current = workInProgress.alternate;
+        null !== current && (current = current.updateQueue, pendingQueue = current.lastBaseUpdate, pendingQueue !== lastBaseUpdate && (null === pendingQueue ? current.firstBaseUpdate = firstPendingUpdate : pendingQueue.next = firstPendingUpdate, current.lastBaseUpdate = lastPendingUpdate));
+      }
+      if (null !== firstBaseUpdate) {
+        var newState = queue.baseState;
+        lastBaseUpdate = 0;
+        current = firstPendingUpdate = lastPendingUpdate = null;
+        pendingQueue = firstBaseUpdate;
+        do {
+          var updateLane = pendingQueue.lane & -536870913,
+            isHiddenUpdate = updateLane !== pendingQueue.lane;
+          if (isHiddenUpdate ? (workInProgressRootRenderLanes & updateLane) === updateLane : (renderLanes & updateLane) === updateLane) {
+            0 !== updateLane && updateLane === currentEntangledLane && (didReadFromEntangledAsyncAction = !0);
+            null !== current && (current = current.next = {
+              lane: 0,
+              tag: pendingQueue.tag,
+              payload: pendingQueue.payload,
+              callback: null,
+              next: null
+            });
+            a: {
+              updateLane = workInProgress;
+              var partialState = pendingQueue;
+              var nextProps = props,
+                instance = instance$jscomp$0;
+              switch (partialState.tag) {
+                case ReplaceState:
+                  partialState = partialState.payload;
+                  if ("function" === typeof partialState) {
+                    isDisallowedContextReadInDEV = !0;
+                    var nextState = partialState.call(instance, newState, nextProps);
+                    if (updateLane.mode & StrictLegacyMode) {
+                      setIsStrictModeForDevtools(!0);
+                      try {
+                        partialState.call(instance, newState, nextProps);
+                      } finally {
+                        setIsStrictModeForDevtools(!1);
+                      }
+                    }
+                    isDisallowedContextReadInDEV = !1;
+                    newState = nextState;
+                    break a;
+                  }
+                  newState = partialState;
+                  break a;
+                case CaptureUpdate:
+                  updateLane.flags = updateLane.flags & -65537 | 128;
+                case UpdateState:
+                  nextState = partialState.payload;
+                  if ("function" === typeof nextState) {
+                    isDisallowedContextReadInDEV = !0;
+                    partialState = nextState.call(instance, newState, nextProps);
+                    if (updateLane.mode & StrictLegacyMode) {
+                      setIsStrictModeForDevtools(!0);
+                      try {
+                        nextState.call(instance, newState, nextProps);
+                      } finally {
+                        setIsStrictModeForDevtools(!1);
+                      }
+                    }
+                    isDisallowedContextReadInDEV = !1;
+                  } else partialState = nextState;
+                  if (null === partialState || void 0 === partialState) break a;
+                  newState = assign({}, newState, partialState);
+                  break a;
+                case ForceUpdate:
+                  hasForceUpdate = !0;
+              }
+            }
+            updateLane = pendingQueue.callback;
+            null !== updateLane && (workInProgress.flags |= 64, isHiddenUpdate && (workInProgress.flags |= 8192), isHiddenUpdate = queue.callbacks, null === isHiddenUpdate ? queue.callbacks = [updateLane] : isHiddenUpdate.push(updateLane));
+          } else isHiddenUpdate = {
+            lane: updateLane,
+            tag: pendingQueue.tag,
+            payload: pendingQueue.payload,
+            callback: pendingQueue.callback,
+            next: null
+          }, null === current ? (firstPendingUpdate = current = isHiddenUpdate, lastPendingUpdate = newState) : current = current.next = isHiddenUpdate, lastBaseUpdate |= updateLane;
+          pendingQueue = pendingQueue.next;
+          if (null === pendingQueue) if (pendingQueue = queue.shared.pending, null === pendingQueue) break;else isHiddenUpdate = pendingQueue, pendingQueue = isHiddenUpdate.next, isHiddenUpdate.next = null, queue.lastBaseUpdate = isHiddenUpdate, queue.shared.pending = null;
+        } while (1);
+        null === current && (lastPendingUpdate = newState);
+        queue.baseState = lastPendingUpdate;
+        queue.firstBaseUpdate = firstPendingUpdate;
+        queue.lastBaseUpdate = current;
+        null === firstBaseUpdate && (queue.shared.lanes = 0);
+        workInProgressRootSkippedLanes |= lastBaseUpdate;
+        workInProgress.lanes = lastBaseUpdate;
+        workInProgress.memoizedState = newState;
+      }
+      currentlyProcessingQueue = null;
+    }
+    function callCallback(callback, context) {
+      if ("function" !== typeof callback) throw Error("Invalid argument passed as callback. Expected a function. Instead received: " + callback);
+      callback.call(context);
+    }
+    function commitHiddenCallbacks(updateQueue, context) {
+      var hiddenCallbacks = updateQueue.shared.hiddenCallbacks;
+      if (null !== hiddenCallbacks) for (updateQueue.shared.hiddenCallbacks = null, updateQueue = 0; updateQueue < hiddenCallbacks.length; updateQueue++) callCallback(hiddenCallbacks[updateQueue], context);
+    }
+    function commitCallbacks(updateQueue, context) {
+      var callbacks = updateQueue.callbacks;
+      if (null !== callbacks) for (updateQueue.callbacks = null, updateQueue = 0; updateQueue < callbacks.length; updateQueue++) callCallback(callbacks[updateQueue], context);
+    }
+    function pushHiddenContext(fiber, context) {
+      var prevEntangledRenderLanes = entangledRenderLanes;
+      push(prevEntangledRenderLanesCursor, prevEntangledRenderLanes, fiber);
+      push(currentTreeHiddenStackCursor, context, fiber);
+      entangledRenderLanes = prevEntangledRenderLanes | context.baseLanes;
+    }
+    function reuseHiddenContextOnStack(fiber) {
+      push(prevEntangledRenderLanesCursor, entangledRenderLanes, fiber);
+      push(currentTreeHiddenStackCursor, currentTreeHiddenStackCursor.current, fiber);
+    }
+    function popHiddenContext(fiber) {
+      entangledRenderLanes = prevEntangledRenderLanesCursor.current;
+      pop(currentTreeHiddenStackCursor, fiber);
+      pop(prevEntangledRenderLanesCursor, fiber);
+    }
+    function mountHookTypesDev() {
+      var hookName = currentHookNameInDev;
+      null === hookTypesDev ? hookTypesDev = [hookName] : hookTypesDev.push(hookName);
+    }
+    function updateHookTypesDev() {
+      var hookName = currentHookNameInDev;
+      if (null !== hookTypesDev && (hookTypesUpdateIndexDev++, hookTypesDev[hookTypesUpdateIndexDev] !== hookName)) {
+        var componentName = getComponentNameFromFiber(currentlyRenderingFiber);
+        if (!didWarnAboutMismatchedHooksForComponent.has(componentName) && (didWarnAboutMismatchedHooksForComponent.add(componentName), null !== hookTypesDev)) {
+          for (var table = "", i = 0; i <= hookTypesUpdateIndexDev; i++) {
+            var oldHookName = hookTypesDev[i],
+              newHookName = i === hookTypesUpdateIndexDev ? hookName : oldHookName;
+            for (oldHookName = i + 1 + ". " + oldHookName; 30 > oldHookName.length;) oldHookName += " ";
+            oldHookName += newHookName + "\n";
+            table += oldHookName;
+          }
+          console.error("React has detected a change in the order of Hooks called by %s. This will lead to bugs and errors if not fixed. For more information, read the Rules of Hooks: https://react.dev/link/rules-of-hooks\n\n   Previous render            Next render\n   ------------------------------------------------------\n%s   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", componentName, table);
+        }
+      }
+    }
+    function checkDepsAreArrayDev(deps) {
+      void 0 === deps || null === deps || isArrayImpl(deps) || console.error("%s received a final argument that is not an array (instead, received `%s`). When specified, the final argument must be an array.", currentHookNameInDev, typeof deps);
+    }
+    function warnOnUseFormStateInDev() {
+      var componentName = getComponentNameFromFiber(currentlyRenderingFiber);
+      didWarnAboutUseFormState.has(componentName) || (didWarnAboutUseFormState.add(componentName), console.error("ReactDOM.useFormState has been renamed to React.useActionState. Please update %s to use React.useActionState.", componentName));
+    }
+    function throwInvalidHookError() {
+      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://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.");
+    }
+    function areHookInputsEqual(nextDeps, prevDeps) {
+      if (ignorePreviousDependencies) return !1;
+      if (null === prevDeps) return console.error("%s received a final argument during this render, but not during the previous render. Even though the final argument is optional, its type cannot change between renders.", currentHookNameInDev), !1;
+      nextDeps.length !== prevDeps.length && console.error("The final argument passed to %s changed size between renders. The order and size of this array must remain constant.\n\nPrevious: %s\nIncoming: %s", currentHookNameInDev, "[" + prevDeps.join(", ") + "]", "[" + nextDeps.join(", ") + "]");
+      for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) if (!objectIs(nextDeps[i], prevDeps[i])) return !1;
+      return !0;
+    }
+    function renderWithHooks(current, workInProgress, Component, props, secondArg, nextRenderLanes) {
+      renderLanes = nextRenderLanes;
+      currentlyRenderingFiber = workInProgress;
+      hookTypesDev = null !== current ? current._debugHookTypes : null;
+      hookTypesUpdateIndexDev = -1;
+      ignorePreviousDependencies = null !== current && current.type !== workInProgress.type;
+      if ("[object AsyncFunction]" === Object.prototype.toString.call(Component) || "[object AsyncGeneratorFunction]" === Object.prototype.toString.call(Component)) nextRenderLanes = getComponentNameFromFiber(currentlyRenderingFiber), didWarnAboutAsyncClientComponent.has(nextRenderLanes) || (didWarnAboutAsyncClientComponent.add(nextRenderLanes), console.error("%s is an async Client Component. Only Server Components can be async at the moment. This error is often caused by accidentally adding `'use client'` to a module that was originally written for the server.", null === nextRenderLanes ? "An unknown Component" : "<" + nextRenderLanes + ">"));
+      workInProgress.memoizedState = null;
+      workInProgress.updateQueue = null;
+      workInProgress.lanes = 0;
+      ReactSharedInternals.H = null !== current && null !== current.memoizedState ? HooksDispatcherOnUpdateInDEV : null !== hookTypesDev ? HooksDispatcherOnMountWithHookTypesInDEV : HooksDispatcherOnMountInDEV;
+      shouldDoubleInvokeUserFnsInHooksDEV = nextRenderLanes = 0 !== (workInProgress.mode & StrictLegacyMode);
+      var children = callComponentInDEV(Component, props, secondArg);
+      shouldDoubleInvokeUserFnsInHooksDEV = !1;
+      didScheduleRenderPhaseUpdateDuringThisPass && (children = renderWithHooksAgain(workInProgress, Component, props, secondArg));
+      if (nextRenderLanes) {
+        setIsStrictModeForDevtools(!0);
+        try {
+          children = renderWithHooksAgain(workInProgress, Component, props, secondArg);
+        } finally {
+          setIsStrictModeForDevtools(!1);
+        }
+      }
+      finishRenderingHooks(current, workInProgress);
+      return children;
+    }
+    function finishRenderingHooks(current, workInProgress) {
+      workInProgress._debugHookTypes = hookTypesDev;
+      null === workInProgress.dependencies ? null !== thenableState$1 && (workInProgress.dependencies = {
+        lanes: 0,
+        firstContext: null,
+        _debugThenableState: thenableState$1
+      }) : workInProgress.dependencies._debugThenableState = thenableState$1;
+      ReactSharedInternals.H = ContextOnlyDispatcher;
+      var didRenderTooFewHooks = null !== currentHook && null !== currentHook.next;
+      renderLanes = 0;
+      hookTypesDev = currentHookNameInDev = workInProgressHook = currentHook = currentlyRenderingFiber = null;
+      hookTypesUpdateIndexDev = -1;
+      null !== current && (current.flags & 65011712) !== (workInProgress.flags & 65011712) && 0 !== (current.mode & 1) && console.error("Internal React error: Expected static flag was missing. Please notify the React team.");
+      didScheduleRenderPhaseUpdate = !1;
+      thenableIndexCounter$1 = 0;
+      thenableState$1 = null;
+      if (didRenderTooFewHooks) throw Error("Rendered fewer hooks than expected. This may be caused by an accidental early return statement.");
+      null === current || didReceiveUpdate || (current = current.dependencies, null !== current && checkIfContextChanged(current) && (didReceiveUpdate = !0));
+      needsToResetSuspendedThenableDEV ? (needsToResetSuspendedThenableDEV = !1, current = !0) : current = !1;
+      current && (workInProgress = getComponentNameFromFiber(workInProgress) || "Unknown", didWarnAboutUseWrappedInTryCatch.has(workInProgress) || didWarnAboutAsyncClientComponent.has(workInProgress) || (didWarnAboutUseWrappedInTryCatch.add(workInProgress), console.error("`use` was called from inside a try/catch block. This is not allowed and can lead to unexpected behavior. To handle errors triggered by `use`, wrap your component in a error boundary.")));
+    }
+    function renderWithHooksAgain(workInProgress, Component, props, secondArg) {
+      currentlyRenderingFiber = workInProgress;
+      var numberOfReRenders = 0;
+      do {
+        didScheduleRenderPhaseUpdateDuringThisPass && (thenableState$1 = null);
+        thenableIndexCounter$1 = 0;
+        didScheduleRenderPhaseUpdateDuringThisPass = !1;
+        if (numberOfReRenders >= RE_RENDER_LIMIT) throw Error("Too many re-renders. React limits the number of renders to prevent an infinite loop.");
+        numberOfReRenders += 1;
+        ignorePreviousDependencies = !1;
+        workInProgressHook = currentHook = null;
+        if (null != workInProgress.updateQueue) {
+          var children = workInProgress.updateQueue;
+          children.lastEffect = null;
+          children.events = null;
+          children.stores = null;
+          null != children.memoCache && (children.memoCache.index = 0);
+        }
+        hookTypesUpdateIndexDev = -1;
+        ReactSharedInternals.H = HooksDispatcherOnRerenderInDEV;
+        children = callComponentInDEV(Component, props, secondArg);
+      } while (didScheduleRenderPhaseUpdateDuringThisPass);
+      return children;
+    }
+    function TransitionAwareHostComponent() {
+      var dispatcher = ReactSharedInternals.H,
+        maybeThenable = dispatcher.useState()[0];
+      maybeThenable = "function" === typeof maybeThenable.then ? useThenable(maybeThenable) : maybeThenable;
+      dispatcher = dispatcher.useState()[0];
+      (null !== currentHook ? currentHook.memoizedState : null) !== dispatcher && (currentlyRenderingFiber.flags |= 1024);
+      return maybeThenable;
+    }
+    function bailoutHooks(current, workInProgress, lanes) {
+      workInProgress.updateQueue = current.updateQueue;
+      workInProgress.flags = 0 !== (workInProgress.mode & 16) ? workInProgress.flags & -402655237 : workInProgress.flags & -2053;
+      current.lanes &= ~lanes;
+    }
+    function resetHooksOnUnwind(workInProgress) {
+      if (didScheduleRenderPhaseUpdate) {
+        for (workInProgress = workInProgress.memoizedState; null !== workInProgress;) {
+          var queue = workInProgress.queue;
+          null !== queue && (queue.pending = null);
+          workInProgress = workInProgress.next;
+        }
+        didScheduleRenderPhaseUpdate = !1;
+      }
+      renderLanes = 0;
+      hookTypesDev = workInProgressHook = currentHook = currentlyRenderingFiber = null;
+      hookTypesUpdateIndexDev = -1;
+      currentHookNameInDev = null;
+      didScheduleRenderPhaseUpdateDuringThisPass = !1;
+      thenableIndexCounter$1 = 0;
+      thenableState$1 = null;
+    }
+    function mountWorkInProgressHook() {
+      var hook = {
+        memoizedState: null,
+        baseState: null,
+        baseQueue: null,
+        queue: null,
+        next: null
+      };
+      null === workInProgressHook ? currentlyRenderingFiber.memoizedState = workInProgressHook = hook : workInProgressHook = workInProgressHook.next = hook;
+      return workInProgressHook;
+    }
+    function updateWorkInProgressHook() {
+      if (null === currentHook) {
+        var nextCurrentHook = currentlyRenderingFiber.alternate;
+        nextCurrentHook = null !== nextCurrentHook ? nextCurrentHook.memoizedState : null;
+      } else nextCurrentHook = currentHook.next;
+      var nextWorkInProgressHook = null === workInProgressHook ? currentlyRenderingFiber.memoizedState : workInProgressHook.next;
+      if (null !== nextWorkInProgressHook) workInProgressHook = nextWorkInProgressHook, currentHook = nextCurrentHook;else {
+        if (null === nextCurrentHook) {
+          if (null === currentlyRenderingFiber.alternate) throw Error("Update hook called on initial render. This is likely a bug in React. Please file an issue.");
+          throw Error("Rendered more hooks than during the previous render.");
+        }
+        currentHook = nextCurrentHook;
+        nextCurrentHook = {
+          memoizedState: currentHook.memoizedState,
+          baseState: currentHook.baseState,
+          baseQueue: currentHook.baseQueue,
+          queue: currentHook.queue,
+          next: null
+        };
+        null === workInProgressHook ? currentlyRenderingFiber.memoizedState = workInProgressHook = nextCurrentHook : workInProgressHook = workInProgressHook.next = nextCurrentHook;
+      }
+      return workInProgressHook;
+    }
+    function createFunctionComponentUpdateQueue() {
+      return {
+        lastEffect: null,
+        events: null,
+        stores: null,
+        memoCache: null
+      };
+    }
+    function useThenable(thenable) {
+      var index = thenableIndexCounter$1;
+      thenableIndexCounter$1 += 1;
+      null === thenableState$1 && (thenableState$1 = createThenableState());
+      thenable = trackUsedThenable(thenableState$1, thenable, index);
+      index = currentlyRenderingFiber;
+      null === (null === workInProgressHook ? index.memoizedState : workInProgressHook.next) && (index = index.alternate, ReactSharedInternals.H = null !== index && null !== index.memoizedState ? HooksDispatcherOnUpdateInDEV : HooksDispatcherOnMountInDEV);
+      return thenable;
+    }
+    function _use(usable) {
+      if (null !== usable && "object" === typeof usable) {
+        if ("function" === typeof usable.then) return useThenable(usable);
+        if (usable.$$typeof === REACT_CONTEXT_TYPE) return _readContext(usable);
+      }
+      throw Error("An unsupported type was passed to use(): " + String(usable));
+    }
+    function _useMemoCache(size) {
+      var memoCache = null,
+        updateQueue = currentlyRenderingFiber.updateQueue;
+      null !== updateQueue && (memoCache = updateQueue.memoCache);
+      if (null == memoCache) {
+        var current = currentlyRenderingFiber.alternate;
+        null !== current && (current = current.updateQueue, null !== current && (current = current.memoCache, null != current && (memoCache = {
+          data: current.data.map(function (array) {
+            return array.slice();
+          }),
+          index: 0
+        })));
+      }
+      null == memoCache && (memoCache = {
+        data: [],
+        index: 0
+      });
+      null === updateQueue && (updateQueue = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = updateQueue);
+      updateQueue.memoCache = memoCache;
+      updateQueue = memoCache.data[memoCache.index];
+      if (void 0 === updateQueue || ignorePreviousDependencies) for (updateQueue = memoCache.data[memoCache.index] = Array(size), current = 0; current < size; current++) updateQueue[current] = REACT_MEMO_CACHE_SENTINEL;else updateQueue.length !== size && console.error("Expected a constant size argument for each invocation of useMemoCache. The previous cache was allocated with size %s but size %s was requested.", updateQueue.length, size);
+      memoCache.index++;
+      return updateQueue;
+    }
+    function basicStateReducer(state, action) {
+      return "function" === typeof action ? action(state) : action;
+    }
+    function mountReducer(reducer, initialArg, init) {
+      var hook = mountWorkInProgressHook();
+      if (void 0 !== init) {
+        var initialState = init(initialArg);
+        if (shouldDoubleInvokeUserFnsInHooksDEV) {
+          setIsStrictModeForDevtools(!0);
+          try {
+            init(initialArg);
+          } finally {
+            setIsStrictModeForDevtools(!1);
+          }
+        }
+      } else initialState = initialArg;
+      hook.memoizedState = hook.baseState = initialState;
+      reducer = {
+        pending: null,
+        lanes: 0,
+        dispatch: null,
+        lastRenderedReducer: reducer,
+        lastRenderedState: initialState
+      };
+      hook.queue = reducer;
+      reducer = reducer.dispatch = dispatchReducerAction.bind(null, currentlyRenderingFiber, reducer);
+      return [hook.memoizedState, reducer];
+    }
+    function updateReducer(reducer) {
+      var hook = updateWorkInProgressHook();
+      return updateReducerImpl(hook, currentHook, reducer);
+    }
+    function updateReducerImpl(hook, current, reducer) {
+      var queue = hook.queue;
+      if (null === queue) throw Error("Should have a queue. You are likely calling Hooks conditionally, which is not allowed. (https://react.dev/link/invalid-hook-call)");
+      queue.lastRenderedReducer = reducer;
+      var baseQueue = hook.baseQueue,
+        pendingQueue = queue.pending;
+      if (null !== pendingQueue) {
+        if (null !== baseQueue) {
+          var baseFirst = baseQueue.next;
+          baseQueue.next = pendingQueue.next;
+          pendingQueue.next = baseFirst;
+        }
+        current.baseQueue !== baseQueue && console.error("Internal error: Expected work-in-progress queue to be a clone. This is a bug in React.");
+        current.baseQueue = baseQueue = pendingQueue;
+        queue.pending = null;
+      }
+      pendingQueue = hook.baseState;
+      if (null === baseQueue) hook.memoizedState = pendingQueue;else {
+        current = baseQueue.next;
+        var newBaseQueueFirst = baseFirst = null,
+          newBaseQueueLast = null,
+          update = current,
+          didReadFromEntangledAsyncAction = !1;
+        do {
+          var updateLane = update.lane & -536870913;
+          if (updateLane !== update.lane ? (workInProgressRootRenderLanes & updateLane) === updateLane : (renderLanes & updateLane) === updateLane) {
+            var revertLane = update.revertLane;
+            if (0 === revertLane) null !== newBaseQueueLast && (newBaseQueueLast = newBaseQueueLast.next = {
+              lane: 0,
+              revertLane: 0,
+              action: update.action,
+              hasEagerState: update.hasEagerState,
+              eagerState: update.eagerState,
+              next: null
+            }), updateLane === currentEntangledLane && (didReadFromEntangledAsyncAction = !0);else if ((renderLanes & revertLane) === revertLane) {
+              update = update.next;
+              revertLane === currentEntangledLane && (didReadFromEntangledAsyncAction = !0);
+              continue;
+            } else updateLane = {
+              lane: 0,
+              revertLane: update.revertLane,
+              action: update.action,
+              hasEagerState: update.hasEagerState,
+              eagerState: update.eagerState,
+              next: null
+            }, null === newBaseQueueLast ? (newBaseQueueFirst = newBaseQueueLast = updateLane, baseFirst = pendingQueue) : newBaseQueueLast = newBaseQueueLast.next = updateLane, currentlyRenderingFiber.lanes |= revertLane, workInProgressRootSkippedLanes |= revertLane;
+            updateLane = update.action;
+            shouldDoubleInvokeUserFnsInHooksDEV && reducer(pendingQueue, updateLane);
+            pendingQueue = update.hasEagerState ? update.eagerState : reducer(pendingQueue, updateLane);
+          } else revertLane = {
+            lane: updateLane,
+            revertLane: update.revertLane,
+            action: update.action,
+            hasEagerState: update.hasEagerState,
+            eagerState: update.eagerState,
+            next: null
+          }, null === newBaseQueueLast ? (newBaseQueueFirst = newBaseQueueLast = revertLane, baseFirst = pendingQueue) : newBaseQueueLast = newBaseQueueLast.next = revertLane, currentlyRenderingFiber.lanes |= updateLane, workInProgressRootSkippedLanes |= updateLane;
+          update = update.next;
+        } while (null !== update && update !== current);
+        null === newBaseQueueLast ? baseFirst = pendingQueue : newBaseQueueLast.next = newBaseQueueFirst;
+        if (!objectIs(pendingQueue, hook.memoizedState) && (didReceiveUpdate = !0, didReadFromEntangledAsyncAction && (reducer = currentEntangledActionThenable, null !== reducer))) throw reducer;
+        hook.memoizedState = pendingQueue;
+        hook.baseState = baseFirst;
+        hook.baseQueue = newBaseQueueLast;
+        queue.lastRenderedState = pendingQueue;
+      }
+      null === baseQueue && (queue.lanes = 0);
+      return [hook.memoizedState, queue.dispatch];
+    }
+    function rerenderReducer(reducer) {
+      var hook = updateWorkInProgressHook(),
+        queue = hook.queue;
+      if (null === queue) throw Error("Should have a queue. You are likely calling Hooks conditionally, which is not allowed. (https://react.dev/link/invalid-hook-call)");
+      queue.lastRenderedReducer = reducer;
+      var dispatch = queue.dispatch,
+        lastRenderPhaseUpdate = queue.pending,
+        newState = hook.memoizedState;
+      if (null !== lastRenderPhaseUpdate) {
+        queue.pending = null;
+        var update = lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+        do newState = reducer(newState, update.action), update = update.next; while (update !== lastRenderPhaseUpdate);
+        objectIs(newState, hook.memoizedState) || (didReceiveUpdate = !0);
+        hook.memoizedState = newState;
+        null === hook.baseQueue && (hook.baseState = newState);
+        queue.lastRenderedState = newState;
+      }
+      return [newState, dispatch];
+    }
+    function mountSyncExternalStore(subscribe, getSnapshot) {
+      var fiber = currentlyRenderingFiber,
+        hook = mountWorkInProgressHook();
+      var nextSnapshot = getSnapshot();
+      if (!didWarnUncachedGetSnapshot) {
+        var cachedSnapshot = getSnapshot();
+        objectIs(nextSnapshot, cachedSnapshot) || (console.error("The result of getSnapshot should be cached to avoid an infinite loop"), didWarnUncachedGetSnapshot = !0);
+      }
+      if (null === workInProgressRoot) throw Error("Expected a work-in-progress root. This is a bug in React. Please file an issue.");
+      0 !== (workInProgressRootRenderLanes & 124) || pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+      hook.memoizedState = nextSnapshot;
+      cachedSnapshot = {
+        value: nextSnapshot,
+        getSnapshot: getSnapshot
+      };
+      hook.queue = cachedSnapshot;
+      mountEffect(subscribeToStore.bind(null, fiber, cachedSnapshot, subscribe), [subscribe]);
+      fiber.flags |= 2048;
+      pushSimpleEffect(HasEffect | Passive, createEffectInstance(), updateStoreInstance.bind(null, fiber, cachedSnapshot, nextSnapshot, getSnapshot), null);
+      return nextSnapshot;
+    }
+    function updateSyncExternalStore(subscribe, getSnapshot) {
+      var fiber = currentlyRenderingFiber,
+        hook = updateWorkInProgressHook();
+      var nextSnapshot = getSnapshot();
+      if (!didWarnUncachedGetSnapshot) {
+        var cachedSnapshot = getSnapshot();
+        objectIs(nextSnapshot, cachedSnapshot) || (console.error("The result of getSnapshot should be cached to avoid an infinite loop"), didWarnUncachedGetSnapshot = !0);
+      }
+      if (cachedSnapshot = !objectIs((currentHook || hook).memoizedState, nextSnapshot)) hook.memoizedState = nextSnapshot, didReceiveUpdate = !0;
+      hook = hook.queue;
+      var create = subscribeToStore.bind(null, fiber, hook, subscribe);
+      updateEffectImpl(2048, Passive, create, [subscribe]);
+      if (hook.getSnapshot !== getSnapshot || cachedSnapshot || null !== workInProgressHook && workInProgressHook.memoizedState.tag & HasEffect) {
+        fiber.flags |= 2048;
+        pushSimpleEffect(HasEffect | Passive, createEffectInstance(), updateStoreInstance.bind(null, fiber, hook, nextSnapshot, getSnapshot), null);
+        if (null === workInProgressRoot) throw Error("Expected a work-in-progress root. This is a bug in React. Please file an issue.");
+        0 !== (renderLanes & 124) || pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+      }
+      return nextSnapshot;
+    }
+    function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
+      fiber.flags |= 16384;
+      fiber = {
+        getSnapshot: getSnapshot,
+        value: renderedSnapshot
+      };
+      getSnapshot = currentlyRenderingFiber.updateQueue;
+      null === getSnapshot ? (getSnapshot = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = getSnapshot, getSnapshot.stores = [fiber]) : (renderedSnapshot = getSnapshot.stores, null === renderedSnapshot ? getSnapshot.stores = [fiber] : renderedSnapshot.push(fiber));
+    }
+    function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
+      inst.value = nextSnapshot;
+      inst.getSnapshot = getSnapshot;
+      checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
+    }
+    function subscribeToStore(fiber, inst, subscribe) {
+      return subscribe(function () {
+        checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
+      });
+    }
+    function checkIfSnapshotChanged(inst) {
+      var latestGetSnapshot = inst.getSnapshot;
+      inst = inst.value;
+      try {
+        var nextValue = latestGetSnapshot();
+        return !objectIs(inst, nextValue);
+      } catch (error) {
+        return !0;
+      }
+    }
+    function forceStoreRerender(fiber) {
+      var root = enqueueConcurrentRenderForLane(fiber, 2);
+      null !== root && scheduleUpdateOnFiber(root, fiber, 2);
+    }
+    function mountStateImpl(initialState) {
+      var hook = mountWorkInProgressHook();
+      if ("function" === typeof initialState) {
+        var initialStateInitializer = initialState;
+        initialState = initialStateInitializer();
+        if (shouldDoubleInvokeUserFnsInHooksDEV) {
+          setIsStrictModeForDevtools(!0);
+          try {
+            initialStateInitializer();
+          } finally {
+            setIsStrictModeForDevtools(!1);
+          }
+        }
+      }
+      hook.memoizedState = hook.baseState = initialState;
+      hook.queue = {
+        pending: null,
+        lanes: 0,
+        dispatch: null,
+        lastRenderedReducer: basicStateReducer,
+        lastRenderedState: initialState
+      };
+      return hook;
+    }
+    function mountState(initialState) {
+      initialState = mountStateImpl(initialState);
+      var queue = initialState.queue,
+        dispatch = dispatchSetState.bind(null, currentlyRenderingFiber, queue);
+      queue.dispatch = dispatch;
+      return [initialState.memoizedState, dispatch];
+    }
+    function mountOptimistic(passthrough) {
+      var hook = mountWorkInProgressHook();
+      hook.memoizedState = hook.baseState = passthrough;
+      var queue = {
+        pending: null,
+        lanes: 0,
+        dispatch: null,
+        lastRenderedReducer: null,
+        lastRenderedState: null
+      };
+      hook.queue = queue;
+      hook = dispatchOptimisticSetState.bind(null, currentlyRenderingFiber, !0, queue);
+      queue.dispatch = hook;
+      return [passthrough, hook];
+    }
+    function updateOptimistic(passthrough, reducer) {
+      var hook = updateWorkInProgressHook();
+      return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
+    }
+    function updateOptimisticImpl(hook, current, passthrough, reducer) {
+      hook.baseState = passthrough;
+      return updateReducerImpl(hook, currentHook, "function" === typeof reducer ? reducer : basicStateReducer);
+    }
+    function rerenderOptimistic(passthrough, reducer) {
+      var hook = updateWorkInProgressHook();
+      if (null !== currentHook) return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
+      hook.baseState = passthrough;
+      return [passthrough, hook.queue.dispatch];
+    }
+    function dispatchActionState(fiber, actionQueue, setPendingState, setState, payload) {
+      if (isRenderPhaseUpdate(fiber)) throw Error("Cannot update form state while rendering.");
+      fiber = actionQueue.action;
+      if (null !== fiber) {
+        var actionNode = {
+          payload: payload,
+          action: fiber,
+          next: null,
+          isTransition: !0,
+          status: "pending",
+          value: null,
+          reason: null,
+          listeners: [],
+          then: function then(listener) {
+            actionNode.listeners.push(listener);
+          }
+        };
+        null !== ReactSharedInternals.T ? setPendingState(!0) : actionNode.isTransition = !1;
+        setState(actionNode);
+        setPendingState = actionQueue.pending;
+        null === setPendingState ? (actionNode.next = actionQueue.pending = actionNode, runActionStateAction(actionQueue, actionNode)) : (actionNode.next = setPendingState.next, actionQueue.pending = setPendingState.next = actionNode);
+      }
+    }
+    function runActionStateAction(actionQueue, node) {
+      var action = node.action,
+        payload = node.payload,
+        prevState = actionQueue.state;
+      if (node.isTransition) {
+        var prevTransition = ReactSharedInternals.T,
+          currentTransition = {};
+        ReactSharedInternals.T = currentTransition;
+        ReactSharedInternals.T._updatedFibers = new Set();
+        try {
+          var returnValue = action(prevState, payload),
+            onStartTransitionFinish = ReactSharedInternals.S;
+          null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
+          handleActionReturnValue(actionQueue, node, returnValue);
+        } catch (error) {
+          onActionError(actionQueue, node, error);
+        } finally {
+          ReactSharedInternals.T = prevTransition, null === prevTransition && currentTransition._updatedFibers && (actionQueue = currentTransition._updatedFibers.size, currentTransition._updatedFibers.clear(), 10 < actionQueue && console.warn("Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table."));
+        }
+      } else try {
+        currentTransition = action(prevState, payload), handleActionReturnValue(actionQueue, node, currentTransition);
+      } catch (error$2) {
+        onActionError(actionQueue, node, error$2);
+      }
+    }
+    function handleActionReturnValue(actionQueue, node, returnValue) {
+      null !== returnValue && "object" === typeof returnValue && "function" === typeof returnValue.then ? (returnValue.then(function (nextState) {
+        onActionSuccess(actionQueue, node, nextState);
+      }, function (error) {
+        return onActionError(actionQueue, node, error);
+      }), node.isTransition || console.error("An async function with useActionState was called outside of a transition. This is likely not what you intended (for example, isPending will not update correctly). Either call the returned function inside startTransition, or pass it to an `action` or `formAction` prop.")) : onActionSuccess(actionQueue, node, returnValue);
+    }
+    function onActionSuccess(actionQueue, actionNode, nextState) {
+      actionNode.status = "fulfilled";
+      actionNode.value = nextState;
+      notifyActionListeners(actionNode);
+      actionQueue.state = nextState;
+      actionNode = actionQueue.pending;
+      null !== actionNode && (nextState = actionNode.next, nextState === actionNode ? actionQueue.pending = null : (nextState = nextState.next, actionNode.next = nextState, runActionStateAction(actionQueue, nextState)));
+    }
+    function onActionError(actionQueue, actionNode, error) {
+      var last = actionQueue.pending;
+      actionQueue.pending = null;
+      if (null !== last) {
+        last = last.next;
+        do actionNode.status = "rejected", actionNode.reason = error, notifyActionListeners(actionNode), actionNode = actionNode.next; while (actionNode !== last);
+      }
+      actionQueue.action = null;
+    }
+    function notifyActionListeners(actionNode) {
+      actionNode = actionNode.listeners;
+      for (var i = 0; i < actionNode.length; i++) (0, actionNode[i])();
+    }
+    function actionStateReducer(oldState, newState) {
+      return newState;
+    }
+    function mountActionState(action, initialStateProp) {
+      var stateHook = mountWorkInProgressHook();
+      stateHook.memoizedState = stateHook.baseState = initialStateProp;
+      var stateQueue = {
+        pending: null,
+        lanes: 0,
+        dispatch: null,
+        lastRenderedReducer: actionStateReducer,
+        lastRenderedState: initialStateProp
+      };
+      stateHook.queue = stateQueue;
+      stateHook = dispatchSetState.bind(null, currentlyRenderingFiber, stateQueue);
+      stateQueue.dispatch = stateHook;
+      stateQueue = mountStateImpl(!1);
+      var setPendingState = dispatchOptimisticSetState.bind(null, currentlyRenderingFiber, !1, stateQueue.queue);
+      stateQueue = mountWorkInProgressHook();
+      var actionQueue = {
+        state: initialStateProp,
+        dispatch: null,
+        action: action,
+        pending: null
+      };
+      stateQueue.queue = actionQueue;
+      stateHook = dispatchActionState.bind(null, currentlyRenderingFiber, actionQueue, setPendingState, stateHook);
+      actionQueue.dispatch = stateHook;
+      stateQueue.memoizedState = action;
+      return [initialStateProp, stateHook, !1];
+    }
+    function updateActionState(action) {
+      var stateHook = updateWorkInProgressHook();
+      return updateActionStateImpl(stateHook, currentHook, action);
+    }
+    function updateActionStateImpl(stateHook, currentStateHook, action) {
+      currentStateHook = updateReducerImpl(stateHook, currentStateHook, actionStateReducer)[0];
+      stateHook = updateReducer(basicStateReducer)[0];
+      if ("object" === typeof currentStateHook && null !== currentStateHook && "function" === typeof currentStateHook.then) try {
+        var state = useThenable(currentStateHook);
+      } catch (x) {
+        if (x === SuspenseException) throw SuspenseActionException;
+        throw x;
+      } else state = currentStateHook;
+      currentStateHook = updateWorkInProgressHook();
+      var actionQueue = currentStateHook.queue,
+        dispatch = actionQueue.dispatch;
+      action !== currentStateHook.memoizedState && (currentlyRenderingFiber.flags |= 2048, pushSimpleEffect(HasEffect | Passive, createEffectInstance(), actionStateActionEffect.bind(null, actionQueue, action), null));
+      return [state, dispatch, stateHook];
+    }
+    function actionStateActionEffect(actionQueue, action) {
+      actionQueue.action = action;
+    }
+    function rerenderActionState(action) {
+      var stateHook = updateWorkInProgressHook(),
+        currentStateHook = currentHook;
+      if (null !== currentStateHook) return updateActionStateImpl(stateHook, currentStateHook, action);
+      updateWorkInProgressHook();
+      stateHook = stateHook.memoizedState;
+      currentStateHook = updateWorkInProgressHook();
+      var dispatch = currentStateHook.queue.dispatch;
+      currentStateHook.memoizedState = action;
+      return [stateHook, dispatch, !1];
+    }
+    function pushSimpleEffect(tag, inst, create, createDeps) {
+      tag = {
+        tag: tag,
+        create: create,
+        deps: createDeps,
+        inst: inst,
+        next: null
+      };
+      inst = currentlyRenderingFiber.updateQueue;
+      null === inst && (inst = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = inst);
+      create = inst.lastEffect;
+      null === create ? inst.lastEffect = tag.next = tag : (createDeps = create.next, create.next = tag, tag.next = createDeps, inst.lastEffect = tag);
+      return tag;
+    }
+    function createEffectInstance() {
+      return {
+        destroy: void 0,
+        resource: void 0
+      };
+    }
+    function mountRef(initialValue) {
+      var hook = mountWorkInProgressHook();
+      initialValue = {
+        current: initialValue
+      };
+      return hook.memoizedState = initialValue;
+    }
+    function mountEffectImpl(fiberFlags, hookFlags, create, createDeps) {
+      var hook = mountWorkInProgressHook();
+      createDeps = void 0 === createDeps ? null : createDeps;
+      currentlyRenderingFiber.flags |= fiberFlags;
+      hook.memoizedState = pushSimpleEffect(HasEffect | hookFlags, createEffectInstance(), create, createDeps);
+    }
+    function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
+      var hook = updateWorkInProgressHook();
+      deps = void 0 === deps ? null : deps;
+      var inst = hook.memoizedState.inst;
+      null !== currentHook && null !== deps && areHookInputsEqual(deps, currentHook.memoizedState.deps) ? hook.memoizedState = pushSimpleEffect(hookFlags, inst, create, deps) : (currentlyRenderingFiber.flags |= fiberFlags, hook.memoizedState = pushSimpleEffect(HasEffect | hookFlags, inst, create, deps));
+    }
+    function mountEffect(create, createDeps) {
+      0 !== (currentlyRenderingFiber.mode & 16) && 0 === (currentlyRenderingFiber.mode & 64) ? mountEffectImpl(276826112, Passive, create, createDeps) : mountEffectImpl(8390656, Passive, create, createDeps);
+    }
+    function mountLayoutEffect(create, deps) {
+      var fiberFlags = 4194308;
+      0 !== (currentlyRenderingFiber.mode & 16) && (fiberFlags |= 134217728);
+      return mountEffectImpl(fiberFlags, Layout, create, deps);
+    }
+    function imperativeHandleEffect(create, ref) {
+      if ("function" === typeof ref) {
+        create = create();
+        var refCleanup = ref(create);
+        return function () {
+          "function" === typeof refCleanup ? refCleanup() : ref(null);
+        };
+      }
+      if (null !== ref && void 0 !== ref) return ref.hasOwnProperty("current") || console.error("Expected useImperativeHandle() first argument to either be a ref callback or React.createRef() object. Instead received: %s.", "an object with keys {" + Object.keys(ref).join(", ") + "}"), create = create(), ref.current = create, function () {
+        ref.current = null;
+      };
+    }
+    function mountImperativeHandle(ref, create, deps) {
+      "function" !== typeof create && console.error("Expected useImperativeHandle() second argument to be a function that creates a handle. Instead received: %s.", null !== create ? typeof create : "null");
+      deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+      var fiberFlags = 4194308;
+      0 !== (currentlyRenderingFiber.mode & 16) && (fiberFlags |= 134217728);
+      mountEffectImpl(fiberFlags, Layout, imperativeHandleEffect.bind(null, create, ref), deps);
+    }
+    function updateImperativeHandle(ref, create, deps) {
+      "function" !== typeof create && console.error("Expected useImperativeHandle() second argument to be a function that creates a handle. Instead received: %s.", null !== create ? typeof create : "null");
+      deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+      updateEffectImpl(4, Layout, imperativeHandleEffect.bind(null, create, ref), deps);
+    }
+    function mountCallback(callback, deps) {
+      mountWorkInProgressHook().memoizedState = [callback, void 0 === deps ? null : deps];
+      return callback;
+    }
+    function updateCallback(callback, deps) {
+      var hook = updateWorkInProgressHook();
+      deps = void 0 === deps ? null : deps;
+      var prevState = hook.memoizedState;
+      if (null !== deps && areHookInputsEqual(deps, prevState[1])) return prevState[0];
+      hook.memoizedState = [callback, deps];
+      return callback;
+    }
+    function mountMemo(nextCreate, deps) {
+      var hook = mountWorkInProgressHook();
+      deps = void 0 === deps ? null : deps;
+      var nextValue = nextCreate();
+      if (shouldDoubleInvokeUserFnsInHooksDEV) {
+        setIsStrictModeForDevtools(!0);
+        try {
+          nextCreate();
+        } finally {
+          setIsStrictModeForDevtools(!1);
+        }
+      }
+      hook.memoizedState = [nextValue, deps];
+      return nextValue;
+    }
+    function updateMemo(nextCreate, deps) {
+      var hook = updateWorkInProgressHook();
+      deps = void 0 === deps ? null : deps;
+      var prevState = hook.memoizedState;
+      if (null !== deps && areHookInputsEqual(deps, prevState[1])) return prevState[0];
+      prevState = nextCreate();
+      if (shouldDoubleInvokeUserFnsInHooksDEV) {
+        setIsStrictModeForDevtools(!0);
+        try {
+          nextCreate();
+        } finally {
+          setIsStrictModeForDevtools(!1);
+        }
+      }
+      hook.memoizedState = [prevState, deps];
+      return prevState;
+    }
+    function mountDeferredValue(value, initialValue) {
+      var hook = mountWorkInProgressHook();
+      return mountDeferredValueImpl(hook, value, initialValue);
+    }
+    function updateDeferredValue(value, initialValue) {
+      var hook = updateWorkInProgressHook();
+      return updateDeferredValueImpl(hook, currentHook.memoizedState, value, initialValue);
+    }
+    function rerenderDeferredValue(value, initialValue) {
+      var hook = updateWorkInProgressHook();
+      return null === currentHook ? mountDeferredValueImpl(hook, value, initialValue) : updateDeferredValueImpl(hook, currentHook.memoizedState, value, initialValue);
+    }
+    function mountDeferredValueImpl(hook, value, initialValue) {
+      if (void 0 === initialValue || 0 !== (renderLanes & 1073741824)) return hook.memoizedState = value;
+      hook.memoizedState = initialValue;
+      hook = requestDeferredLane();
+      currentlyRenderingFiber.lanes |= hook;
+      workInProgressRootSkippedLanes |= hook;
+      return initialValue;
+    }
+    function updateDeferredValueImpl(hook, prevValue, value, initialValue) {
+      if (objectIs(value, prevValue)) return value;
+      if (null !== currentTreeHiddenStackCursor.current) return hook = mountDeferredValueImpl(hook, value, initialValue), objectIs(hook, prevValue) || (didReceiveUpdate = !0), hook;
+      if (0 === (renderLanes & 42)) return didReceiveUpdate = !0, hook.memoizedState = value;
+      hook = requestDeferredLane();
+      currentlyRenderingFiber.lanes |= hook;
+      workInProgressRootSkippedLanes |= hook;
+      return prevValue;
+    }
+    function startTransition(fiber, queue, pendingState, finishedState, callback) {
+      var previousPriority = currentUpdatePriority;
+      currentUpdatePriority = 0 !== previousPriority && previousPriority < ContinuousEventPriority ? previousPriority : ContinuousEventPriority;
+      var prevTransition = ReactSharedInternals.T,
+        currentTransition = {};
+      ReactSharedInternals.T = currentTransition;
+      dispatchOptimisticSetState(fiber, !1, queue, pendingState);
+      currentTransition._updatedFibers = new Set();
+      try {
+        var returnValue = callback(),
+          onStartTransitionFinish = ReactSharedInternals.S;
+        null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
+        if (null !== returnValue && "object" === typeof returnValue && "function" === typeof returnValue.then) {
+          var thenableForFinishedState = chainThenableValue(returnValue, finishedState);
+          dispatchSetStateInternal(fiber, queue, thenableForFinishedState, requestUpdateLane(fiber));
+        } else dispatchSetStateInternal(fiber, queue, finishedState, requestUpdateLane(fiber));
+      } catch (error) {
+        dispatchSetStateInternal(fiber, queue, {
+          then: function then() {},
+          status: "rejected",
+          reason: error
+        }, requestUpdateLane(fiber));
+      } finally {
+        currentUpdatePriority = previousPriority, ReactSharedInternals.T = prevTransition, null === prevTransition && currentTransition._updatedFibers && (fiber = currentTransition._updatedFibers.size, currentTransition._updatedFibers.clear(), 10 < fiber && console.warn("Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table."));
+      }
+    }
+    function mountTransition() {
+      var stateHook = mountStateImpl(!1);
+      stateHook = startTransition.bind(null, currentlyRenderingFiber, stateHook.queue, !0, !1);
+      mountWorkInProgressHook().memoizedState = stateHook;
+      return [!1, stateHook];
+    }
+    function updateTransition() {
+      var booleanOrThenable = updateReducer(basicStateReducer)[0],
+        start = updateWorkInProgressHook().memoizedState;
+      return ["boolean" === typeof booleanOrThenable ? booleanOrThenable : useThenable(booleanOrThenable), start];
+    }
+    function rerenderTransition() {
+      var booleanOrThenable = rerenderReducer(basicStateReducer)[0],
+        start = updateWorkInProgressHook().memoizedState;
+      return ["boolean" === typeof booleanOrThenable ? booleanOrThenable : useThenable(booleanOrThenable), start];
+    }
+    function useHostTransitionStatus() {
+      return _readContext(HostTransitionContext);
+    }
+    function mountId() {
+      var hook = mountWorkInProgressHook(),
+        identifierPrefix = workInProgressRoot.identifierPrefix,
+        globalClientId = globalClientIdCounter++;
+      identifierPrefix = "\xAB" + identifierPrefix + "r" + globalClientId.toString(32) + "\xBB";
+      return hook.memoizedState = identifierPrefix;
+    }
+    function mountRefresh() {
+      return mountWorkInProgressHook().memoizedState = refreshCache.bind(null, currentlyRenderingFiber);
+    }
+    function refreshCache(fiber, seedKey) {
+      for (var provider = fiber.return; null !== provider;) {
+        switch (provider.tag) {
+          case 24:
+          case 3:
+            var lane = requestUpdateLane(provider);
+            fiber = createUpdate(lane);
+            var root = enqueueUpdate(provider, fiber, lane);
+            null !== root && (scheduleUpdateOnFiber(root, provider, lane), entangleTransitions(root, provider, lane));
+            provider = createCache();
+            null !== seedKey && void 0 !== seedKey && null !== root && console.error("The seed argument is not enabled outside experimental channels.");
+            fiber.payload = {
+              cache: provider
+            };
+            return;
+        }
+        provider = provider.return;
+      }
+    }
+    function dispatchReducerAction(fiber, queue, action) {
+      var args = arguments;
+      "function" === typeof args[3] && console.error("State updates from the useState() and useReducer() Hooks don't support the second callback argument. To execute a side effect after rendering, declare it in the component body with useEffect().");
+      args = requestUpdateLane(fiber);
+      var update = {
+        lane: args,
+        revertLane: 0,
+        action: action,
+        hasEagerState: !1,
+        eagerState: null,
+        next: null
+      };
+      isRenderPhaseUpdate(fiber) ? enqueueRenderPhaseUpdate(queue, update) : (update = enqueueConcurrentHookUpdate(fiber, queue, update, args), null !== update && (scheduleUpdateOnFiber(update, fiber, args), entangleTransitionUpdate(update, queue, args)));
+      markStateUpdateScheduled(fiber, args);
+    }
+    function dispatchSetState(fiber, queue, action) {
+      var args = arguments;
+      "function" === typeof args[3] && console.error("State updates from the useState() and useReducer() Hooks don't support the second callback argument. To execute a side effect after rendering, declare it in the component body with useEffect().");
+      args = requestUpdateLane(fiber);
+      dispatchSetStateInternal(fiber, queue, action, args);
+      markStateUpdateScheduled(fiber, args);
+    }
+    function dispatchSetStateInternal(fiber, queue, action, lane) {
+      var update = {
+        lane: lane,
+        revertLane: 0,
+        action: action,
+        hasEagerState: !1,
+        eagerState: null,
+        next: null
+      };
+      if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, update);else {
+        var alternate = fiber.alternate;
+        if (0 === fiber.lanes && (null === alternate || 0 === alternate.lanes) && (alternate = queue.lastRenderedReducer, null !== alternate)) {
+          var prevDispatcher = ReactSharedInternals.H;
+          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
+          try {
+            var currentState = queue.lastRenderedState,
+              eagerState = alternate(currentState, action);
+            update.hasEagerState = !0;
+            update.eagerState = eagerState;
+            if (objectIs(eagerState, currentState)) return enqueueUpdate$1(fiber, queue, update, 0), null === workInProgressRoot && finishQueueingConcurrentUpdates(), !1;
+          } catch (error) {} finally {
+            ReactSharedInternals.H = prevDispatcher;
+          }
+        }
+        action = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
+        if (null !== action) return scheduleUpdateOnFiber(action, fiber, lane), entangleTransitionUpdate(action, queue, lane), !0;
+      }
+      return !1;
+    }
+    function dispatchOptimisticSetState(fiber, throwIfDuringRender, queue, action) {
+      null === ReactSharedInternals.T && 0 === currentEntangledLane && console.error("An optimistic state update occurred outside a transition or action. To fix, move the update to an action, or wrap with startTransition.");
+      action = {
+        lane: 2,
+        revertLane: requestTransitionLane(),
+        action: action,
+        hasEagerState: !1,
+        eagerState: null,
+        next: null
+      };
+      if (isRenderPhaseUpdate(fiber)) {
+        if (throwIfDuringRender) throw Error("Cannot update optimistic state while rendering.");
+        console.error("Cannot call startTransition while rendering.");
+      } else throwIfDuringRender = enqueueConcurrentHookUpdate(fiber, queue, action, 2), null !== throwIfDuringRender && scheduleUpdateOnFiber(throwIfDuringRender, fiber, 2);
+      markStateUpdateScheduled(fiber, 2);
+    }
+    function isRenderPhaseUpdate(fiber) {
+      var alternate = fiber.alternate;
+      return fiber === currentlyRenderingFiber || null !== alternate && alternate === currentlyRenderingFiber;
+    }
+    function enqueueRenderPhaseUpdate(queue, update) {
+      didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate = !0;
+      var pending = queue.pending;
+      null === pending ? update.next = update : (update.next = pending.next, pending.next = update);
+      queue.pending = update;
+    }
+    function entangleTransitionUpdate(root, queue, lane) {
+      if (0 !== (lane & 4194048)) {
+        var queueLanes = queue.lanes;
+        queueLanes &= root.pendingLanes;
+        lane |= queueLanes;
+        queue.lanes = lane;
+        markRootEntangled(root, lane);
+      }
+    }
+    function pushDebugInfo(debugInfo) {
+      var previousDebugInfo = currentDebugInfo;
+      null != debugInfo && (currentDebugInfo = null === previousDebugInfo ? debugInfo : previousDebugInfo.concat(debugInfo));
+      return previousDebugInfo;
+    }
+    function validateFragmentProps(element, fiber, returnFiber) {
+      for (var keys = Object.keys(element.props), i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        if ("children" !== key && "key" !== key) {
+          null === fiber && (fiber = createFiberFromElement(element, returnFiber.mode, 0), fiber._debugInfo = currentDebugInfo, fiber.return = returnFiber);
+          runWithFiberInDEV(fiber, function (erroredKey) {
+            console.error("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", erroredKey);
+          }, key);
+          break;
+        }
+      }
+    }
+    function unwrapThenable(thenable) {
+      var index = thenableIndexCounter;
+      thenableIndexCounter += 1;
+      null === thenableState && (thenableState = createThenableState());
+      return trackUsedThenable(thenableState, thenable, index);
+    }
+    function coerceRef(workInProgress, element) {
+      element = element.props.ref;
+      workInProgress.ref = void 0 !== element ? element : null;
+    }
+    function throwOnInvalidObjectType(returnFiber, newChild) {
+      if (newChild.$$typeof === REACT_LEGACY_ELEMENT_TYPE) throw Error('A React Element from an older version of React was rendered. This is not supported. It can happen if:\n- Multiple copies of the "react" package is used.\n- A library pre-bundled an old copy of "react" or "react/jsx-runtime".\n- A compiler tries to "inline" JSX instead of using the runtime.');
+      returnFiber = Object.prototype.toString.call(newChild);
+      throw Error("Objects are not valid as a React child (found: " + ("[object Object]" === returnFiber ? "object with keys {" + Object.keys(newChild).join(", ") + "}" : returnFiber) + "). If you meant to render a collection of children, use an array instead.");
+    }
+    function warnOnFunctionType(returnFiber, invalidChild) {
+      var parentName = getComponentNameFromFiber(returnFiber) || "Component";
+      ownerHasFunctionTypeWarning[parentName] || (ownerHasFunctionTypeWarning[parentName] = !0, invalidChild = invalidChild.displayName || invalidChild.name || "Component", 3 === returnFiber.tag ? console.error("Functions are not valid as a React child. This may happen if you return %s instead of <%s /> from render. Or maybe you meant to call this function rather than return it.\n  root.render(%s)", invalidChild, invalidChild, invalidChild) : console.error("Functions are not valid as a React child. This may happen if you return %s instead of <%s /> from render. Or maybe you meant to call this function rather than return it.\n  <%s>{%s}</%s>", invalidChild, invalidChild, parentName, invalidChild, parentName));
+    }
+    function warnOnSymbolType(returnFiber, invalidChild) {
+      var parentName = getComponentNameFromFiber(returnFiber) || "Component";
+      ownerHasSymbolTypeWarning[parentName] || (ownerHasSymbolTypeWarning[parentName] = !0, invalidChild = String(invalidChild), 3 === returnFiber.tag ? console.error("Symbols are not valid as a React child.\n  root.render(%s)", invalidChild) : console.error("Symbols are not valid as a React child.\n  <%s>%s</%s>", parentName, invalidChild, parentName));
+    }
+    function createChildReconciler(shouldTrackSideEffects) {
+      function deleteChild(returnFiber, childToDelete) {
+        if (shouldTrackSideEffects) {
+          var deletions = returnFiber.deletions;
+          null === deletions ? (returnFiber.deletions = [childToDelete], returnFiber.flags |= 16) : deletions.push(childToDelete);
+        }
+      }
+      function deleteRemainingChildren(returnFiber, currentFirstChild) {
+        if (!shouldTrackSideEffects) return null;
+        for (; null !== currentFirstChild;) deleteChild(returnFiber, currentFirstChild), currentFirstChild = currentFirstChild.sibling;
+        return null;
+      }
+      function mapRemainingChildren(currentFirstChild) {
+        for (var existingChildren = new Map(); null !== currentFirstChild;) null !== currentFirstChild.key ? existingChildren.set(currentFirstChild.key, currentFirstChild) : existingChildren.set(currentFirstChild.index, currentFirstChild), currentFirstChild = currentFirstChild.sibling;
+        return existingChildren;
+      }
+      function useFiber(fiber, pendingProps) {
+        fiber = createWorkInProgress(fiber, pendingProps);
+        fiber.index = 0;
+        fiber.sibling = null;
+        return fiber;
+      }
+      function placeChild(newFiber, lastPlacedIndex, newIndex) {
+        newFiber.index = newIndex;
+        if (!shouldTrackSideEffects) return newFiber.flags |= 1048576, lastPlacedIndex;
+        newIndex = newFiber.alternate;
+        if (null !== newIndex) return newIndex = newIndex.index, newIndex < lastPlacedIndex ? (newFiber.flags |= 67108866, lastPlacedIndex) : newIndex;
+        newFiber.flags |= 67108866;
+        return lastPlacedIndex;
+      }
+      function placeSingleChild(newFiber) {
+        shouldTrackSideEffects && null === newFiber.alternate && (newFiber.flags |= 67108866);
+        return newFiber;
+      }
+      function updateTextNode(returnFiber, current, textContent, lanes) {
+        if (null === current || 6 !== current.tag) return current = createFiberFromText(textContent, returnFiber.mode, lanes), current.return = returnFiber, current._debugOwner = returnFiber, current._debugTask = returnFiber._debugTask, current._debugInfo = currentDebugInfo, current;
+        current = useFiber(current, textContent);
+        current.return = returnFiber;
+        current._debugInfo = currentDebugInfo;
+        return current;
+      }
+      function updateElement(returnFiber, current, element, lanes) {
+        var elementType = element.type;
+        if (elementType === REACT_FRAGMENT_TYPE) return current = updateFragment(returnFiber, current, element.props.children, lanes, element.key), validateFragmentProps(element, current, returnFiber), current;
+        if (null !== current && (current.elementType === elementType || isCompatibleFamilyForHotReloading(current, element) || "object" === typeof elementType && null !== elementType && elementType.$$typeof === REACT_LAZY_TYPE && callLazyInitInDEV(elementType) === current.type)) return current = useFiber(current, element.props), coerceRef(current, element), current.return = returnFiber, current._debugOwner = element._owner, current._debugInfo = currentDebugInfo, current;
+        current = createFiberFromElement(element, returnFiber.mode, lanes);
+        coerceRef(current, element);
+        current.return = returnFiber;
+        current._debugInfo = currentDebugInfo;
+        return current;
+      }
+      function updatePortal(returnFiber, current, portal, lanes) {
+        if (null === current || 4 !== current.tag || current.stateNode.containerInfo !== portal.containerInfo || current.stateNode.implementation !== portal.implementation) return current = createFiberFromPortal(portal, returnFiber.mode, lanes), current.return = returnFiber, current._debugInfo = currentDebugInfo, current;
+        current = useFiber(current, portal.children || []);
+        current.return = returnFiber;
+        current._debugInfo = currentDebugInfo;
+        return current;
+      }
+      function updateFragment(returnFiber, current, fragment, lanes, key) {
+        if (null === current || 7 !== current.tag) return current = createFiberFromFragment(fragment, returnFiber.mode, lanes, key), current.return = returnFiber, current._debugOwner = returnFiber, current._debugTask = returnFiber._debugTask, current._debugInfo = currentDebugInfo, current;
+        current = useFiber(current, fragment);
+        current.return = returnFiber;
+        current._debugInfo = currentDebugInfo;
+        return current;
+      }
+      function createChild(returnFiber, newChild, lanes) {
+        if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild) return newChild = createFiberFromText("" + newChild, returnFiber.mode, lanes), newChild.return = returnFiber, newChild._debugOwner = returnFiber, newChild._debugTask = returnFiber._debugTask, newChild._debugInfo = currentDebugInfo, newChild;
+        if ("object" === typeof newChild && null !== newChild) {
+          switch (newChild.$$typeof) {
+            case REACT_ELEMENT_TYPE:
+              return lanes = createFiberFromElement(newChild, returnFiber.mode, lanes), coerceRef(lanes, newChild), lanes.return = returnFiber, returnFiber = pushDebugInfo(newChild._debugInfo), lanes._debugInfo = currentDebugInfo, currentDebugInfo = returnFiber, lanes;
+            case REACT_PORTAL_TYPE:
+              return newChild = createFiberFromPortal(newChild, returnFiber.mode, lanes), newChild.return = returnFiber, newChild._debugInfo = currentDebugInfo, newChild;
+            case REACT_LAZY_TYPE:
+              var _prevDebugInfo = pushDebugInfo(newChild._debugInfo);
+              newChild = callLazyInitInDEV(newChild);
+              returnFiber = createChild(returnFiber, newChild, lanes);
+              currentDebugInfo = _prevDebugInfo;
+              return returnFiber;
+          }
+          if (isArrayImpl(newChild) || getIteratorFn(newChild)) return lanes = createFiberFromFragment(newChild, returnFiber.mode, lanes, null), lanes.return = returnFiber, lanes._debugOwner = returnFiber, lanes._debugTask = returnFiber._debugTask, returnFiber = pushDebugInfo(newChild._debugInfo), lanes._debugInfo = currentDebugInfo, currentDebugInfo = returnFiber, lanes;
+          if ("function" === typeof newChild.then) return _prevDebugInfo = pushDebugInfo(newChild._debugInfo), returnFiber = createChild(returnFiber, unwrapThenable(newChild), lanes), currentDebugInfo = _prevDebugInfo, returnFiber;
+          if (newChild.$$typeof === REACT_CONTEXT_TYPE) return createChild(returnFiber, readContextDuringReconciliation(returnFiber, newChild), lanes);
+          throwOnInvalidObjectType(returnFiber, newChild);
+        }
+        "function" === typeof newChild && warnOnFunctionType(returnFiber, newChild);
+        "symbol" === typeof newChild && warnOnSymbolType(returnFiber, newChild);
+        return null;
+      }
+      function updateSlot(returnFiber, oldFiber, newChild, lanes) {
+        var key = null !== oldFiber ? oldFiber.key : null;
+        if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild) return null !== key ? null : updateTextNode(returnFiber, oldFiber, "" + newChild, lanes);
+        if ("object" === typeof newChild && null !== newChild) {
+          switch (newChild.$$typeof) {
+            case REACT_ELEMENT_TYPE:
+              return newChild.key === key ? (key = pushDebugInfo(newChild._debugInfo), returnFiber = updateElement(returnFiber, oldFiber, newChild, lanes), currentDebugInfo = key, returnFiber) : null;
+            case REACT_PORTAL_TYPE:
+              return newChild.key === key ? updatePortal(returnFiber, oldFiber, newChild, lanes) : null;
+            case REACT_LAZY_TYPE:
+              return key = pushDebugInfo(newChild._debugInfo), newChild = callLazyInitInDEV(newChild), returnFiber = updateSlot(returnFiber, oldFiber, newChild, lanes), currentDebugInfo = key, returnFiber;
+          }
+          if (isArrayImpl(newChild) || getIteratorFn(newChild)) {
+            if (null !== key) return null;
+            key = pushDebugInfo(newChild._debugInfo);
+            returnFiber = updateFragment(returnFiber, oldFiber, newChild, lanes, null);
+            currentDebugInfo = key;
+            return returnFiber;
+          }
+          if ("function" === typeof newChild.then) return key = pushDebugInfo(newChild._debugInfo), returnFiber = updateSlot(returnFiber, oldFiber, unwrapThenable(newChild), lanes), currentDebugInfo = key, returnFiber;
+          if (newChild.$$typeof === REACT_CONTEXT_TYPE) return updateSlot(returnFiber, oldFiber, readContextDuringReconciliation(returnFiber, newChild), lanes);
+          throwOnInvalidObjectType(returnFiber, newChild);
+        }
+        "function" === typeof newChild && warnOnFunctionType(returnFiber, newChild);
+        "symbol" === typeof newChild && warnOnSymbolType(returnFiber, newChild);
+        return null;
+      }
+      function updateFromMap(existingChildren, returnFiber, newIdx, newChild, lanes) {
+        if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild) return existingChildren = existingChildren.get(newIdx) || null, updateTextNode(returnFiber, existingChildren, "" + newChild, lanes);
+        if ("object" === typeof newChild && null !== newChild) {
+          switch (newChild.$$typeof) {
+            case REACT_ELEMENT_TYPE:
+              return newIdx = existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, existingChildren = pushDebugInfo(newChild._debugInfo), returnFiber = updateElement(returnFiber, newIdx, newChild, lanes), currentDebugInfo = existingChildren, returnFiber;
+            case REACT_PORTAL_TYPE:
+              return existingChildren = existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, updatePortal(returnFiber, existingChildren, newChild, lanes);
+            case REACT_LAZY_TYPE:
+              var _prevDebugInfo7 = pushDebugInfo(newChild._debugInfo);
+              newChild = callLazyInitInDEV(newChild);
+              returnFiber = updateFromMap(existingChildren, returnFiber, newIdx, newChild, lanes);
+              currentDebugInfo = _prevDebugInfo7;
+              return returnFiber;
+          }
+          if (isArrayImpl(newChild) || getIteratorFn(newChild)) return newIdx = existingChildren.get(newIdx) || null, existingChildren = pushDebugInfo(newChild._debugInfo), returnFiber = updateFragment(returnFiber, newIdx, newChild, lanes, null), currentDebugInfo = existingChildren, returnFiber;
+          if ("function" === typeof newChild.then) return _prevDebugInfo7 = pushDebugInfo(newChild._debugInfo), returnFiber = updateFromMap(existingChildren, returnFiber, newIdx, unwrapThenable(newChild), lanes), currentDebugInfo = _prevDebugInfo7, returnFiber;
+          if (newChild.$$typeof === REACT_CONTEXT_TYPE) return updateFromMap(existingChildren, returnFiber, newIdx, readContextDuringReconciliation(returnFiber, newChild), lanes);
+          throwOnInvalidObjectType(returnFiber, newChild);
+        }
+        "function" === typeof newChild && warnOnFunctionType(returnFiber, newChild);
+        "symbol" === typeof newChild && warnOnSymbolType(returnFiber, newChild);
+        return null;
+      }
+      function warnOnInvalidKey(returnFiber, workInProgress, child, knownKeys) {
+        if ("object" !== typeof child || null === child) return knownKeys;
+        switch (child.$$typeof) {
+          case REACT_ELEMENT_TYPE:
+          case REACT_PORTAL_TYPE:
+            warnForMissingKey(returnFiber, workInProgress, child);
+            var key = child.key;
+            if ("string" !== typeof key) break;
+            if (null === knownKeys) {
+              knownKeys = new Set();
+              knownKeys.add(key);
+              break;
+            }
+            if (!knownKeys.has(key)) {
+              knownKeys.add(key);
+              break;
+            }
+            runWithFiberInDEV(workInProgress, function () {
+              console.error("Encountered two children with the same key, `%s`. Keys should be unique so that components maintain their identity across updates. Non-unique keys may cause children to be duplicated and/or omitted \u2014 the behavior is unsupported and could change in a future version.", key);
+            });
+            break;
+          case REACT_LAZY_TYPE:
+            child = callLazyInitInDEV(child), warnOnInvalidKey(returnFiber, workInProgress, child, knownKeys);
+        }
+        return knownKeys;
+      }
+      function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, lanes) {
+        for (var knownKeys = null, resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null; null !== oldFiber && newIdx < newChildren.length; newIdx++) {
+          oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
+          var newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], lanes);
+          if (null === newFiber) {
+            null === oldFiber && (oldFiber = nextOldFiber);
+            break;
+          }
+          knownKeys = warnOnInvalidKey(returnFiber, newFiber, newChildren[newIdx], knownKeys);
+          shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
+          currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
+          null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber;
+          previousNewFiber = newFiber;
+          oldFiber = nextOldFiber;
+        }
+        if (newIdx === newChildren.length) return deleteRemainingChildren(returnFiber, oldFiber), resultingFirstChild;
+        if (null === oldFiber) {
+          for (; newIdx < newChildren.length; newIdx++) oldFiber = createChild(returnFiber, newChildren[newIdx], lanes), null !== oldFiber && (knownKeys = warnOnInvalidKey(returnFiber, oldFiber, newChildren[newIdx], knownKeys), currentFirstChild = placeChild(oldFiber, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = oldFiber : previousNewFiber.sibling = oldFiber, previousNewFiber = oldFiber);
+          return resultingFirstChild;
+        }
+        for (oldFiber = mapRemainingChildren(oldFiber); newIdx < newChildren.length; newIdx++) nextOldFiber = updateFromMap(oldFiber, returnFiber, newIdx, newChildren[newIdx], lanes), null !== nextOldFiber && (knownKeys = warnOnInvalidKey(returnFiber, nextOldFiber, newChildren[newIdx], knownKeys), shouldTrackSideEffects && null !== nextOldFiber.alternate && oldFiber.delete(null === nextOldFiber.key ? newIdx : nextOldFiber.key), currentFirstChild = placeChild(nextOldFiber, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = nextOldFiber : previousNewFiber.sibling = nextOldFiber, previousNewFiber = nextOldFiber);
+        shouldTrackSideEffects && oldFiber.forEach(function (child) {
+          return deleteChild(returnFiber, child);
+        });
+        return resultingFirstChild;
+      }
+      function reconcileChildrenIterator(returnFiber, currentFirstChild, newChildren, lanes) {
+        if (null == newChildren) throw Error("An iterable object provided no iterator.");
+        for (var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null, knownKeys = null, step = newChildren.next(); null !== oldFiber && !step.done; newIdx++, step = newChildren.next()) {
+          oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
+          var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
+          if (null === newFiber) {
+            null === oldFiber && (oldFiber = nextOldFiber);
+            break;
+          }
+          knownKeys = warnOnInvalidKey(returnFiber, newFiber, step.value, knownKeys);
+          shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
+          currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
+          null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber;
+          previousNewFiber = newFiber;
+          oldFiber = nextOldFiber;
+        }
+        if (step.done) return deleteRemainingChildren(returnFiber, oldFiber), resultingFirstChild;
+        if (null === oldFiber) {
+          for (; !step.done; newIdx++, step = newChildren.next()) oldFiber = createChild(returnFiber, step.value, lanes), null !== oldFiber && (knownKeys = warnOnInvalidKey(returnFiber, oldFiber, step.value, knownKeys), currentFirstChild = placeChild(oldFiber, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = oldFiber : previousNewFiber.sibling = oldFiber, previousNewFiber = oldFiber);
+          return resultingFirstChild;
+        }
+        for (oldFiber = mapRemainingChildren(oldFiber); !step.done; newIdx++, step = newChildren.next()) nextOldFiber = updateFromMap(oldFiber, returnFiber, newIdx, step.value, lanes), null !== nextOldFiber && (knownKeys = warnOnInvalidKey(returnFiber, nextOldFiber, step.value, knownKeys), shouldTrackSideEffects && null !== nextOldFiber.alternate && oldFiber.delete(null === nextOldFiber.key ? newIdx : nextOldFiber.key), currentFirstChild = placeChild(nextOldFiber, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = nextOldFiber : previousNewFiber.sibling = nextOldFiber, previousNewFiber = nextOldFiber);
+        shouldTrackSideEffects && oldFiber.forEach(function (child) {
+          return deleteChild(returnFiber, child);
+        });
+        return resultingFirstChild;
+      }
+      function reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes) {
+        "object" === typeof newChild && null !== newChild && newChild.type === REACT_FRAGMENT_TYPE && null === newChild.key && (validateFragmentProps(newChild, null, returnFiber), newChild = newChild.props.children);
+        if ("object" === typeof newChild && null !== newChild) {
+          switch (newChild.$$typeof) {
+            case REACT_ELEMENT_TYPE:
+              var prevDebugInfo = pushDebugInfo(newChild._debugInfo);
+              a: {
+                for (var key = newChild.key; null !== currentFirstChild;) {
+                  if (currentFirstChild.key === key) {
+                    key = newChild.type;
+                    if (key === REACT_FRAGMENT_TYPE) {
+                      if (7 === currentFirstChild.tag) {
+                        deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+                        lanes = useFiber(currentFirstChild, newChild.props.children);
+                        lanes.return = returnFiber;
+                        lanes._debugOwner = newChild._owner;
+                        lanes._debugInfo = currentDebugInfo;
+                        validateFragmentProps(newChild, lanes, returnFiber);
+                        returnFiber = lanes;
+                        break a;
+                      }
+                    } else if (currentFirstChild.elementType === key || isCompatibleFamilyForHotReloading(currentFirstChild, newChild) || "object" === typeof key && null !== key && key.$$typeof === REACT_LAZY_TYPE && callLazyInitInDEV(key) === currentFirstChild.type) {
+                      deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+                      lanes = useFiber(currentFirstChild, newChild.props);
+                      coerceRef(lanes, newChild);
+                      lanes.return = returnFiber;
+                      lanes._debugOwner = newChild._owner;
+                      lanes._debugInfo = currentDebugInfo;
+                      returnFiber = lanes;
+                      break a;
+                    }
+                    deleteRemainingChildren(returnFiber, currentFirstChild);
+                    break;
+                  } else deleteChild(returnFiber, currentFirstChild);
+                  currentFirstChild = currentFirstChild.sibling;
+                }
+                newChild.type === REACT_FRAGMENT_TYPE ? (lanes = createFiberFromFragment(newChild.props.children, returnFiber.mode, lanes, newChild.key), lanes.return = returnFiber, lanes._debugOwner = returnFiber, lanes._debugTask = returnFiber._debugTask, lanes._debugInfo = currentDebugInfo, validateFragmentProps(newChild, lanes, returnFiber), returnFiber = lanes) : (lanes = createFiberFromElement(newChild, returnFiber.mode, lanes), coerceRef(lanes, newChild), lanes.return = returnFiber, lanes._debugInfo = currentDebugInfo, returnFiber = lanes);
+              }
+              returnFiber = placeSingleChild(returnFiber);
+              currentDebugInfo = prevDebugInfo;
+              return returnFiber;
+            case REACT_PORTAL_TYPE:
+              a: {
+                prevDebugInfo = newChild;
+                for (newChild = prevDebugInfo.key; null !== currentFirstChild;) {
+                  if (currentFirstChild.key === newChild) {
+                    if (4 === currentFirstChild.tag && currentFirstChild.stateNode.containerInfo === prevDebugInfo.containerInfo && currentFirstChild.stateNode.implementation === prevDebugInfo.implementation) {
+                      deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+                      lanes = useFiber(currentFirstChild, prevDebugInfo.children || []);
+                      lanes.return = returnFiber;
+                      returnFiber = lanes;
+                      break a;
+                    } else {
+                      deleteRemainingChildren(returnFiber, currentFirstChild);
+                      break;
+                    }
+                  } else deleteChild(returnFiber, currentFirstChild);
+                  currentFirstChild = currentFirstChild.sibling;
+                }
+                lanes = createFiberFromPortal(prevDebugInfo, returnFiber.mode, lanes);
+                lanes.return = returnFiber;
+                returnFiber = lanes;
+              }
+              return placeSingleChild(returnFiber);
+            case REACT_LAZY_TYPE:
+              return prevDebugInfo = pushDebugInfo(newChild._debugInfo), newChild = callLazyInitInDEV(newChild), returnFiber = reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes), currentDebugInfo = prevDebugInfo, returnFiber;
+          }
+          if (isArrayImpl(newChild)) return prevDebugInfo = pushDebugInfo(newChild._debugInfo), returnFiber = reconcileChildrenArray(returnFiber, currentFirstChild, newChild, lanes), currentDebugInfo = prevDebugInfo, returnFiber;
+          if (getIteratorFn(newChild)) {
+            prevDebugInfo = pushDebugInfo(newChild._debugInfo);
+            key = getIteratorFn(newChild);
+            if ("function" !== typeof key) throw Error("An object is not an iterable. This error is likely caused by a bug in React. Please file an issue.");
+            var newChildren = key.call(newChild);
+            if (newChildren === newChild) {
+              if (0 !== returnFiber.tag || "[object GeneratorFunction]" !== Object.prototype.toString.call(returnFiber.type) || "[object Generator]" !== Object.prototype.toString.call(newChildren)) didWarnAboutGenerators || console.error("Using Iterators as children is unsupported and will likely yield unexpected results because enumerating a generator mutates it. You may convert it to an array with `Array.from()` or the `[...spread]` operator before rendering. You can also use an Iterable that can iterate multiple times over the same items."), didWarnAboutGenerators = !0;
+            } else newChild.entries !== key || didWarnAboutMaps || (console.error("Using Maps as children is not supported. Use an array of keyed ReactElements instead."), didWarnAboutMaps = !0);
+            returnFiber = reconcileChildrenIterator(returnFiber, currentFirstChild, newChildren, lanes);
+            currentDebugInfo = prevDebugInfo;
+            return returnFiber;
+          }
+          if ("function" === typeof newChild.then) return prevDebugInfo = pushDebugInfo(newChild._debugInfo), returnFiber = reconcileChildFibersImpl(returnFiber, currentFirstChild, unwrapThenable(newChild), lanes), currentDebugInfo = prevDebugInfo, returnFiber;
+          if (newChild.$$typeof === REACT_CONTEXT_TYPE) return reconcileChildFibersImpl(returnFiber, currentFirstChild, readContextDuringReconciliation(returnFiber, newChild), lanes);
+          throwOnInvalidObjectType(returnFiber, newChild);
+        }
+        if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild) return prevDebugInfo = "" + newChild, null !== currentFirstChild && 6 === currentFirstChild.tag ? (deleteRemainingChildren(returnFiber, currentFirstChild.sibling), lanes = useFiber(currentFirstChild, prevDebugInfo), lanes.return = returnFiber, returnFiber = lanes) : (deleteRemainingChildren(returnFiber, currentFirstChild), lanes = createFiberFromText(prevDebugInfo, returnFiber.mode, lanes), lanes.return = returnFiber, lanes._debugOwner = returnFiber, lanes._debugTask = returnFiber._debugTask, lanes._debugInfo = currentDebugInfo, returnFiber = lanes), placeSingleChild(returnFiber);
+        "function" === typeof newChild && warnOnFunctionType(returnFiber, newChild);
+        "symbol" === typeof newChild && warnOnSymbolType(returnFiber, newChild);
+        return deleteRemainingChildren(returnFiber, currentFirstChild);
+      }
+      return function (returnFiber, currentFirstChild, newChild, lanes) {
+        var prevDebugInfo = currentDebugInfo;
+        currentDebugInfo = null;
+        try {
+          thenableIndexCounter = 0;
+          var firstChildFiber = reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes);
+          thenableState = null;
+          return firstChildFiber;
+        } catch (x) {
+          if (x === SuspenseException || x === SuspenseActionException || 0 === (returnFiber.mode & 1) && "object" === typeof x && null !== x && "function" === typeof x.then) throw x;
+          var fiber = createFiber(29, x, null, returnFiber.mode);
+          fiber.lanes = lanes;
+          fiber.return = returnFiber;
+          var debugInfo = fiber._debugInfo = currentDebugInfo;
+          fiber._debugOwner = returnFiber._debugOwner;
+          fiber._debugTask = returnFiber._debugTask;
+          if (null != debugInfo) for (var i = debugInfo.length - 1; 0 <= i; i--) if ("string" === typeof debugInfo[i].stack) {
+            fiber._debugOwner = debugInfo[i];
+            fiber._debugTask = debugInfo[i].debugTask;
+            break;
+          }
+          return fiber;
+        } finally {
+          currentDebugInfo = prevDebugInfo;
+        }
+      };
+    }
+    function pushPrimaryTreeSuspenseHandler(handler) {
+      var current = handler.alternate;
+      push(suspenseStackCursor, suspenseStackCursor.current & SubtreeSuspenseContextMask, handler);
+      push(suspenseHandlerStackCursor, handler, handler);
+      null === shellBoundary && (null === current || null !== currentTreeHiddenStackCursor.current ? shellBoundary = handler : null !== current.memoizedState && (shellBoundary = handler));
+    }
+    function pushOffscreenSuspenseHandler(fiber) {
+      if (22 === fiber.tag) {
+        if (push(suspenseStackCursor, suspenseStackCursor.current, fiber), push(suspenseHandlerStackCursor, fiber, fiber), null === shellBoundary) {
+          var current = fiber.alternate;
+          null !== current && null !== current.memoizedState && (shellBoundary = fiber);
+        }
+      } else reuseSuspenseHandlerOnStack(fiber);
+    }
+    function reuseSuspenseHandlerOnStack(fiber) {
+      push(suspenseStackCursor, suspenseStackCursor.current, fiber);
+      push(suspenseHandlerStackCursor, suspenseHandlerStackCursor.current, fiber);
+    }
+    function popSuspenseHandler(fiber) {
+      pop(suspenseHandlerStackCursor, fiber);
+      shellBoundary === fiber && (shellBoundary = null);
+      pop(suspenseStackCursor, fiber);
+    }
+    function findFirstSuspended(row) {
+      for (var node = row; null !== node;) {
+        if (13 === node.tag) {
+          var state = node.memoizedState;
+          if (null !== state && (null === state.dehydrated || isSuspenseInstancePending() || isSuspenseInstanceFallback())) return node;
+        } else if (19 === node.tag && void 0 !== node.memoizedProps.revealOrder) {
+          if (0 !== (node.flags & 128)) return node;
+        } else if (null !== node.child) {
+          node.child.return = node;
+          node = node.child;
+          continue;
+        }
+        if (node === row) break;
+        for (; null === node.sibling;) {
+          if (null === node.return || node.return === row) return null;
+          node = node.return;
+        }
+        node.sibling.return = node.return;
+        node = node.sibling;
+      }
+      return null;
+    }
+    function warnOnInvalidCallback(callback) {
+      if (null !== callback && "function" !== typeof callback) {
+        var key = String(callback);
+        didWarnOnInvalidCallback.has(key) || (didWarnOnInvalidCallback.add(key), console.error("Expected the last optional `callback` argument to be a function. Instead received: %s.", callback));
+      }
+    }
+    function applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, nextProps) {
+      var prevState = workInProgress.memoizedState,
+        partialState = getDerivedStateFromProps(nextProps, prevState);
+      if (workInProgress.mode & StrictLegacyMode) {
+        setIsStrictModeForDevtools(!0);
+        try {
+          partialState = getDerivedStateFromProps(nextProps, prevState);
+        } finally {
+          setIsStrictModeForDevtools(!1);
+        }
+      }
+      void 0 === partialState && (ctor = getComponentNameFromType(ctor) || "Component", didWarnAboutUndefinedDerivedState.has(ctor) || (didWarnAboutUndefinedDerivedState.add(ctor), console.error("%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. You have returned undefined.", ctor)));
+      prevState = null === partialState || void 0 === partialState ? prevState : assign({}, prevState, partialState);
+      workInProgress.memoizedState = prevState;
+      0 === workInProgress.lanes && (workInProgress.updateQueue.baseState = prevState);
+    }
+    function checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) {
+      var instance = workInProgress.stateNode;
+      if ("function" === typeof instance.shouldComponentUpdate) {
+        oldProps = instance.shouldComponentUpdate(newProps, newState, nextContext);
+        if (workInProgress.mode & StrictLegacyMode) {
+          setIsStrictModeForDevtools(!0);
+          try {
+            oldProps = instance.shouldComponentUpdate(newProps, newState, nextContext);
+          } finally {
+            setIsStrictModeForDevtools(!1);
+          }
+        }
+        void 0 === oldProps && console.error("%s.shouldComponentUpdate(): Returned undefined instead of a boolean value. Make sure to return true or false.", getComponentNameFromType(ctor) || "Component");
+        return oldProps;
+      }
+      return ctor.prototype && ctor.prototype.isPureReactComponent ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState) : !0;
+    }
+    function constructClassInstance(workInProgress, ctor, props) {
+      var context = emptyContextObject,
+        contextType = ctor.contextType;
+      if ("contextType" in ctor && null !== contextType && (void 0 === contextType || contextType.$$typeof !== REACT_CONTEXT_TYPE) && !didWarnAboutInvalidateContextType.has(ctor)) {
+        didWarnAboutInvalidateContextType.add(ctor);
+        var addendum = void 0 === contextType ? " However, it is set to undefined. This can be caused by a typo or by mixing up named and default imports. This can also happen due to a circular dependency, so try moving the createContext() call to a separate file." : "object" !== typeof contextType ? " However, it is set to a " + typeof contextType + "." : contextType.$$typeof === REACT_CONSUMER_TYPE ? " Did you accidentally pass the Context.Consumer instead?" : " However, it is set to an object with keys {" + Object.keys(contextType).join(", ") + "}.";
+        console.error("%s defines an invalid contextType. contextType should point to the Context object returned by React.createContext().%s", getComponentNameFromType(ctor) || "Component", addendum);
+      }
+      "object" === typeof contextType && null !== contextType && (context = _readContext(contextType));
+      contextType = new ctor(props, context);
+      if (workInProgress.mode & StrictLegacyMode) {
+        setIsStrictModeForDevtools(!0);
+        try {
+          contextType = new ctor(props, context);
+        } finally {
+          setIsStrictModeForDevtools(!1);
+        }
+      }
+      props = workInProgress.memoizedState = null !== contextType.state && void 0 !== contextType.state ? contextType.state : null;
+      contextType.updater = classComponentUpdater;
+      workInProgress.stateNode = contextType;
+      contextType._reactInternals = workInProgress;
+      contextType._reactInternalInstance = fakeInternalInstance;
+      "function" === typeof ctor.getDerivedStateFromProps && null === props && (workInProgress = getComponentNameFromType(ctor) || "Component", didWarnAboutUninitializedState.has(workInProgress) || (didWarnAboutUninitializedState.add(workInProgress), console.error("`%s` uses `getDerivedStateFromProps` but its initial state is %s. This is not recommended. Instead, define the initial state by assigning an object to `this.state` in the constructor of `%s`. This ensures that `getDerivedStateFromProps` arguments have a consistent shape.", workInProgress, null === contextType.state ? "null" : "undefined", workInProgress)));
+      if ("function" === typeof ctor.getDerivedStateFromProps || "function" === typeof contextType.getSnapshotBeforeUpdate) if (context = props = workInProgress = null, "function" === typeof contextType.componentWillMount && !0 !== contextType.componentWillMount.__suppressDeprecationWarning ? workInProgress = "componentWillMount" : "function" === typeof contextType.UNSAFE_componentWillMount && (workInProgress = "UNSAFE_componentWillMount"), "function" === typeof contextType.componentWillReceiveProps && !0 !== contextType.componentWillReceiveProps.__suppressDeprecationWarning ? props = "componentWillReceiveProps" : "function" === typeof contextType.UNSAFE_componentWillReceiveProps && (props = "UNSAFE_componentWillReceiveProps"), "function" === typeof contextType.componentWillUpdate && !0 !== contextType.componentWillUpdate.__suppressDeprecationWarning ? context = "componentWillUpdate" : "function" === typeof contextType.UNSAFE_componentWillUpdate && (context = "UNSAFE_componentWillUpdate"), null !== workInProgress || null !== props || null !== context) addendum = getComponentNameFromType(ctor) || "Component", ctor = "function" === typeof ctor.getDerivedStateFromProps ? "getDerivedStateFromProps()" : "getSnapshotBeforeUpdate()", didWarnAboutLegacyLifecyclesAndDerivedState.has(addendum) || (didWarnAboutLegacyLifecyclesAndDerivedState.add(addendum), console.error("Unsafe legacy lifecycles will not be called for components using new component APIs.\n\n%s uses %s but also contains the following legacy lifecycles:%s%s%s\n\nThe above lifecycles should be removed. Learn more about this warning here:\nhttps://react.dev/link/unsafe-component-lifecycles", addendum, ctor, null !== workInProgress ? "\n  " + workInProgress : "", null !== props ? "\n  " + props : "", null !== context ? "\n  " + context : ""));
+      return contextType;
+    }
+    function callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext) {
+      var oldState = instance.state;
+      "function" === typeof instance.componentWillReceiveProps && instance.componentWillReceiveProps(newProps, nextContext);
+      "function" === typeof instance.UNSAFE_componentWillReceiveProps && instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+      instance.state !== oldState && (workInProgress = getComponentNameFromFiber(workInProgress) || "Component", didWarnAboutStateAssignmentForComponent.has(workInProgress) || (didWarnAboutStateAssignmentForComponent.add(workInProgress), console.error("%s.componentWillReceiveProps(): Assigning directly to this.state is deprecated (except inside a component's constructor). Use setState instead.", workInProgress)), classComponentUpdater.enqueueReplaceState(instance, instance.state, null));
+    }
+    function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
+      var instance = workInProgress.stateNode,
+        name = getComponentNameFromType(ctor) || "Component";
+      instance.render || (ctor.prototype && "function" === typeof ctor.prototype.render ? console.error("No `render` method found on the %s instance: did you accidentally return an object from the constructor?", name) : console.error("No `render` method found on the %s instance: you may have forgotten to define `render`.", name));
+      !instance.getInitialState || instance.getInitialState.isReactClassApproved || instance.state || console.error("getInitialState was defined on %s, a plain JavaScript class. This is only supported for classes created using React.createClass. Did you mean to define a state property instead?", name);
+      instance.getDefaultProps && !instance.getDefaultProps.isReactClassApproved && console.error("getDefaultProps was defined on %s, a plain JavaScript class. This is only supported for classes created using React.createClass. Use a static property to define defaultProps instead.", name);
+      instance.contextType && console.error("contextType was defined as an instance property on %s. Use a static property to define contextType instead.", name);
+      ctor.childContextTypes && !didWarnAboutChildContextTypes.has(ctor) && (didWarnAboutChildContextTypes.add(ctor), console.error("%s uses the legacy childContextTypes API which was removed in React 19. Use React.createContext() instead. (https://react.dev/link/legacy-context)", name));
+      ctor.contextTypes && !didWarnAboutContextTypes$1.has(ctor) && (didWarnAboutContextTypes$1.add(ctor), console.error("%s uses the legacy contextTypes API which was removed in React 19. Use React.createContext() with static contextType instead. (https://react.dev/link/legacy-context)", name));
+      "function" === typeof instance.componentShouldUpdate && console.error("%s has a method called componentShouldUpdate(). Did you mean shouldComponentUpdate()? The name is phrased as a question because the function is expected to return a value.", name);
+      ctor.prototype && ctor.prototype.isPureReactComponent && "undefined" !== typeof instance.shouldComponentUpdate && console.error("%s has a method called shouldComponentUpdate(). shouldComponentUpdate should not be used when extending React.PureComponent. Please extend React.Component if shouldComponentUpdate is used.", getComponentNameFromType(ctor) || "A pure component");
+      "function" === typeof instance.componentDidUnmount && console.error("%s has a method called componentDidUnmount(). But there is no such lifecycle method. Did you mean componentWillUnmount()?", name);
+      "function" === typeof instance.componentDidReceiveProps && console.error("%s has a method called componentDidReceiveProps(). But there is no such lifecycle method. If you meant to update the state in response to changing props, use componentWillReceiveProps(). If you meant to fetch data or run side-effects or mutations after React has updated the UI, use componentDidUpdate().", name);
+      "function" === typeof instance.componentWillRecieveProps && console.error("%s has a method called componentWillRecieveProps(). Did you mean componentWillReceiveProps()?", name);
+      "function" === typeof instance.UNSAFE_componentWillRecieveProps && console.error("%s has a method called UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?", name);
+      var hasMutatedProps = instance.props !== newProps;
+      void 0 !== instance.props && hasMutatedProps && console.error("When calling super() in `%s`, make sure to pass up the same props that your component's constructor was passed.", name);
+      instance.defaultProps && console.error("Setting defaultProps as an instance property on %s is not supported and will be ignored. Instead, define defaultProps as a static property on %s.", name, name);
+      "function" !== typeof instance.getSnapshotBeforeUpdate || "function" === typeof instance.componentDidUpdate || didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.has(ctor) || (didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(ctor), console.error("%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). This component defines getSnapshotBeforeUpdate() only.", getComponentNameFromType(ctor)));
+      "function" === typeof instance.getDerivedStateFromProps && console.error("%s: getDerivedStateFromProps() is defined as an instance method and will be ignored. Instead, declare it as a static method.", name);
+      "function" === typeof instance.getDerivedStateFromError && console.error("%s: getDerivedStateFromError() is defined as an instance method and will be ignored. Instead, declare it as a static method.", name);
+      "function" === typeof ctor.getSnapshotBeforeUpdate && console.error("%s: getSnapshotBeforeUpdate() is defined as a static method and will be ignored. Instead, declare it as an instance method.", name);
+      (hasMutatedProps = instance.state) && ("object" !== typeof hasMutatedProps || isArrayImpl(hasMutatedProps)) && console.error("%s.state: must be set to an object or null", name);
+      "function" === typeof instance.getChildContext && "object" !== typeof ctor.childContextTypes && console.error("%s.getChildContext(): childContextTypes must be defined in order to use getChildContext().", name);
+      instance = workInProgress.stateNode;
+      instance.props = newProps;
+      instance.state = workInProgress.memoizedState;
+      instance.refs = {};
+      initializeUpdateQueue(workInProgress);
+      name = ctor.contextType;
+      instance.context = "object" === typeof name && null !== name ? _readContext(name) : emptyContextObject;
+      instance.state === newProps && (name = getComponentNameFromType(ctor) || "Component", didWarnAboutDirectlyAssigningPropsToState.has(name) || (didWarnAboutDirectlyAssigningPropsToState.add(name), console.error("%s: It is not recommended to assign props directly to state because updates to props won't be reflected in state. In most cases, it is better to use props directly.", name)));
+      workInProgress.mode & StrictLegacyMode && ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, instance);
+      ReactStrictModeWarnings.recordUnsafeLifecycleWarnings(workInProgress, instance);
+      instance.state = workInProgress.memoizedState;
+      name = ctor.getDerivedStateFromProps;
+      "function" === typeof name && (applyDerivedStateFromProps(workInProgress, ctor, name, newProps), instance.state = workInProgress.memoizedState);
+      "function" === typeof ctor.getDerivedStateFromProps || "function" === typeof instance.getSnapshotBeforeUpdate || "function" !== typeof instance.UNSAFE_componentWillMount && "function" !== typeof instance.componentWillMount || (ctor = instance.state, "function" === typeof instance.componentWillMount && instance.componentWillMount(), "function" === typeof instance.UNSAFE_componentWillMount && instance.UNSAFE_componentWillMount(), ctor !== instance.state && (console.error("%s.componentWillMount(): Assigning directly to this.state is deprecated (except inside a component's constructor). Use setState instead.", getComponentNameFromFiber(workInProgress) || "Component"), classComponentUpdater.enqueueReplaceState(instance, instance.state, null)), processUpdateQueue(workInProgress, newProps, instance, renderLanes), suspendIfUpdateReadFromEntangledAsyncAction(), instance.state = workInProgress.memoizedState);
+      "function" === typeof instance.componentDidMount && (workInProgress.flags |= 4194308);
+      0 !== (workInProgress.mode & 16) && (workInProgress.flags |= 134217728);
+    }
+    function resolveClassComponentProps(Component, baseProps) {
+      var newProps = baseProps;
+      if ("ref" in baseProps) {
+        newProps = {};
+        for (var propName in baseProps) "ref" !== propName && (newProps[propName] = baseProps[propName]);
+      }
+      if (Component = Component.defaultProps) {
+        newProps === baseProps && (newProps = assign({}, newProps));
+        for (var _propName in Component) void 0 === newProps[_propName] && (newProps[_propName] = Component[_propName]);
+      }
+      return newProps;
+    }
+    function defaultOnRecoverableError(error) {
+      reportGlobalError(error);
+    }
+    function logUncaughtError(root, errorInfo) {
+      try {
+        componentName = errorInfo.source ? getComponentNameFromFiber(errorInfo.source) : null;
+        errorBoundaryName = null;
+        var error = errorInfo.value;
+        if (null !== ReactSharedInternals.actQueue) ReactSharedInternals.thrownErrors.push(error);else {
+          var onUncaughtError = root.onUncaughtError;
+          onUncaughtError(error, {
+            componentStack: errorInfo.stack
+          });
+        }
+      } catch (e) {
+        setTimeout(function () {
+          throw e;
+        });
+      }
+    }
+    function logCaughtError(root, boundary, errorInfo) {
+      try {
+        componentName = errorInfo.source ? getComponentNameFromFiber(errorInfo.source) : null;
+        errorBoundaryName = getComponentNameFromFiber(boundary);
+        var onCaughtError = root.onCaughtError;
+        onCaughtError(errorInfo.value, {
+          componentStack: errorInfo.stack,
+          errorBoundary: 1 === boundary.tag ? boundary.stateNode : null
+        });
+      } catch (e) {
+        setTimeout(function () {
+          throw e;
+        });
+      }
+    }
+    function createRootErrorUpdate(root, errorInfo, lane) {
+      lane = createUpdate(lane);
+      lane.tag = CaptureUpdate;
+      lane.payload = {
+        element: null
+      };
+      lane.callback = function () {
+        runWithFiberInDEV(errorInfo.source, logUncaughtError, root, errorInfo);
+      };
+      return lane;
+    }
+    function createClassErrorUpdate(lane) {
+      lane = createUpdate(lane);
+      lane.tag = CaptureUpdate;
+      return lane;
+    }
+    function initializeClassErrorUpdate(update, root, fiber, errorInfo) {
+      var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+      if ("function" === typeof getDerivedStateFromError) {
+        var error = errorInfo.value;
+        update.payload = function () {
+          return getDerivedStateFromError(error);
+        };
+        update.callback = function () {
+          markFailedErrorBoundaryForHotReloading(fiber);
+          runWithFiberInDEV(errorInfo.source, logCaughtError, root, fiber, errorInfo);
+        };
+      }
+      var inst = fiber.stateNode;
+      null !== inst && "function" === typeof inst.componentDidCatch && (update.callback = function () {
+        markFailedErrorBoundaryForHotReloading(fiber);
+        runWithFiberInDEV(errorInfo.source, logCaughtError, root, fiber, errorInfo);
+        "function" !== typeof getDerivedStateFromError && (null === legacyErrorBoundariesThatAlreadyFailed ? legacyErrorBoundariesThatAlreadyFailed = new Set([this]) : legacyErrorBoundariesThatAlreadyFailed.add(this));
+        callComponentDidCatchInDEV(this, errorInfo);
+        "function" === typeof getDerivedStateFromError || 0 === (fiber.lanes & 2) && console.error("%s: Error boundaries should implement getDerivedStateFromError(). In that method, return a state update to display an error message or fallback UI.", getComponentNameFromFiber(fiber) || "Unknown");
+      });
+    }
+    function throwException(root, returnFiber, sourceFiber, value, rootRenderLanes) {
+      sourceFiber.flags |= 32768;
+      isDevToolsPresent && restorePendingUpdaters(root, rootRenderLanes);
+      if (null !== value && "object" === typeof value && "function" === typeof value.then) {
+        var currentSourceFiber = sourceFiber.alternate;
+        null !== currentSourceFiber && propagateParentContextChanges(currentSourceFiber, sourceFiber, rootRenderLanes, !0);
+        currentSourceFiber = sourceFiber.tag;
+        0 !== (sourceFiber.mode & 1) || 0 !== currentSourceFiber && 11 !== currentSourceFiber && 15 !== currentSourceFiber || ((currentSourceFiber = sourceFiber.alternate) ? (sourceFiber.updateQueue = currentSourceFiber.updateQueue, sourceFiber.memoizedState = currentSourceFiber.memoizedState, sourceFiber.lanes = currentSourceFiber.lanes) : (sourceFiber.updateQueue = null, sourceFiber.memoizedState = null));
+        currentSourceFiber = suspenseHandlerStackCursor.current;
+        if (null !== currentSourceFiber) {
+          switch (currentSourceFiber.tag) {
+            case 13:
+              return sourceFiber.mode & 1 && (null === shellBoundary ? renderDidSuspendDelayIfPossible() : null === currentSourceFiber.alternate && workInProgressRootExitStatus === RootInProgress && (workInProgressRootExitStatus = RootSuspended)), currentSourceFiber.flags &= -257, 0 === (currentSourceFiber.mode & 1) ? currentSourceFiber === returnFiber ? currentSourceFiber.flags |= 65536 : (currentSourceFiber.flags |= 128, sourceFiber.flags |= 131072, sourceFiber.flags &= -52805, 1 === sourceFiber.tag ? null === sourceFiber.alternate ? sourceFiber.tag = 17 : (returnFiber = createUpdate(2), returnFiber.tag = ForceUpdate, enqueueUpdate(sourceFiber, returnFiber, 2)) : 0 === sourceFiber.tag && null === sourceFiber.alternate && (sourceFiber.tag = 28), sourceFiber.lanes |= 2) : (currentSourceFiber.flags |= 65536, currentSourceFiber.lanes = rootRenderLanes), value === noopSuspenseyCommitThenable ? currentSourceFiber.flags |= 16384 : (returnFiber = currentSourceFiber.updateQueue, null === returnFiber ? currentSourceFiber.updateQueue = new Set([value]) : returnFiber.add(value), currentSourceFiber.mode & 1 && attachPingListener(root, value, rootRenderLanes)), !1;
+            case 22:
+              if (currentSourceFiber.mode & 1) return currentSourceFiber.flags |= 65536, value === noopSuspenseyCommitThenable ? currentSourceFiber.flags |= 16384 : (returnFiber = currentSourceFiber.updateQueue, null === returnFiber ? (returnFiber = {
+                transitions: null,
+                markerInstances: null,
+                retryQueue: new Set([value])
+              }, currentSourceFiber.updateQueue = returnFiber) : (sourceFiber = returnFiber.retryQueue, null === sourceFiber ? returnFiber.retryQueue = new Set([value]) : sourceFiber.add(value)), attachPingListener(root, value, rootRenderLanes)), !1;
+          }
+          throw Error("Unexpected Suspense handler tag (" + currentSourceFiber.tag + "). This is a bug in React.");
+        }
+        if (1 === root.tag) return attachPingListener(root, value, rootRenderLanes), renderDidSuspendDelayIfPossible(), !1;
+        value = 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.");
+      }
+      currentSourceFiber = createCapturedValueAtFiber(Error("There was an error during concurrent rendering but React was able to recover by instead synchronously rendering the entire root.", {
+        cause: value
+      }), sourceFiber);
+      null === workInProgressRootConcurrentErrors ? workInProgressRootConcurrentErrors = [currentSourceFiber] : workInProgressRootConcurrentErrors.push(currentSourceFiber);
+      workInProgressRootExitStatus !== RootSuspendedWithDelay && (workInProgressRootExitStatus = RootErrored);
+      if (null === returnFiber) return !0;
+      value = createCapturedValueAtFiber(value, sourceFiber);
+      do {
+        switch (returnFiber.tag) {
+          case 3:
+            return returnFiber.flags |= 65536, root = rootRenderLanes & -rootRenderLanes, returnFiber.lanes |= root, root = createRootErrorUpdate(returnFiber.stateNode, value, root), enqueueCapturedUpdate(returnFiber, root), !1;
+          case 1:
+            if (sourceFiber = returnFiber.type, currentSourceFiber = returnFiber.stateNode, 0 === (returnFiber.flags & 128) && ("function" === typeof sourceFiber.getDerivedStateFromError || null !== currentSourceFiber && "function" === typeof currentSourceFiber.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(currentSourceFiber)))) return returnFiber.flags |= 65536, rootRenderLanes &= -rootRenderLanes, returnFiber.lanes |= rootRenderLanes, rootRenderLanes = createClassErrorUpdate(rootRenderLanes), initializeClassErrorUpdate(rootRenderLanes, root, returnFiber, value), enqueueCapturedUpdate(returnFiber, rootRenderLanes), !1;
+        }
+        returnFiber = returnFiber.return;
+      } while (null !== returnFiber);
+      return !1;
+    }
+    function reconcileChildren(current, workInProgress, nextChildren, renderLanes) {
+      workInProgress.child = null === current ? mountChildFibers(workInProgress, null, nextChildren, renderLanes) : reconcileChildFibers(workInProgress, current.child, nextChildren, renderLanes);
+    }
+    function updateForwardRef(current, workInProgress, Component, nextProps, renderLanes) {
+      Component = Component.render;
+      var ref = workInProgress.ref;
+      if ("ref" in nextProps) {
+        var propsWithoutRef = {};
+        for (var key in nextProps) "ref" !== key && (propsWithoutRef[key] = nextProps[key]);
+      } else propsWithoutRef = nextProps;
+      prepareToReadContext(workInProgress);
+      markComponentRenderStarted(workInProgress);
+      nextProps = renderWithHooks(current, workInProgress, Component, propsWithoutRef, ref, renderLanes);
+      markComponentRenderStopped();
+      if (null !== current && !didReceiveUpdate) return bailoutHooks(current, workInProgress, renderLanes), bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+      workInProgress.flags |= 1;
+      reconcileChildren(current, workInProgress, nextProps, renderLanes);
+      return workInProgress.child;
+    }
+    function updateMemoComponent(current, workInProgress, Component, nextProps, renderLanes) {
+      if (null === current) {
+        var type = Component.type;
+        if ("function" === typeof type && !shouldConstruct(type) && void 0 === type.defaultProps && null === Component.compare) return Component = resolveFunctionForHotReloading(type), workInProgress.tag = 15, workInProgress.type = Component, validateFunctionComponentInDev(workInProgress, type), updateSimpleMemoComponent(current, workInProgress, Component, nextProps, renderLanes);
+        current = createFiberFromTypeAndProps(Component.type, null, nextProps, workInProgress, workInProgress.mode, renderLanes);
+        current.ref = workInProgress.ref;
+        current.return = workInProgress;
+        return workInProgress.child = current;
+      }
+      type = current.child;
+      if (!checkScheduledUpdateOrContext(current, renderLanes)) {
+        var prevProps = type.memoizedProps;
+        Component = Component.compare;
+        Component = null !== Component ? Component : shallowEqual;
+        if (Component(prevProps, nextProps) && current.ref === workInProgress.ref) return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+      }
+      workInProgress.flags |= 1;
+      current = createWorkInProgress(type, nextProps);
+      current.ref = workInProgress.ref;
+      current.return = workInProgress;
+      return workInProgress.child = current;
+    }
+    function updateSimpleMemoComponent(current, workInProgress, Component, nextProps, renderLanes) {
+      if (null !== current) {
+        var prevProps = current.memoizedProps;
+        if (shallowEqual(prevProps, nextProps) && current.ref === workInProgress.ref && workInProgress.type === current.type) if (didReceiveUpdate = !1, workInProgress.pendingProps = nextProps = prevProps, checkScheduledUpdateOrContext(current, renderLanes)) 0 !== (current.flags & 131072) && (didReceiveUpdate = !0);else return workInProgress.lanes = current.lanes, bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+      }
+      return updateFunctionComponent(current, workInProgress, Component, nextProps, renderLanes);
+    }
+    function updateOffscreenComponent(current, workInProgress, renderLanes) {
+      var nextProps = workInProgress.pendingProps,
+        nextChildren = nextProps.children,
+        prevState = null !== current ? current.memoizedState : null;
+      if ("hidden" === nextProps.mode) {
+        if (0 !== (workInProgress.flags & 128)) {
+          nextProps = null !== prevState ? prevState.baseLanes | renderLanes : renderLanes;
+          if (null !== current) {
+            nextChildren = workInProgress.child = current.child;
+            for (prevState = 0; null !== nextChildren;) prevState = prevState | nextChildren.lanes | nextChildren.childLanes, nextChildren = nextChildren.sibling;
+            workInProgress.childLanes = prevState & ~nextProps;
+          } else workInProgress.childLanes = 0, workInProgress.child = null;
+          return deferHiddenOffscreenComponent(current, workInProgress, nextProps, renderLanes);
+        }
+        if (0 === (workInProgress.mode & 1)) workInProgress.memoizedState = {
+          baseLanes: 0,
+          cachePool: null
+        }, null !== current && pushTransition(workInProgress, null), reuseHiddenContextOnStack(workInProgress), pushOffscreenSuspenseHandler(workInProgress);else if (0 !== (renderLanes & 536870912)) workInProgress.memoizedState = {
+          baseLanes: 0,
+          cachePool: null
+        }, null !== current && pushTransition(workInProgress, null !== prevState ? prevState.cachePool : null), null !== prevState ? pushHiddenContext(workInProgress, prevState) : reuseHiddenContextOnStack(workInProgress), pushOffscreenSuspenseHandler(workInProgress);else return workInProgress.lanes = workInProgress.childLanes = 536870912, deferHiddenOffscreenComponent(current, workInProgress, null !== prevState ? prevState.baseLanes | renderLanes : renderLanes, renderLanes);
+      } else null !== prevState ? (pushTransition(workInProgress, prevState.cachePool), pushHiddenContext(workInProgress, prevState), reuseSuspenseHandlerOnStack(workInProgress), workInProgress.memoizedState = null) : (null !== current && pushTransition(workInProgress, null), reuseHiddenContextOnStack(workInProgress), reuseSuspenseHandlerOnStack(workInProgress));
+      reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+      return workInProgress.child;
+    }
+    function deferHiddenOffscreenComponent(current, workInProgress, nextBaseLanes, renderLanes) {
+      var JSCompiler_inline_result = peekCacheFromPool();
+      JSCompiler_inline_result = null === JSCompiler_inline_result ? null : {
+        parent: CacheContext._currentValue,
+        pool: JSCompiler_inline_result
+      };
+      workInProgress.memoizedState = {
+        baseLanes: nextBaseLanes,
+        cachePool: JSCompiler_inline_result
+      };
+      null !== current && pushTransition(workInProgress, null);
+      reuseHiddenContextOnStack(workInProgress);
+      pushOffscreenSuspenseHandler(workInProgress);
+      null !== current && propagateParentContextChanges(current, workInProgress, renderLanes, !0);
+      return null;
+    }
+    function markRef(current, workInProgress) {
+      var ref = workInProgress.ref;
+      if (null === ref) null !== current && null !== current.ref && (workInProgress.flags |= 4194816);else {
+        if ("function" !== typeof ref && "object" !== typeof ref) throw Error("Expected ref to be a function, an object returned by React.createRef(), or undefined/null.");
+        if (null === current || current.ref !== ref) workInProgress.flags |= 4194816;
+      }
+    }
+    function updateFunctionComponent(current, workInProgress, Component, nextProps, renderLanes) {
+      if (Component.prototype && "function" === typeof Component.prototype.render) {
+        var componentName = getComponentNameFromType(Component) || "Unknown";
+        didWarnAboutBadClass[componentName] || (console.error("The <%s /> component appears to have a render method, but doesn't extend React.Component. This is likely to cause errors. Change %s to extend React.Component instead.", componentName, componentName), didWarnAboutBadClass[componentName] = !0);
+      }
+      workInProgress.mode & StrictLegacyMode && ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, null);
+      null === current && (validateFunctionComponentInDev(workInProgress, workInProgress.type), Component.contextTypes && (componentName = getComponentNameFromType(Component) || "Unknown", didWarnAboutContextTypes[componentName] || (didWarnAboutContextTypes[componentName] = !0, console.error("%s uses the legacy contextTypes API which was removed in React 19. Use React.createContext() with React.useContext() instead. (https://react.dev/link/legacy-context)", componentName))));
+      prepareToReadContext(workInProgress);
+      markComponentRenderStarted(workInProgress);
+      Component = renderWithHooks(current, workInProgress, Component, nextProps, void 0, renderLanes);
+      markComponentRenderStopped();
+      if (null !== current && !didReceiveUpdate) return bailoutHooks(current, workInProgress, renderLanes), bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+      workInProgress.flags |= 1;
+      reconcileChildren(current, workInProgress, Component, renderLanes);
+      return workInProgress.child;
+    }
+    function replayFunctionComponent(current, workInProgress, nextProps, Component, secondArg, renderLanes) {
+      prepareToReadContext(workInProgress);
+      markComponentRenderStarted(workInProgress);
+      hookTypesUpdateIndexDev = -1;
+      ignorePreviousDependencies = null !== current && current.type !== workInProgress.type;
+      workInProgress.updateQueue = null;
+      nextProps = renderWithHooksAgain(workInProgress, Component, nextProps, secondArg);
+      finishRenderingHooks(current, workInProgress);
+      markComponentRenderStopped();
+      if (null !== current && !didReceiveUpdate) return bailoutHooks(current, workInProgress, renderLanes), bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+      workInProgress.flags |= 1;
+      reconcileChildren(current, workInProgress, nextProps, renderLanes);
+      return workInProgress.child;
+    }
+    function updateClassComponent(current, workInProgress, Component, nextProps, renderLanes) {
+      switch (shouldErrorImpl(workInProgress)) {
+        case !1:
+          var _instance = workInProgress.stateNode,
+            state = new workInProgress.type(workInProgress.memoizedProps, _instance.context).state;
+          _instance.updater.enqueueSetState(_instance, state, null);
+          break;
+        case !0:
+          workInProgress.flags |= 128;
+          workInProgress.flags |= 65536;
+          _instance = Error("Simulated error coming from DevTools");
+          var lane = renderLanes & -renderLanes;
+          workInProgress.lanes |= lane;
+          state = workInProgressRoot;
+          if (null === state) throw Error("Expected a work-in-progress root. This is a bug in React. Please file an issue.");
+          lane = createClassErrorUpdate(lane);
+          initializeClassErrorUpdate(lane, state, workInProgress, createCapturedValueAtFiber(_instance, workInProgress));
+          enqueueCapturedUpdate(workInProgress, lane);
+      }
+      prepareToReadContext(workInProgress);
+      if (null === workInProgress.stateNode) resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress), constructClassInstance(workInProgress, Component, nextProps), mountClassInstance(workInProgress, Component, nextProps, renderLanes), _instance = !0;else if (null === current) {
+        _instance = workInProgress.stateNode;
+        var unresolvedOldProps = workInProgress.memoizedProps;
+        lane = resolveClassComponentProps(Component, unresolvedOldProps);
+        _instance.props = lane;
+        var oldContext = _instance.context,
+          contextType = Component.contextType;
+        state = emptyContextObject;
+        "object" === typeof contextType && null !== contextType && (state = _readContext(contextType));
+        var getDerivedStateFromProps = Component.getDerivedStateFromProps;
+        contextType = "function" === typeof getDerivedStateFromProps || "function" === typeof _instance.getSnapshotBeforeUpdate;
+        unresolvedOldProps = workInProgress.pendingProps !== unresolvedOldProps;
+        contextType || "function" !== typeof _instance.UNSAFE_componentWillReceiveProps && "function" !== typeof _instance.componentWillReceiveProps || (unresolvedOldProps || oldContext !== state) && callComponentWillReceiveProps(workInProgress, _instance, nextProps, state);
+        hasForceUpdate = !1;
+        var oldState = workInProgress.memoizedState;
+        _instance.state = oldState;
+        processUpdateQueue(workInProgress, nextProps, _instance, renderLanes);
+        suspendIfUpdateReadFromEntangledAsyncAction();
+        oldContext = workInProgress.memoizedState;
+        unresolvedOldProps || oldState !== oldContext || hasForceUpdate ? ("function" === typeof getDerivedStateFromProps && (applyDerivedStateFromProps(workInProgress, Component, getDerivedStateFromProps, nextProps), oldContext = workInProgress.memoizedState), (lane = hasForceUpdate || checkShouldComponentUpdate(workInProgress, Component, lane, nextProps, oldState, oldContext, state)) ? (contextType || "function" !== typeof _instance.UNSAFE_componentWillMount && "function" !== typeof _instance.componentWillMount || ("function" === typeof _instance.componentWillMount && _instance.componentWillMount(), "function" === typeof _instance.UNSAFE_componentWillMount && _instance.UNSAFE_componentWillMount()), "function" === typeof _instance.componentDidMount && (workInProgress.flags |= 4194308), 0 !== (workInProgress.mode & 16) && (workInProgress.flags |= 134217728)) : ("function" === typeof _instance.componentDidMount && (workInProgress.flags |= 4194308), 0 !== (workInProgress.mode & 16) && (workInProgress.flags |= 134217728), workInProgress.memoizedProps = nextProps, workInProgress.memoizedState = oldContext), _instance.props = nextProps, _instance.state = oldContext, _instance.context = state, _instance = lane) : ("function" === typeof _instance.componentDidMount && (workInProgress.flags |= 4194308), 0 !== (workInProgress.mode & 16) && (workInProgress.flags |= 134217728), _instance = !1);
+      } else {
+        _instance = workInProgress.stateNode;
+        cloneUpdateQueue(current, workInProgress);
+        state = workInProgress.memoizedProps;
+        contextType = resolveClassComponentProps(Component, state);
+        _instance.props = contextType;
+        getDerivedStateFromProps = workInProgress.pendingProps;
+        oldState = _instance.context;
+        oldContext = Component.contextType;
+        lane = emptyContextObject;
+        "object" === typeof oldContext && null !== oldContext && (lane = _readContext(oldContext));
+        unresolvedOldProps = Component.getDerivedStateFromProps;
+        (oldContext = "function" === typeof unresolvedOldProps || "function" === typeof _instance.getSnapshotBeforeUpdate) || "function" !== typeof _instance.UNSAFE_componentWillReceiveProps && "function" !== typeof _instance.componentWillReceiveProps || (state !== getDerivedStateFromProps || oldState !== lane) && callComponentWillReceiveProps(workInProgress, _instance, nextProps, lane);
+        hasForceUpdate = !1;
+        oldState = workInProgress.memoizedState;
+        _instance.state = oldState;
+        processUpdateQueue(workInProgress, nextProps, _instance, renderLanes);
+        suspendIfUpdateReadFromEntangledAsyncAction();
+        var newState = workInProgress.memoizedState;
+        state !== getDerivedStateFromProps || oldState !== newState || hasForceUpdate || null !== current && null !== current.dependencies && checkIfContextChanged(current.dependencies) ? ("function" === typeof unresolvedOldProps && (applyDerivedStateFromProps(workInProgress, Component, unresolvedOldProps, nextProps), newState = workInProgress.memoizedState), (contextType = hasForceUpdate || checkShouldComponentUpdate(workInProgress, Component, contextType, nextProps, oldState, newState, lane) || null !== current && null !== current.dependencies && checkIfContextChanged(current.dependencies)) ? (oldContext || "function" !== typeof _instance.UNSAFE_componentWillUpdate && "function" !== typeof _instance.componentWillUpdate || ("function" === typeof _instance.componentWillUpdate && _instance.componentWillUpdate(nextProps, newState, lane), "function" === typeof _instance.UNSAFE_componentWillUpdate && _instance.UNSAFE_componentWillUpdate(nextProps, newState, lane)), "function" === typeof _instance.componentDidUpdate && (workInProgress.flags |= 4), "function" === typeof _instance.getSnapshotBeforeUpdate && (workInProgress.flags |= 1024)) : ("function" !== typeof _instance.componentDidUpdate || state === current.memoizedProps && oldState === current.memoizedState || (workInProgress.flags |= 4), "function" !== typeof _instance.getSnapshotBeforeUpdate || state === current.memoizedProps && oldState === current.memoizedState || (workInProgress.flags |= 1024), workInProgress.memoizedProps = nextProps, workInProgress.memoizedState = newState), _instance.props = nextProps, _instance.state = newState, _instance.context = lane, _instance = contextType) : ("function" !== typeof _instance.componentDidUpdate || state === current.memoizedProps && oldState === current.memoizedState || (workInProgress.flags |= 4), "function" !== typeof _instance.getSnapshotBeforeUpdate || state === current.memoizedProps && oldState === current.memoizedState || (workInProgress.flags |= 1024), _instance = !1);
+      }
+      current = finishClassComponent(current, workInProgress, Component, _instance, !1, renderLanes);
+      Component = workInProgress.stateNode;
+      _instance && Component.props !== nextProps && (didWarnAboutReassigningProps || console.error("It looks like %s is reassigning its own `this.props` while rendering. This is not supported and can lead to confusing bugs.", getComponentNameFromFiber(workInProgress) || "a component"), didWarnAboutReassigningProps = !0);
+      return current;
+    }
+    function finishClassComponent(current, workInProgress, Component, shouldUpdate, hasContext, renderLanes) {
+      markRef(current, workInProgress);
+      hasContext = 0 !== (workInProgress.flags & 128);
+      if (!shouldUpdate && !hasContext) return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+      shouldUpdate = workInProgress.stateNode;
+      setCurrentFiber(workInProgress);
+      if (hasContext && "function" !== typeof Component.getDerivedStateFromError) Component = null, profilerStartTime = -1;else {
+        markComponentRenderStarted(workInProgress);
+        Component = callRenderInDEV(shouldUpdate);
+        if (workInProgress.mode & StrictLegacyMode) {
+          setIsStrictModeForDevtools(!0);
+          try {
+            callRenderInDEV(shouldUpdate);
+          } finally {
+            setIsStrictModeForDevtools(!1);
+          }
+        }
+        markComponentRenderStopped();
+      }
+      workInProgress.flags |= 1;
+      null !== current && hasContext ? (workInProgress.child = reconcileChildFibers(workInProgress, current.child, null, renderLanes), workInProgress.child = reconcileChildFibers(workInProgress, null, Component, renderLanes)) : reconcileChildren(current, workInProgress, Component, renderLanes);
+      workInProgress.memoizedState = shouldUpdate.state;
+      return workInProgress.child;
+    }
+    function validateFunctionComponentInDev(workInProgress, Component) {
+      Component && Component.childContextTypes && console.error("childContextTypes cannot be defined on a function component.\n  %s.childContextTypes = ...", Component.displayName || Component.name || "Component");
+      "function" === typeof Component.getDerivedStateFromProps && (workInProgress = getComponentNameFromType(Component) || "Unknown", didWarnAboutGetDerivedStateOnFunctionComponent[workInProgress] || (console.error("%s: Function components do not support getDerivedStateFromProps.", workInProgress), didWarnAboutGetDerivedStateOnFunctionComponent[workInProgress] = !0));
+      "object" === typeof Component.contextType && null !== Component.contextType && (Component = getComponentNameFromType(Component) || "Unknown", didWarnAboutContextTypeOnFunctionComponent[Component] || (console.error("%s: Function components do not support contextType.", Component), didWarnAboutContextTypeOnFunctionComponent[Component] = !0));
+    }
+    function mountSuspenseOffscreenState(renderLanes) {
+      return {
+        baseLanes: renderLanes,
+        cachePool: getSuspendedCache()
+      };
+    }
+    function getRemainingWorkInPrimaryTree(current, primaryTreeDidDefer, renderLanes) {
+      current = null !== current ? current.childLanes & ~renderLanes : 0;
+      primaryTreeDidDefer && (current |= workInProgressDeferredLane);
+      return current;
+    }
+    function updateSuspenseComponent(current, workInProgress, renderLanes) {
+      var nextProps = workInProgress.pendingProps;
+      shouldSuspendImpl(workInProgress) && (workInProgress.flags |= 128);
+      var showFallback = !1,
+        didSuspend = 0 !== (workInProgress.flags & 128),
+        JSCompiler_temp;
+      (JSCompiler_temp = didSuspend) || (JSCompiler_temp = null !== current && null === current.memoizedState ? !1 : 0 !== (suspenseStackCursor.current & ForceSuspenseFallback));
+      JSCompiler_temp && (showFallback = !0, workInProgress.flags &= -129);
+      JSCompiler_temp = 0 !== (workInProgress.flags & 32);
+      workInProgress.flags &= -33;
+      if (null === current) {
+        var nextPrimaryChildren = nextProps.children;
+        nextProps = nextProps.fallback;
+        if (showFallback) return reuseSuspenseHandlerOnStack(workInProgress), showFallback = workInProgress.mode, didSuspend = workInProgress.child, nextPrimaryChildren = {
+          mode: "hidden",
+          children: nextPrimaryChildren
+        }, 0 === (showFallback & 1) && null !== didSuspend ? (didSuspend.childLanes = 0, didSuspend.pendingProps = nextPrimaryChildren, workInProgress.mode & 2 && (didSuspend.actualDuration = -0, didSuspend.actualStartTime = -1.1, didSuspend.selfBaseDuration = -0, didSuspend.treeBaseDuration = -0)) : didSuspend = mountWorkInProgressOffscreenFiber(nextPrimaryChildren, showFallback), nextProps = createFiberFromFragment(nextProps, showFallback, renderLanes, null), didSuspend.return = workInProgress, nextProps.return = workInProgress, didSuspend.sibling = nextProps, workInProgress.child = didSuspend, nextPrimaryChildren = workInProgress.child, nextPrimaryChildren.memoizedState = mountSuspenseOffscreenState(renderLanes), nextPrimaryChildren.childLanes = getRemainingWorkInPrimaryTree(current, JSCompiler_temp, renderLanes), workInProgress.memoizedState = SUSPENDED_MARKER, nextProps;
+        pushPrimaryTreeSuspenseHandler(workInProgress);
+        return mountSuspensePrimaryChildren(workInProgress, nextPrimaryChildren);
+      }
+      nextPrimaryChildren = current.memoizedState;
+      if (null !== nextPrimaryChildren && null !== nextPrimaryChildren.dehydrated) {
+        if (didSuspend) workInProgress.flags & 256 ? (pushPrimaryTreeSuspenseHandler(workInProgress), workInProgress.flags &= -257, workInProgress = retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes)) : null !== workInProgress.memoizedState ? (reuseSuspenseHandlerOnStack(workInProgress), workInProgress.child = current.child, workInProgress.flags |= 128, workInProgress = null) : (reuseSuspenseHandlerOnStack(workInProgress), nextPrimaryChildren = nextProps.fallback, showFallback = workInProgress.mode, nextProps = mountWorkInProgressOffscreenFiber({
+          mode: "visible",
+          children: nextProps.children
+        }, showFallback), nextPrimaryChildren = createFiberFromFragment(nextPrimaryChildren, showFallback, renderLanes, null), nextPrimaryChildren.flags |= 2, nextProps.return = workInProgress, nextPrimaryChildren.return = workInProgress, nextProps.sibling = nextPrimaryChildren, workInProgress.child = nextProps, 0 !== (workInProgress.mode & 1) && reconcileChildFibers(workInProgress, current.child, null, renderLanes), nextProps = workInProgress.child, nextProps.memoizedState = mountSuspenseOffscreenState(renderLanes), nextProps.childLanes = getRemainingWorkInPrimaryTree(current, JSCompiler_temp, renderLanes), workInProgress.memoizedState = SUSPENDED_MARKER, workInProgress = nextPrimaryChildren);else if (pushPrimaryTreeSuspenseHandler(workInProgress), isSuspenseInstanceFallback()) showFallback = getSuspenseInstanceFallbackErrorDetails(), JSCompiler_temp = showFallback.digest, nextPrimaryChildren = showFallback.message, nextProps = showFallback.stack, showFallback = showFallback.componentStack, nextPrimaryChildren = nextPrimaryChildren ? Error(nextPrimaryChildren) : Error("The server could not finish this Suspense boundary, likely due to an error during server rendering. Switched to client rendering."), nextPrimaryChildren.stack = nextProps || "", nextPrimaryChildren.digest = JSCompiler_temp, JSCompiler_temp = void 0 === showFallback ? null : showFallback, nextProps = {
+          value: nextPrimaryChildren,
+          source: null,
+          stack: JSCompiler_temp
+        }, "string" === typeof JSCompiler_temp && CapturedStacks.set(nextPrimaryChildren, nextProps), null === hydrationErrors ? hydrationErrors = [nextProps] : hydrationErrors.push(nextProps), workInProgress = retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes);else if (didReceiveUpdate || propagateParentContextChanges(current, workInProgress, renderLanes, !1), JSCompiler_temp = 0 !== (renderLanes & current.childLanes), didReceiveUpdate || JSCompiler_temp) {
+          JSCompiler_temp = workInProgressRoot;
+          if (null !== JSCompiler_temp) {
+            nextProps = renderLanes & -renderLanes;
+            if (0 !== (nextProps & 42)) nextProps = 1;else switch (nextProps) {
+              case 2:
+                nextProps = 1;
+                break;
+              case 8:
+                nextProps = 4;
+                break;
+              case 32:
+                nextProps = 16;
+                break;
+              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:
+                nextProps = 128;
+                break;
+              case 268435456:
+                nextProps = 134217728;
+                break;
+              default:
+                nextProps = 0;
+            }
+            nextProps = 0 !== (nextProps & (JSCompiler_temp.suspendedLanes | renderLanes)) ? 0 : nextProps;
+            if (0 !== nextProps && nextProps !== nextPrimaryChildren.retryLane) throw nextPrimaryChildren.retryLane = nextProps, enqueueConcurrentRenderForLane(current, nextProps), scheduleUpdateOnFiber(JSCompiler_temp, current, nextProps), SelectiveHydrationException;
+          }
+          isSuspenseInstancePending() || renderDidSuspendDelayIfPossible();
+          workInProgress = retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes);
+        } else isSuspenseInstancePending() ? (workInProgress.flags |= 192, workInProgress.child = current.child, workInProgress = null) : (workInProgress = mountSuspensePrimaryChildren(workInProgress, nextProps.children), workInProgress.flags |= 4096);
+        return workInProgress;
+      }
+      if (showFallback) {
+        reuseSuspenseHandlerOnStack(workInProgress);
+        nextPrimaryChildren = nextProps.fallback;
+        showFallback = workInProgress.mode;
+        didSuspend = current.child;
+        var currentFallbackChildFragment = didSuspend.sibling,
+          primaryChildProps = {
+            mode: "hidden",
+            children: nextProps.children
+          };
+        0 === (showFallback & 1) && workInProgress.child !== didSuspend ? (nextProps = workInProgress.child, nextProps.childLanes = 0, nextProps.pendingProps = primaryChildProps, workInProgress.mode & 2 && (nextProps.actualDuration = -0, nextProps.actualStartTime = -1.1, nextProps.selfBaseDuration = didSuspend.selfBaseDuration, nextProps.treeBaseDuration = didSuspend.treeBaseDuration), workInProgress.deletions = null) : (nextProps = createWorkInProgress(didSuspend, primaryChildProps), nextProps.subtreeFlags = didSuspend.subtreeFlags & 65011712);
+        null !== currentFallbackChildFragment ? nextPrimaryChildren = createWorkInProgress(currentFallbackChildFragment, nextPrimaryChildren) : (nextPrimaryChildren = createFiberFromFragment(nextPrimaryChildren, showFallback, renderLanes, null), nextPrimaryChildren.flags |= 2);
+        nextPrimaryChildren.return = workInProgress;
+        nextProps.return = workInProgress;
+        nextProps.sibling = nextPrimaryChildren;
+        workInProgress.child = nextProps;
+        nextProps = nextPrimaryChildren;
+        nextPrimaryChildren = workInProgress.child;
+        showFallback = current.child.memoizedState;
+        null === showFallback ? showFallback = mountSuspenseOffscreenState(renderLanes) : (didSuspend = showFallback.cachePool, null !== didSuspend ? (currentFallbackChildFragment = CacheContext._currentValue, didSuspend = didSuspend.parent !== currentFallbackChildFragment ? {
+          parent: currentFallbackChildFragment,
+          pool: currentFallbackChildFragment
+        } : didSuspend) : didSuspend = getSuspendedCache(), showFallback = {
+          baseLanes: showFallback.baseLanes | renderLanes,
+          cachePool: didSuspend
+        });
+        nextPrimaryChildren.memoizedState = showFallback;
+        nextPrimaryChildren.childLanes = getRemainingWorkInPrimaryTree(current, JSCompiler_temp, renderLanes);
+        workInProgress.memoizedState = SUSPENDED_MARKER;
+        return nextProps;
+      }
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      JSCompiler_temp = current.child;
+      current = JSCompiler_temp.sibling;
+      JSCompiler_temp = createWorkInProgress(JSCompiler_temp, {
+        mode: "visible",
+        children: nextProps.children
+      });
+      0 === (workInProgress.mode & 1) && (JSCompiler_temp.lanes = renderLanes);
+      JSCompiler_temp.return = workInProgress;
+      JSCompiler_temp.sibling = null;
+      null !== current && (renderLanes = workInProgress.deletions, null === renderLanes ? (workInProgress.deletions = [current], workInProgress.flags |= 16) : renderLanes.push(current));
+      workInProgress.child = JSCompiler_temp;
+      workInProgress.memoizedState = null;
+      return JSCompiler_temp;
+    }
+    function mountSuspensePrimaryChildren(workInProgress, primaryChildren) {
+      primaryChildren = mountWorkInProgressOffscreenFiber({
+        mode: "visible",
+        children: primaryChildren
+      }, workInProgress.mode);
+      primaryChildren.return = workInProgress;
+      return workInProgress.child = primaryChildren;
+    }
+    function mountWorkInProgressOffscreenFiber(offscreenProps, mode) {
+      offscreenProps = createFiber(22, offscreenProps, null, mode);
+      offscreenProps.lanes = 0;
+      offscreenProps.stateNode = {
+        _visibility: 1,
+        _pendingMarkers: null,
+        _retryCache: null,
+        _transitions: null
+      };
+      return offscreenProps;
+    }
+    function retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes) {
+      reconcileChildFibers(workInProgress, current.child, null, renderLanes);
+      current = mountSuspensePrimaryChildren(workInProgress, workInProgress.pendingProps.children);
+      current.flags |= 2;
+      workInProgress.memoizedState = null;
+      return current;
+    }
+    function scheduleSuspenseWorkOnFiber(fiber, renderLanes, propagationRoot) {
+      fiber.lanes |= renderLanes;
+      var alternate = fiber.alternate;
+      null !== alternate && (alternate.lanes |= renderLanes);
+      scheduleContextWorkOnParentPath(fiber.return, renderLanes, propagationRoot);
+    }
+    function validateSuspenseListNestedChild(childSlot, index) {
+      var isAnArray = isArrayImpl(childSlot);
+      childSlot = !isAnArray && "function" === typeof getIteratorFn(childSlot);
+      return isAnArray || childSlot ? (isAnArray = isAnArray ? "array" : "iterable", console.error("A nested %s was passed to row #%s in <SuspenseList />. Wrap it in an additional SuspenseList to configure its revealOrder: <SuspenseList revealOrder=...> ... <SuspenseList revealOrder=...>{%s}</SuspenseList> ... </SuspenseList>", isAnArray, index, isAnArray), !1) : !0;
+    }
+    function initSuspenseListRenderState(workInProgress, isBackwards, tail, lastContentRow, tailMode) {
+      var renderState = workInProgress.memoizedState;
+      null === renderState ? workInProgress.memoizedState = {
+        isBackwards: isBackwards,
+        rendering: null,
+        renderingStartTime: 0,
+        last: lastContentRow,
+        tail: tail,
+        tailMode: tailMode
+      } : (renderState.isBackwards = isBackwards, renderState.rendering = null, renderState.renderingStartTime = 0, renderState.last = lastContentRow, renderState.tail = tail, renderState.tailMode = tailMode);
+    }
+    function updateSuspenseListComponent(current, workInProgress, renderLanes) {
+      var nextProps = workInProgress.pendingProps,
+        revealOrder = nextProps.revealOrder,
+        tailMode = nextProps.tail;
+      nextProps = nextProps.children;
+      if (void 0 !== revealOrder && "forwards" !== revealOrder && "backwards" !== revealOrder && "together" !== revealOrder && !didWarnAboutRevealOrder[revealOrder]) if (didWarnAboutRevealOrder[revealOrder] = !0, "string" === typeof revealOrder) switch (revealOrder.toLowerCase()) {
+        case "together":
+        case "forwards":
+        case "backwards":
+          console.error('"%s" is not a valid value for revealOrder on <SuspenseList />. Use lowercase "%s" instead.', revealOrder, revealOrder.toLowerCase());
+          break;
+        case "forward":
+        case "backward":
+          console.error('"%s" is not a valid value for revealOrder on <SuspenseList />. React uses the -s suffix in the spelling. Use "%ss" instead.', revealOrder, revealOrder.toLowerCase());
+          break;
+        default:
+          console.error('"%s" is not a supported revealOrder on <SuspenseList />. Did you mean "together", "forwards" or "backwards"?', revealOrder);
+      } else console.error('%s is not a supported value for revealOrder on <SuspenseList />. Did you mean "together", "forwards" or "backwards"?', revealOrder);
+      void 0 === tailMode || didWarnAboutTailOptions[tailMode] || ("collapsed" !== tailMode && "hidden" !== tailMode ? (didWarnAboutTailOptions[tailMode] = !0, console.error('"%s" is not a supported value for tail on <SuspenseList />. Did you mean "collapsed" or "hidden"?', tailMode)) : "forwards" !== revealOrder && "backwards" !== revealOrder && (didWarnAboutTailOptions[tailMode] = !0, console.error('<SuspenseList tail="%s" /> is only valid if revealOrder is "forwards" or "backwards". Did you mean to specify revealOrder="forwards"?', tailMode)));
+      a: if (("forwards" === revealOrder || "backwards" === revealOrder) && void 0 !== nextProps && null !== nextProps && !1 !== nextProps) if (isArrayImpl(nextProps)) for (var i = 0; i < nextProps.length; i++) {
+        if (!validateSuspenseListNestedChild(nextProps[i], i)) break a;
+      } else if (i = getIteratorFn(nextProps), "function" === typeof i) {
+        if (i = i.call(nextProps)) for (var step = i.next(), _i = 0; !step.done; step = i.next()) {
+          if (!validateSuspenseListNestedChild(step.value, _i)) break a;
+          _i++;
+        }
+      } else console.error('A single row was passed to a <SuspenseList revealOrder="%s" />. This is not useful since it needs multiple rows. Did you mean to pass multiple children or an array?', revealOrder);
+      reconcileChildren(current, workInProgress, nextProps, renderLanes);
+      nextProps = suspenseStackCursor.current;
+      if (0 !== (nextProps & ForceSuspenseFallback)) nextProps = nextProps & SubtreeSuspenseContextMask | ForceSuspenseFallback, workInProgress.flags |= 128;else {
+        if (null !== current && 0 !== (current.flags & 128)) a: for (current = workInProgress.child; null !== current;) {
+          if (13 === current.tag) null !== current.memoizedState && scheduleSuspenseWorkOnFiber(current, renderLanes, workInProgress);else if (19 === current.tag) scheduleSuspenseWorkOnFiber(current, renderLanes, workInProgress);else if (null !== current.child) {
+            current.child.return = current;
+            current = current.child;
+            continue;
+          }
+          if (current === workInProgress) break a;
+          for (; null === current.sibling;) {
+            if (null === current.return || current.return === workInProgress) break a;
+            current = current.return;
+          }
+          current.sibling.return = current.return;
+          current = current.sibling;
+        }
+        nextProps &= SubtreeSuspenseContextMask;
+      }
+      push(suspenseStackCursor, nextProps, workInProgress);
+      if (0 === (workInProgress.mode & 1)) workInProgress.memoizedState = null;else switch (revealOrder) {
+        case "forwards":
+          renderLanes = workInProgress.child;
+          for (revealOrder = null; null !== renderLanes;) current = renderLanes.alternate, null !== current && null === findFirstSuspended(current) && (revealOrder = renderLanes), renderLanes = renderLanes.sibling;
+          renderLanes = revealOrder;
+          null === renderLanes ? (revealOrder = workInProgress.child, workInProgress.child = null) : (revealOrder = renderLanes.sibling, renderLanes.sibling = null);
+          initSuspenseListRenderState(workInProgress, !1, revealOrder, renderLanes, tailMode);
+          break;
+        case "backwards":
+          renderLanes = null;
+          revealOrder = workInProgress.child;
+          for (workInProgress.child = null; null !== revealOrder;) {
+            current = revealOrder.alternate;
+            if (null !== current && null === findFirstSuspended(current)) {
+              workInProgress.child = revealOrder;
+              break;
+            }
+            current = revealOrder.sibling;
+            revealOrder.sibling = renderLanes;
+            renderLanes = revealOrder;
+            revealOrder = current;
+          }
+          initSuspenseListRenderState(workInProgress, !0, renderLanes, null, tailMode);
+          break;
+        case "together":
+          initSuspenseListRenderState(workInProgress, !1, null, null, void 0);
+          break;
+        default:
+          workInProgress.memoizedState = null;
+      }
+      return workInProgress.child;
+    }
+    function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
+      0 === (workInProgress.mode & 1) && null !== current && (current.alternate = null, workInProgress.alternate = null, workInProgress.flags |= 2);
+    }
+    function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
+      null !== current && (workInProgress.dependencies = current.dependencies);
+      profilerStartTime = -1;
+      workInProgressRootSkippedLanes |= workInProgress.lanes;
+      if (0 === (renderLanes & workInProgress.childLanes)) if (null !== current) {
+        if (propagateParentContextChanges(current, workInProgress, renderLanes, !1), 0 === (renderLanes & workInProgress.childLanes)) return null;
+      } else return null;
+      if (null !== current && workInProgress.child !== current.child) throw Error("Resuming work not yet implemented.");
+      if (null !== workInProgress.child) {
+        current = workInProgress.child;
+        renderLanes = createWorkInProgress(current, current.pendingProps);
+        workInProgress.child = renderLanes;
+        for (renderLanes.return = workInProgress; null !== current.sibling;) current = current.sibling, renderLanes = renderLanes.sibling = createWorkInProgress(current, current.pendingProps), renderLanes.return = workInProgress;
+        renderLanes.sibling = null;
+      }
+      return workInProgress.child;
+    }
+    function checkScheduledUpdateOrContext(current, renderLanes) {
+      if (0 !== (current.lanes & renderLanes)) return !0;
+      current = current.dependencies;
+      return null !== current && checkIfContextChanged(current) ? !0 : !1;
+    }
+    function attemptEarlyBailoutIfNoScheduledUpdate(current, workInProgress, renderLanes) {
+      switch (workInProgress.tag) {
+        case 3:
+          pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+          pushProvider(workInProgress, CacheContext, current.memoizedState.cache);
+          break;
+        case 27:
+        case 5:
+          pushHostContext(workInProgress);
+          break;
+        case 4:
+          pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+          break;
+        case 10:
+          pushProvider(workInProgress, workInProgress.type, workInProgress.memoizedProps.value);
+          break;
+        case 12:
+          0 !== (renderLanes & workInProgress.childLanes) && (workInProgress.flags |= 4);
+          workInProgress.flags |= 2048;
+          var stateNode = workInProgress.stateNode;
+          stateNode.effectDuration = -0;
+          stateNode.passiveEffectDuration = -0;
+          break;
+        case 13:
+          stateNode = workInProgress.memoizedState;
+          if (null !== stateNode) {
+            if (null !== stateNode.dehydrated) return pushPrimaryTreeSuspenseHandler(workInProgress), workInProgress.flags |= 128, null;
+            if (0 !== (renderLanes & workInProgress.child.childLanes)) return updateSuspenseComponent(current, workInProgress, renderLanes);
+            pushPrimaryTreeSuspenseHandler(workInProgress);
+            current = bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+            return null !== current ? current.sibling : null;
+          }
+          pushPrimaryTreeSuspenseHandler(workInProgress);
+          break;
+        case 19:
+          var didSuspendBefore = 0 !== (current.flags & 128);
+          stateNode = 0 !== (renderLanes & workInProgress.childLanes);
+          stateNode || (propagateParentContextChanges(current, workInProgress, renderLanes, !1), stateNode = 0 !== (renderLanes & workInProgress.childLanes));
+          if (didSuspendBefore) {
+            if (stateNode) return updateSuspenseListComponent(current, workInProgress, renderLanes);
+            workInProgress.flags |= 128;
+          }
+          didSuspendBefore = workInProgress.memoizedState;
+          null !== didSuspendBefore && (didSuspendBefore.rendering = null, didSuspendBefore.tail = null, didSuspendBefore.lastEffect = null);
+          push(suspenseStackCursor, suspenseStackCursor.current, workInProgress);
+          if (stateNode) break;else return null;
+        case 22:
+        case 23:
+          return workInProgress.lanes = 0, updateOffscreenComponent(current, workInProgress, renderLanes);
+        case 24:
+          pushProvider(workInProgress, CacheContext, current.memoizedState.cache);
+      }
+      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    }
+    function beginWork(current, workInProgress, renderLanes) {
+      if (workInProgress._debugNeedsRemount && null !== current) {
+        renderLanes = createFiberFromTypeAndProps(workInProgress.type, workInProgress.key, workInProgress.pendingProps, workInProgress._debugOwner || null, workInProgress.mode, workInProgress.lanes);
+        renderLanes._debugStack = workInProgress._debugStack;
+        renderLanes._debugTask = workInProgress._debugTask;
+        var returnFiber = workInProgress.return;
+        if (null === returnFiber) throw Error("Cannot swap the root fiber.");
+        current.alternate = null;
+        workInProgress.alternate = null;
+        renderLanes.index = workInProgress.index;
+        renderLanes.sibling = workInProgress.sibling;
+        renderLanes.return = workInProgress.return;
+        renderLanes.ref = workInProgress.ref;
+        renderLanes._debugInfo = workInProgress._debugInfo;
+        if (workInProgress === returnFiber.child) returnFiber.child = renderLanes;else {
+          var prevSibling = returnFiber.child;
+          if (null === prevSibling) throw Error("Expected parent to have a child.");
+          for (; prevSibling.sibling !== workInProgress;) if (prevSibling = prevSibling.sibling, null === prevSibling) throw Error("Expected to find the previous sibling.");
+          prevSibling.sibling = renderLanes;
+        }
+        workInProgress = returnFiber.deletions;
+        null === workInProgress ? (returnFiber.deletions = [current], returnFiber.flags |= 16) : workInProgress.push(current);
+        renderLanes.flags |= 2;
+        return renderLanes;
+      }
+      if (null !== current) {
+        if (current.memoizedProps !== workInProgress.pendingProps || workInProgress.type !== current.type) didReceiveUpdate = !0;else {
+          if (!checkScheduledUpdateOrContext(current, renderLanes) && 0 === (workInProgress.flags & 128)) return didReceiveUpdate = !1, attemptEarlyBailoutIfNoScheduledUpdate(current, workInProgress, renderLanes);
+          didReceiveUpdate = 0 !== (current.flags & 131072) ? !0 : !1;
+        }
+      } else didReceiveUpdate = !1;
+      workInProgress.lanes = 0;
+      switch (workInProgress.tag) {
+        case 16:
+          a: if (prevSibling = workInProgress.elementType, resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress), returnFiber = workInProgress.pendingProps, current = callLazyInitInDEV(prevSibling), workInProgress.type = current, "function" === typeof current) shouldConstruct(current) ? (returnFiber = resolveClassComponentProps(current, returnFiber), workInProgress.tag = 1, workInProgress.type = current = resolveFunctionForHotReloading(current), workInProgress = updateClassComponent(null, workInProgress, current, returnFiber, renderLanes)) : (workInProgress.tag = 0, validateFunctionComponentInDev(workInProgress, current), workInProgress.type = current = resolveFunctionForHotReloading(current), workInProgress = updateFunctionComponent(null, workInProgress, current, returnFiber, renderLanes));else {
+            if (void 0 !== current && null !== current) if (prevSibling = current.$$typeof, prevSibling === REACT_FORWARD_REF_TYPE) {
+              workInProgress.tag = 11;
+              workInProgress.type = current = resolveForwardRefForHotReloading(current);
+              workInProgress = updateForwardRef(null, workInProgress, current, returnFiber, renderLanes);
+              break a;
+            } else if (prevSibling === REACT_MEMO_TYPE) {
+              workInProgress.tag = 14;
+              workInProgress = updateMemoComponent(null, workInProgress, current, returnFiber, renderLanes);
+              break a;
+            }
+            workInProgress = "";
+            null !== current && "object" === typeof current && current.$$typeof === REACT_LAZY_TYPE && (workInProgress = " Did you wrap a component in React.lazy() more than once?");
+            current = getComponentNameFromType(current) || current;
+            throw Error("Element type is invalid. Received a promise that resolves to: " + current + ". Lazy element type must resolve to a class or function." + workInProgress);
+          }
+          return workInProgress;
+        case 0:
+          return updateFunctionComponent(current, workInProgress, workInProgress.type, workInProgress.pendingProps, renderLanes);
+        case 1:
+          return returnFiber = workInProgress.type, prevSibling = resolveClassComponentProps(returnFiber, workInProgress.pendingProps), updateClassComponent(current, workInProgress, returnFiber, prevSibling, renderLanes);
+        case 3:
+          pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+          if (null === current) throw Error("Should have a current fiber. This is a bug in React.");
+          var nextProps = workInProgress.pendingProps;
+          prevSibling = workInProgress.memoizedState;
+          returnFiber = prevSibling.element;
+          cloneUpdateQueue(current, workInProgress);
+          processUpdateQueue(workInProgress, nextProps, null, renderLanes);
+          nextProps = workInProgress.memoizedState;
+          var nextCache = nextProps.cache;
+          pushProvider(workInProgress, CacheContext, nextCache);
+          nextCache !== prevSibling.cache && propagateContextChanges(workInProgress, [CacheContext], renderLanes, !0);
+          suspendIfUpdateReadFromEntangledAsyncAction();
+          prevSibling = nextProps.element;
+          prevSibling === returnFiber ? workInProgress = bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) : (reconcileChildren(current, workInProgress, prevSibling, renderLanes), workInProgress = workInProgress.child);
+          return workInProgress;
+        case 26:
+        case 27:
+        case 5:
+          return pushHostContext(workInProgress), returnFiber = workInProgress.pendingProps.children, null !== workInProgress.memoizedState && (prevSibling = renderWithHooks(current, workInProgress, TransitionAwareHostComponent, null, null, renderLanes), HostTransitionContext._currentValue = prevSibling), markRef(current, workInProgress), reconcileChildren(current, workInProgress, returnFiber, renderLanes), workInProgress.child;
+        case 6:
+          return null;
+        case 13:
+          return updateSuspenseComponent(current, workInProgress, renderLanes);
+        case 4:
+          return pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo), returnFiber = workInProgress.pendingProps, null === current ? workInProgress.child = reconcileChildFibers(workInProgress, null, returnFiber, renderLanes) : reconcileChildren(current, workInProgress, returnFiber, renderLanes), workInProgress.child;
+        case 11:
+          return updateForwardRef(current, workInProgress, workInProgress.type, workInProgress.pendingProps, renderLanes);
+        case 7:
+          return reconcileChildren(current, workInProgress, workInProgress.pendingProps, renderLanes), workInProgress.child;
+        case 8:
+          return reconcileChildren(current, workInProgress, workInProgress.pendingProps.children, renderLanes), workInProgress.child;
+        case 12:
+          return workInProgress.flags |= 4, workInProgress.flags |= 2048, returnFiber = workInProgress.stateNode, returnFiber.effectDuration = -0, returnFiber.passiveEffectDuration = -0, reconcileChildren(current, workInProgress, workInProgress.pendingProps.children, renderLanes), workInProgress.child;
+        case 10:
+          return returnFiber = workInProgress.type, prevSibling = workInProgress.pendingProps, nextProps = prevSibling.value, "value" in prevSibling || hasWarnedAboutUsingNoValuePropOnContextProvider || (hasWarnedAboutUsingNoValuePropOnContextProvider = !0, console.error("The `value` prop is required for the `<Context.Provider>`. Did you misspell it or forget to pass it?")), pushProvider(workInProgress, returnFiber, nextProps), reconcileChildren(current, workInProgress, prevSibling.children, renderLanes), workInProgress.child;
+        case 9:
+          return prevSibling = workInProgress.type._context, returnFiber = workInProgress.pendingProps.children, "function" !== typeof returnFiber && console.error("A context consumer was rendered with multiple children, or a child that isn't a function. A context consumer expects a single child that is a function. If you did pass a function, make sure there is no trailing or leading whitespace around it."), prepareToReadContext(workInProgress), prevSibling = _readContext(prevSibling), markComponentRenderStarted(workInProgress), returnFiber = callComponentInDEV(returnFiber, prevSibling, void 0), markComponentRenderStopped(), workInProgress.flags |= 1, reconcileChildren(current, workInProgress, returnFiber, renderLanes), workInProgress.child;
+        case 14:
+          return updateMemoComponent(current, workInProgress, workInProgress.type, workInProgress.pendingProps, renderLanes);
+        case 15:
+          return updateSimpleMemoComponent(current, workInProgress, workInProgress.type, workInProgress.pendingProps, renderLanes);
+        case 17:
+          return returnFiber = workInProgress.type, prevSibling = resolveClassComponentProps(returnFiber, workInProgress.pendingProps), resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress), workInProgress.tag = 1, prepareToReadContext(workInProgress), constructClassInstance(workInProgress, returnFiber, prevSibling), mountClassInstance(workInProgress, returnFiber, prevSibling, renderLanes), finishClassComponent(null, workInProgress, returnFiber, !0, !1, renderLanes);
+        case 28:
+          return returnFiber = workInProgress.type, prevSibling = resolveClassComponentProps(returnFiber, workInProgress.pendingProps), resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress), workInProgress.tag = 0, updateFunctionComponent(null, workInProgress, returnFiber, prevSibling, renderLanes);
+        case 19:
+          return updateSuspenseListComponent(current, workInProgress, renderLanes);
+        case 31:
+          return returnFiber = workInProgress.pendingProps, renderLanes = workInProgress.mode, returnFiber = {
+            mode: returnFiber.mode,
+            children: returnFiber.children
+          }, null === current ? (current = mountWorkInProgressOffscreenFiber(returnFiber, renderLanes), current.ref = workInProgress.ref, workInProgress.child = current, current.return = workInProgress, workInProgress = current) : (current = createWorkInProgress(current.child, returnFiber), current.ref = workInProgress.ref, workInProgress.child = current, current.return = workInProgress, workInProgress = current), workInProgress;
+        case 22:
+          return updateOffscreenComponent(current, workInProgress, renderLanes);
+        case 24:
+          return prepareToReadContext(workInProgress), returnFiber = _readContext(CacheContext), null === current ? (prevSibling = peekCacheFromPool(), null === prevSibling && (prevSibling = workInProgressRoot, nextProps = createCache(), prevSibling.pooledCache = nextProps, retainCache(nextProps), null !== nextProps && (prevSibling.pooledCacheLanes |= renderLanes), prevSibling = nextProps), workInProgress.memoizedState = {
+            parent: returnFiber,
+            cache: prevSibling
+          }, initializeUpdateQueue(workInProgress), pushProvider(workInProgress, CacheContext, prevSibling)) : (0 !== (current.lanes & renderLanes) && (cloneUpdateQueue(current, workInProgress), processUpdateQueue(workInProgress, null, null, renderLanes), suspendIfUpdateReadFromEntangledAsyncAction()), prevSibling = current.memoizedState, nextProps = workInProgress.memoizedState, prevSibling.parent !== returnFiber ? (prevSibling = {
+            parent: returnFiber,
+            cache: returnFiber
+          }, workInProgress.memoizedState = prevSibling, 0 === workInProgress.lanes && (workInProgress.memoizedState = workInProgress.updateQueue.baseState = prevSibling), pushProvider(workInProgress, CacheContext, returnFiber)) : (returnFiber = nextProps.cache, pushProvider(workInProgress, CacheContext, returnFiber), returnFiber !== prevSibling.cache && propagateContextChanges(workInProgress, [CacheContext], renderLanes, !0))), reconcileChildren(current, workInProgress, workInProgress.pendingProps.children, renderLanes), workInProgress.child;
+        case 29:
+          throw workInProgress.pendingProps;
+      }
+      throw Error("Unknown unit of work tag (" + workInProgress.tag + "). This error is likely caused by a bug in React. Please file an issue.");
+    }
+    function scheduleRetryEffect(workInProgress, retryQueue) {
+      null !== retryQueue && (workInProgress.flags |= 4);
+      workInProgress.flags & 16384 && (retryQueue = 22 !== workInProgress.tag ? claimNextRetryLane() : 536870912, workInProgress.lanes |= retryQueue, workInProgressSuspendedRetryLanes |= retryQueue);
+    }
+    function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
+      switch (renderState.tailMode) {
+        case "hidden":
+          hasRenderedATailFallback = renderState.tail;
+          for (var lastTailNode = null; null !== hasRenderedATailFallback;) null !== hasRenderedATailFallback.alternate && (lastTailNode = hasRenderedATailFallback), hasRenderedATailFallback = hasRenderedATailFallback.sibling;
+          null === lastTailNode ? renderState.tail = null : lastTailNode.sibling = null;
+          break;
+        case "collapsed":
+          lastTailNode = renderState.tail;
+          for (var _lastTailNode = null; null !== lastTailNode;) null !== lastTailNode.alternate && (_lastTailNode = lastTailNode), lastTailNode = lastTailNode.sibling;
+          null === _lastTailNode ? hasRenderedATailFallback || null === renderState.tail ? renderState.tail = null : renderState.tail.sibling = null : _lastTailNode.sibling = null;
+      }
+    }
+    function bubbleProperties(completedWork) {
+      var didBailout = null !== completedWork.alternate && completedWork.alternate.child === completedWork.child,
+        newChildLanes = 0,
+        subtreeFlags = 0;
+      if (didBailout) {
+        if (0 !== (completedWork.mode & 2)) {
+          for (var _treeBaseDuration = completedWork.selfBaseDuration, _child2 = completedWork.child; null !== _child2;) newChildLanes |= _child2.lanes | _child2.childLanes, subtreeFlags |= _child2.subtreeFlags & 65011712, subtreeFlags |= _child2.flags & 65011712, _treeBaseDuration += _child2.treeBaseDuration, _child2 = _child2.sibling;
+          completedWork.treeBaseDuration = _treeBaseDuration;
+        } else for (_treeBaseDuration = completedWork.child; null !== _treeBaseDuration;) newChildLanes |= _treeBaseDuration.lanes | _treeBaseDuration.childLanes, subtreeFlags |= _treeBaseDuration.subtreeFlags & 65011712, subtreeFlags |= _treeBaseDuration.flags & 65011712, _treeBaseDuration.return = completedWork, _treeBaseDuration = _treeBaseDuration.sibling;
+      } else if (0 !== (completedWork.mode & 2)) {
+        _treeBaseDuration = completedWork.actualDuration;
+        _child2 = completedWork.selfBaseDuration;
+        for (var child = completedWork.child; null !== child;) newChildLanes |= child.lanes | child.childLanes, subtreeFlags |= child.subtreeFlags, subtreeFlags |= child.flags, _treeBaseDuration += child.actualDuration, _child2 += child.treeBaseDuration, child = child.sibling;
+        completedWork.actualDuration = _treeBaseDuration;
+        completedWork.treeBaseDuration = _child2;
+      } else for (_treeBaseDuration = completedWork.child; null !== _treeBaseDuration;) newChildLanes |= _treeBaseDuration.lanes | _treeBaseDuration.childLanes, subtreeFlags |= _treeBaseDuration.subtreeFlags, subtreeFlags |= _treeBaseDuration.flags, _treeBaseDuration.return = completedWork, _treeBaseDuration = _treeBaseDuration.sibling;
+      completedWork.subtreeFlags |= subtreeFlags;
+      completedWork.childLanes = newChildLanes;
+      return didBailout;
+    }
+    function completeWork(current, workInProgress, renderLanes) {
+      var newProps = workInProgress.pendingProps;
+      switch (workInProgress.tag) {
+        case 28:
+        case 31:
+        case 16:
+        case 15:
+        case 0:
+        case 11:
+        case 7:
+        case 8:
+        case 12:
+        case 9:
+        case 14:
+          return bubbleProperties(workInProgress), null;
+        case 1:
+          return bubbleProperties(workInProgress), null;
+        case 3:
+          return renderLanes = workInProgress.stateNode, newProps = null, null !== current && (newProps = current.memoizedState.cache), workInProgress.memoizedState.cache !== newProps && (workInProgress.flags |= 2048), popProvider(CacheContext, workInProgress), popHostContainer(workInProgress), renderLanes.pendingContext && (renderLanes.context = renderLanes.pendingContext, renderLanes.pendingContext = null), null !== current && null !== current.child || null === current || current.memoizedState.isDehydrated && 0 === (workInProgress.flags & 256) || (workInProgress.flags |= 1024, upgradeHydrationErrorsToRecoverable()), bubbleProperties(workInProgress), null;
+        case 26:
+        case 27:
+        case 5:
+          popHostContext(workInProgress);
+          var _type2 = workInProgress.type;
+          if (null !== current && null != workInProgress.stateNode) current.memoizedProps !== newProps && (workInProgress.flags |= 4);else {
+            if (!newProps) {
+              if (null === workInProgress.stateNode) throw Error("We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue.");
+              bubbleProperties(workInProgress);
+              return null;
+            }
+            requiredContext(contextStackCursor.current);
+            renderLanes = requiredContext(rootInstanceStackCursor.current);
+            current = allocateTag();
+            _type2 = getViewConfigForType(_type2);
+            for (var key in _type2.validAttributes) newProps.hasOwnProperty(key) && ReactNativePrivateInterface.deepFreezeAndThrowOnMutationInDev(newProps[key]);
+            key = diffProperties(null, emptyObject$1, newProps, _type2.validAttributes);
+            ReactNativePrivateInterface.UIManager.createView(current, _type2.uiViewClassName, renderLanes.containerTag, key);
+            renderLanes = new ReactNativeFiberHostComponent(current, _type2, workInProgress);
+            instanceCache.set(current, workInProgress);
+            instanceProps.set(current, newProps);
+            a: for (current = workInProgress.child; null !== current;) {
+              if (5 === current.tag || 6 === current.tag) renderLanes._children.push(current.stateNode);else if (4 !== current.tag && null !== current.child) {
+                current.child.return = current;
+                current = current.child;
+                continue;
+              }
+              if (current === workInProgress) break a;
+              for (; null === current.sibling;) {
+                if (null === current.return || current.return === workInProgress) break a;
+                current = current.return;
+              }
+              current.sibling.return = current.return;
+              current = current.sibling;
+            }
+            workInProgress.stateNode = renderLanes;
+            finalizeInitialChildren(renderLanes) && (workInProgress.flags |= 4);
+          }
+          bubbleProperties(workInProgress);
+          workInProgress.flags &= -16777217;
+          return null;
+        case 6:
+          if (current && null != workInProgress.stateNode) current.memoizedProps !== newProps && (workInProgress.flags |= 4);else {
+            if ("string" !== typeof newProps && null === workInProgress.stateNode) throw Error("We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue.");
+            current = requiredContext(rootInstanceStackCursor.current);
+            if (!requiredContext(contextStackCursor.current).isInAParentText) throw Error("Text strings must be rendered within a <Text> component.");
+            renderLanes = allocateTag();
+            ReactNativePrivateInterface.UIManager.createView(renderLanes, "RCTRawText", current.containerTag, {
+              text: newProps
+            });
+            instanceCache.set(renderLanes, workInProgress);
+            workInProgress.stateNode = renderLanes;
+          }
+          bubbleProperties(workInProgress);
+          return null;
+        case 13:
+          newProps = workInProgress.memoizedState;
+          if (null === current || null !== current.memoizedState && null !== current.memoizedState.dehydrated) {
+            if (null !== newProps && null !== newProps.dehydrated) {
+              if (null === current) {
+                throw Error("A dehydrated suspense component was completed without a hydrated node. This is probably a bug in React.");
+                throw Error("Expected prepareToHydrateHostSuspenseInstance() to never be called. This error is likely caused by a bug in React. Please file an issue.");
+              }
+              emitPendingHydrationWarnings();
+              0 === (workInProgress.flags & 128) && (workInProgress.memoizedState = null);
+              workInProgress.flags |= 4;
+              bubbleProperties(workInProgress);
+              0 !== (workInProgress.mode & 2) && null !== newProps && (key = workInProgress.child, null !== key && (workInProgress.treeBaseDuration -= key.treeBaseDuration));
+              key = !1;
+            } else key = upgradeHydrationErrorsToRecoverable(), null !== current && null !== current.memoizedState && (current.memoizedState.hydrationErrors = key), key = !0;
+            if (!key) {
+              if (workInProgress.flags & 256) return popSuspenseHandler(workInProgress), workInProgress;
+              popSuspenseHandler(workInProgress);
+              return null;
+            }
+          }
+          popSuspenseHandler(workInProgress);
+          if (0 !== (workInProgress.flags & 128)) return workInProgress.lanes = renderLanes, 0 !== (workInProgress.mode & 2) && transferActualDuration(workInProgress), workInProgress;
+          renderLanes = null !== newProps;
+          current = null !== current && null !== current.memoizedState;
+          renderLanes && (newProps = workInProgress.child, key = null, null !== newProps.alternate && null !== newProps.alternate.memoizedState && null !== newProps.alternate.memoizedState.cachePool && (key = newProps.alternate.memoizedState.cachePool.pool), _type2 = null, null !== newProps.memoizedState && null !== newProps.memoizedState.cachePool && (_type2 = newProps.memoizedState.cachePool.pool), _type2 !== key && (newProps.flags |= 2048));
+          renderLanes !== current && renderLanes && (workInProgress.child.flags |= 8192);
+          scheduleRetryEffect(workInProgress, workInProgress.updateQueue);
+          bubbleProperties(workInProgress);
+          0 !== (workInProgress.mode & 2) && renderLanes && (current = workInProgress.child, null !== current && (workInProgress.treeBaseDuration -= current.treeBaseDuration));
+          return null;
+        case 4:
+          return popHostContainer(workInProgress), bubbleProperties(workInProgress), null;
+        case 10:
+          return popProvider(workInProgress.type, workInProgress), bubbleProperties(workInProgress), null;
+        case 17:
+          return bubbleProperties(workInProgress), null;
+        case 19:
+          pop(suspenseStackCursor, workInProgress);
+          key = workInProgress.memoizedState;
+          if (null === key) return bubbleProperties(workInProgress), null;
+          newProps = 0 !== (workInProgress.flags & 128);
+          _type2 = key.rendering;
+          if (null === _type2) {
+            if (newProps) cutOffTailIfNeeded(key, !1);else {
+              if (workInProgressRootExitStatus !== RootInProgress || null !== current && 0 !== (current.flags & 128)) for (current = workInProgress.child; null !== current;) {
+                _type2 = findFirstSuspended(current);
+                if (null !== _type2) {
+                  workInProgress.flags |= 128;
+                  cutOffTailIfNeeded(key, !1);
+                  current = _type2.updateQueue;
+                  workInProgress.updateQueue = current;
+                  scheduleRetryEffect(workInProgress, current);
+                  workInProgress.subtreeFlags = 0;
+                  current = renderLanes;
+                  for (renderLanes = workInProgress.child; null !== renderLanes;) resetWorkInProgress(renderLanes, current), renderLanes = renderLanes.sibling;
+                  push(suspenseStackCursor, suspenseStackCursor.current & SubtreeSuspenseContextMask | ForceSuspenseFallback, workInProgress);
+                  return workInProgress.child;
+                }
+                current = current.sibling;
+              }
+              null !== key.tail && now$1() > workInProgressRootRenderTargetTime && (workInProgress.flags |= 128, newProps = !0, cutOffTailIfNeeded(key, !1), workInProgress.lanes = 4194304);
+            }
+          } else {
+            if (!newProps) if (current = findFirstSuspended(_type2), null !== current) {
+              if (workInProgress.flags |= 128, newProps = !0, current = current.updateQueue, workInProgress.updateQueue = current, scheduleRetryEffect(workInProgress, current), cutOffTailIfNeeded(key, !0), null === key.tail && "hidden" === key.tailMode && !_type2.alternate) return bubbleProperties(workInProgress), null;
+            } else 2 * now$1() - key.renderingStartTime > workInProgressRootRenderTargetTime && 536870912 !== renderLanes && (workInProgress.flags |= 128, newProps = !0, cutOffTailIfNeeded(key, !1), workInProgress.lanes = 4194304);
+            key.isBackwards ? (_type2.sibling = workInProgress.child, workInProgress.child = _type2) : (current = key.last, null !== current ? current.sibling = _type2 : workInProgress.child = _type2, key.last = _type2);
+          }
+          if (null !== key.tail) return current = key.tail, key.rendering = current, key.tail = current.sibling, key.renderingStartTime = now$1(), current.sibling = null, renderLanes = suspenseStackCursor.current, renderLanes = newProps ? renderLanes & SubtreeSuspenseContextMask | ForceSuspenseFallback : renderLanes & SubtreeSuspenseContextMask, push(suspenseStackCursor, renderLanes, workInProgress), current;
+          bubbleProperties(workInProgress);
+          return null;
+        case 22:
+        case 23:
+          return popSuspenseHandler(workInProgress), popHiddenContext(workInProgress), newProps = null !== workInProgress.memoizedState, null !== current ? null !== current.memoizedState !== newProps && (workInProgress.flags |= 8192) : newProps && (workInProgress.flags |= 8192), newProps && 0 !== (workInProgress.mode & 1) ? 0 !== (renderLanes & 536870912) && 0 === (workInProgress.flags & 128) && (bubbleProperties(workInProgress), workInProgress.subtreeFlags & 6 && (workInProgress.flags |= 8192)) : bubbleProperties(workInProgress), renderLanes = workInProgress.updateQueue, null !== renderLanes && scheduleRetryEffect(workInProgress, renderLanes.retryQueue), renderLanes = null, null !== current && null !== current.memoizedState && null !== current.memoizedState.cachePool && (renderLanes = current.memoizedState.cachePool.pool), newProps = null, null !== workInProgress.memoizedState && null !== workInProgress.memoizedState.cachePool && (newProps = workInProgress.memoizedState.cachePool.pool), newProps !== renderLanes && (workInProgress.flags |= 2048), null !== current && pop(resumedCache, workInProgress), null;
+        case 24:
+          return renderLanes = null, null !== current && (renderLanes = current.memoizedState.cache), workInProgress.memoizedState.cache !== renderLanes && (workInProgress.flags |= 2048), popProvider(CacheContext, workInProgress), bubbleProperties(workInProgress), null;
+        case 25:
+          return null;
+        case 30:
+          return null;
+        case 29:
+          return null;
+      }
+      throw Error("Unknown unit of work tag (" + workInProgress.tag + "). This error is likely caused by a bug in React. Please file an issue.");
+    }
+    function unwindWork(current, workInProgress) {
+      switch (workInProgress.tag) {
+        case 1:
+          return current = workInProgress.flags, current & 65536 ? (workInProgress.flags = current & -65537 | 128, 0 !== (workInProgress.mode & 2) && transferActualDuration(workInProgress), workInProgress) : null;
+        case 3:
+          return popProvider(CacheContext, workInProgress), popHostContainer(workInProgress), current = workInProgress.flags, 0 !== (current & 65536) && 0 === (current & 128) ? (workInProgress.flags = current & -65537 | 128, workInProgress) : null;
+        case 26:
+        case 27:
+        case 5:
+          return popHostContext(workInProgress), null;
+        case 13:
+          popSuspenseHandler(workInProgress);
+          current = workInProgress.memoizedState;
+          if (null !== current && null !== current.dehydrated && null === workInProgress.alternate) throw Error("Threw in newly mounted dehydrated component. This is likely a bug in React. Please file an issue.");
+          current = workInProgress.flags;
+          return current & 65536 ? (workInProgress.flags = current & -65537 | 128, 0 !== (workInProgress.mode & 2) && transferActualDuration(workInProgress), workInProgress) : null;
+        case 19:
+          return pop(suspenseStackCursor, workInProgress), null;
+        case 4:
+          return popHostContainer(workInProgress), null;
+        case 10:
+          return popProvider(workInProgress.type, workInProgress), null;
+        case 22:
+        case 23:
+          return popSuspenseHandler(workInProgress), popHiddenContext(workInProgress), null !== current && pop(resumedCache, workInProgress), current = workInProgress.flags, current & 65536 ? (workInProgress.flags = current & -65537 | 128, 0 !== (workInProgress.mode & 2) && transferActualDuration(workInProgress), workInProgress) : null;
+        case 24:
+          return popProvider(CacheContext, workInProgress), null;
+        case 25:
+          return null;
+        default:
+          return null;
+      }
+    }
+    function unwindInterruptedWork(current, interruptedWork) {
+      switch (interruptedWork.tag) {
+        case 3:
+          popProvider(CacheContext, interruptedWork);
+          popHostContainer(interruptedWork);
+          break;
+        case 26:
+        case 27:
+        case 5:
+          popHostContext(interruptedWork);
+          break;
+        case 4:
+          popHostContainer(interruptedWork);
+          break;
+        case 13:
+          popSuspenseHandler(interruptedWork);
+          break;
+        case 19:
+          pop(suspenseStackCursor, interruptedWork);
+          break;
+        case 10:
+          popProvider(interruptedWork.type, interruptedWork);
+          break;
+        case 22:
+        case 23:
+          popSuspenseHandler(interruptedWork);
+          popHiddenContext(interruptedWork);
+          null !== current && pop(resumedCache, interruptedWork);
+          break;
+        case 24:
+          popProvider(CacheContext, interruptedWork);
+      }
+    }
+    function shouldProfile(current) {
+      return 0 !== (current.mode & 2);
+    }
+    function commitHookLayoutEffects(finishedWork, hookFlags) {
+      shouldProfile(finishedWork) ? (startEffectTimer(), commitHookEffectListMount(hookFlags, finishedWork), recordEffectDuration()) : commitHookEffectListMount(hookFlags, finishedWork);
+    }
+    function commitHookLayoutUnmountEffects(finishedWork, nearestMountedAncestor, hookFlags) {
+      shouldProfile(finishedWork) ? (startEffectTimer(), commitHookEffectListUnmount(hookFlags, finishedWork, nearestMountedAncestor), recordEffectDuration()) : commitHookEffectListUnmount(hookFlags, finishedWork, nearestMountedAncestor);
+    }
+    function commitHookEffectListMount(flags, finishedWork) {
+      try {
+        var updateQueue = finishedWork.updateQueue,
+          lastEffect = null !== updateQueue ? updateQueue.lastEffect : null;
+        if (null !== lastEffect) {
+          var firstEffect = lastEffect.next;
+          updateQueue = firstEffect;
+          do {
+            if ((updateQueue.tag & flags) === flags && ((flags & Passive) !== NoFlags ? null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markComponentPassiveEffectMountStarted && injectedProfilingHooks.markComponentPassiveEffectMountStarted(finishedWork) : (flags & Layout) !== NoFlags && null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markComponentLayoutEffectMountStarted && injectedProfilingHooks.markComponentLayoutEffectMountStarted(finishedWork), lastEffect = void 0, (flags & Insertion) !== NoFlags && (isRunningInsertionEffect = !0), lastEffect = runWithFiberInDEV(finishedWork, callCreateInDEV, updateQueue), (flags & Insertion) !== NoFlags && (isRunningInsertionEffect = !1), (flags & Passive) !== NoFlags ? null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markComponentPassiveEffectMountStopped && injectedProfilingHooks.markComponentPassiveEffectMountStopped() : (flags & Layout) !== NoFlags && null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markComponentLayoutEffectMountStopped && injectedProfilingHooks.markComponentLayoutEffectMountStopped(), void 0 !== lastEffect && "function" !== typeof lastEffect)) {
+              var hookName = void 0;
+              hookName = 0 !== (updateQueue.tag & Layout) ? "useLayoutEffect" : 0 !== (updateQueue.tag & Insertion) ? "useInsertionEffect" : "useEffect";
+              var addendum = void 0;
+              addendum = null === lastEffect ? " You returned null. If your effect does not require clean up, return undefined (or nothing)." : "function" === typeof lastEffect.then ? "\n\nIt looks like you wrote " + hookName + "(async () => ...) or returned a Promise. Instead, write the async function inside your effect and call it immediately:\n\n" + hookName + "(() => {\n  async function fetchData() {\n    // You can await here\n    const response = await MyAPI.getData(someId);\n    // ...\n  }\n  fetchData();\n}, [someId]); // Or [] if effect doesn't need props or state\n\nLearn more about data fetching with Hooks: https://react.dev/link/hooks-data-fetching" : " You returned: " + lastEffect;
+              runWithFiberInDEV(finishedWork, function (n, a) {
+                console.error("%s must not return anything besides a function, which is used for clean-up.%s", n, a);
+              }, hookName, addendum);
+            }
+            updateQueue = updateQueue.next;
+          } while (updateQueue !== firstEffect);
+        }
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+    }
+    function commitHookEffectListUnmount(flags, finishedWork, nearestMountedAncestor) {
+      try {
+        var updateQueue = finishedWork.updateQueue,
+          lastEffect = null !== updateQueue ? updateQueue.lastEffect : null;
+        if (null !== lastEffect) {
+          var firstEffect = lastEffect.next;
+          updateQueue = firstEffect;
+          do {
+            if ((updateQueue.tag & flags) === flags) {
+              var inst = updateQueue.inst,
+                destroy = inst.destroy;
+              void 0 !== destroy && (inst.destroy = void 0, (flags & Passive) !== NoFlags ? null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markComponentPassiveEffectUnmountStarted && injectedProfilingHooks.markComponentPassiveEffectUnmountStarted(finishedWork) : (flags & Layout) !== NoFlags && null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStarted && injectedProfilingHooks.markComponentLayoutEffectUnmountStarted(finishedWork), (flags & Insertion) !== NoFlags && (isRunningInsertionEffect = !0), lastEffect = finishedWork, runWithFiberInDEV(lastEffect, callDestroyInDEV, lastEffect, nearestMountedAncestor, destroy), (flags & Insertion) !== NoFlags && (isRunningInsertionEffect = !1), (flags & Passive) !== NoFlags ? null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markComponentPassiveEffectUnmountStopped && injectedProfilingHooks.markComponentPassiveEffectUnmountStopped() : (flags & Layout) !== NoFlags && null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markComponentLayoutEffectUnmountStopped && injectedProfilingHooks.markComponentLayoutEffectUnmountStopped());
+            }
+            updateQueue = updateQueue.next;
+          } while (updateQueue !== firstEffect);
+        }
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+    }
+    function commitHookPassiveMountEffects(finishedWork, hookFlags) {
+      shouldProfile(finishedWork) ? (startEffectTimer(), commitHookEffectListMount(hookFlags, finishedWork), recordEffectDuration()) : commitHookEffectListMount(hookFlags, finishedWork);
+    }
+    function commitHookPassiveUnmountEffects(finishedWork, nearestMountedAncestor, hookFlags) {
+      shouldProfile(finishedWork) ? (startEffectTimer(), commitHookEffectListUnmount(hookFlags, finishedWork, nearestMountedAncestor), recordEffectDuration()) : commitHookEffectListUnmount(hookFlags, finishedWork, nearestMountedAncestor);
+    }
+    function commitClassDidMount(finishedWork) {
+      var instance = finishedWork.stateNode;
+      "function" === typeof instance.componentDidMount && runWithFiberInDEV(finishedWork, callComponentDidMountInDEV, finishedWork, instance);
+    }
+    function commitClassCallbacks(finishedWork) {
+      var updateQueue = finishedWork.updateQueue;
+      if (null !== updateQueue) {
+        var instance = finishedWork.stateNode;
+        finishedWork.type.defaultProps || "ref" in finishedWork.memoizedProps || didWarnAboutReassigningProps || (instance.props !== finishedWork.memoizedProps && console.error("Expected %s props to match memoized props before processing the update queue. This might either be because of a bug in React, or because a component reassigns its own `this.props`. Please file an issue.", getComponentNameFromFiber(finishedWork) || "instance"), instance.state !== finishedWork.memoizedState && console.error("Expected %s state to match memoized state before processing the update queue. This might either be because of a bug in React, or because a component reassigns its own `this.state`. Please file an issue.", getComponentNameFromFiber(finishedWork) || "instance"));
+        try {
+          runWithFiberInDEV(finishedWork, commitCallbacks, updateQueue, instance);
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        }
+      }
+    }
+    function callGetSnapshotBeforeUpdates(instance, prevProps, prevState) {
+      return instance.getSnapshotBeforeUpdate(prevProps, prevState);
+    }
+    function commitClassSnapshot(finishedWork, current) {
+      var prevProps = current.memoizedProps,
+        prevState = current.memoizedState;
+      current = finishedWork.stateNode;
+      finishedWork.type.defaultProps || "ref" in finishedWork.memoizedProps || didWarnAboutReassigningProps || (current.props !== finishedWork.memoizedProps && console.error("Expected %s props to match memoized props before getSnapshotBeforeUpdate. This might either be because of a bug in React, or because a component reassigns its own `this.props`. Please file an issue.", getComponentNameFromFiber(finishedWork) || "instance"), current.state !== finishedWork.memoizedState && console.error("Expected %s state to match memoized state before getSnapshotBeforeUpdate. This might either be because of a bug in React, or because a component reassigns its own `this.state`. Please file an issue.", getComponentNameFromFiber(finishedWork) || "instance"));
+      try {
+        var resolvedPrevProps = resolveClassComponentProps(finishedWork.type, prevProps, finishedWork.elementType === finishedWork.type);
+        var snapshot = runWithFiberInDEV(finishedWork, callGetSnapshotBeforeUpdates, current, resolvedPrevProps, prevState);
+        prevProps = didWarnAboutUndefinedSnapshotBeforeUpdate;
+        void 0 !== snapshot || prevProps.has(finishedWork.type) || (prevProps.add(finishedWork.type), runWithFiberInDEV(finishedWork, function () {
+          console.error("%s.getSnapshotBeforeUpdate(): A snapshot value (or null) must be returned. You have returned undefined.", getComponentNameFromFiber(finishedWork));
+        }));
+        current.__reactInternalSnapshotBeforeUpdate = snapshot;
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+    }
+    function safelyCallComponentWillUnmount(current, nearestMountedAncestor, instance) {
+      instance.props = resolveClassComponentProps(current.type, current.memoizedProps);
+      instance.state = current.memoizedState;
+      shouldProfile(current) ? (startEffectTimer(), runWithFiberInDEV(current, callComponentWillUnmountInDEV, current, nearestMountedAncestor, instance), recordEffectDuration()) : runWithFiberInDEV(current, callComponentWillUnmountInDEV, current, nearestMountedAncestor, instance);
+    }
+    function commitAttachRef(finishedWork) {
+      var ref = finishedWork.ref;
+      if (null !== ref) {
+        switch (finishedWork.tag) {
+          case 26:
+          case 27:
+          case 5:
+            var instanceToUse = getPublicInstance(finishedWork.stateNode);
+            break;
+          case 30:
+            instanceToUse = finishedWork.stateNode;
+            break;
+          default:
+            instanceToUse = finishedWork.stateNode;
+        }
+        if ("function" === typeof ref) {
+          if (shouldProfile(finishedWork)) try {
+            startEffectTimer(), finishedWork.refCleanup = ref(instanceToUse);
+          } finally {
+            recordEffectDuration();
+          } else finishedWork.refCleanup = ref(instanceToUse);
+        } else "string" === typeof ref ? console.error("String refs are no longer supported.") : ref.hasOwnProperty("current") || console.error("Unexpected ref object provided for %s. Use either a ref-setter function or React.createRef().", getComponentNameFromFiber(finishedWork)), ref.current = instanceToUse;
+      }
+    }
+    function safelyAttachRef(current, nearestMountedAncestor) {
+      try {
+        runWithFiberInDEV(current, commitAttachRef, current);
+      } catch (error) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error);
+      }
+    }
+    function safelyDetachRef(current, nearestMountedAncestor) {
+      var ref = current.ref,
+        refCleanup = current.refCleanup;
+      if (null !== ref) if ("function" === typeof refCleanup) try {
+        if (shouldProfile(current)) try {
+          startEffectTimer(), runWithFiberInDEV(current, refCleanup);
+        } finally {
+          recordEffectDuration(current);
+        } else runWithFiberInDEV(current, refCleanup);
+      } catch (error) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error);
+      } finally {
+        current.refCleanup = null, current = current.alternate, null != current && (current.refCleanup = null);
+      } else if ("function" === typeof ref) try {
+        if (shouldProfile(current)) try {
+          startEffectTimer(), runWithFiberInDEV(current, ref, null);
+        } finally {
+          recordEffectDuration(current);
+        } else runWithFiberInDEV(current, ref, null);
+      } catch (error$3) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error$3);
+      } else ref.current = null;
+    }
+    function commitProfiler(finishedWork, current, commitStartTime, effectDuration) {
+      var _finishedWork$memoize = finishedWork.memoizedProps,
+        id = _finishedWork$memoize.id,
+        onCommit = _finishedWork$memoize.onCommit;
+      _finishedWork$memoize = _finishedWork$memoize.onRender;
+      current = null === current ? "mount" : "update";
+      currentUpdateIsNested && (current = "nested-update");
+      "function" === typeof _finishedWork$memoize && _finishedWork$memoize(id, current, finishedWork.actualDuration, finishedWork.treeBaseDuration, finishedWork.actualStartTime, commitStartTime);
+      "function" === typeof onCommit && onCommit(finishedWork.memoizedProps.id, current, effectDuration, commitStartTime);
+    }
+    function commitProfilerPostCommitImpl(finishedWork, current, commitStartTime, passiveEffectDuration) {
+      var _finishedWork$memoize2 = finishedWork.memoizedProps;
+      finishedWork = _finishedWork$memoize2.id;
+      _finishedWork$memoize2 = _finishedWork$memoize2.onPostCommit;
+      current = null === current ? "mount" : "update";
+      currentUpdateIsNested && (current = "nested-update");
+      "function" === typeof _finishedWork$memoize2 && _finishedWork$memoize2(finishedWork, current, passiveEffectDuration, commitStartTime);
+    }
+    function commitHostMount(finishedWork) {
+      var type = finishedWork.type,
+        props = finishedWork.memoizedProps,
+        instance = finishedWork.stateNode;
+      try {
+        runWithFiberInDEV(finishedWork, commitMount, instance, type, props, finishedWork);
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+    }
+    function isHostParent(fiber) {
+      return 5 === fiber.tag || 3 === fiber.tag || 4 === fiber.tag;
+    }
+    function getHostSibling(fiber) {
+      a: for (;;) {
+        for (; null === fiber.sibling;) {
+          if (null === fiber.return || isHostParent(fiber.return)) return null;
+          fiber = fiber.return;
+        }
+        fiber.sibling.return = fiber.return;
+        for (fiber = fiber.sibling; 5 !== fiber.tag && 6 !== fiber.tag && 18 !== fiber.tag;) {
+          if (fiber.flags & 2) continue a;
+          if (null === fiber.child || 4 === fiber.tag) continue a;else fiber.child.return = fiber, fiber = fiber.child;
+        }
+        if (!(fiber.flags & 2)) return fiber.stateNode;
+      }
+    }
+    function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
+      var tag = node.tag;
+      if (5 === tag || 6 === tag) {
+        if (node = node.stateNode, before) {
+          if ("number" === typeof parent) throw Error("Container does not support insertBefore operation");
+        } else ReactNativePrivateInterface.UIManager.setChildren(parent.containerTag, ["number" === typeof node ? node : node._nativeTag]);
+      } else if (4 !== tag && (node = node.child, null !== node)) for (insertOrAppendPlacementNodeIntoContainer(node, before, parent), node = node.sibling; null !== node;) insertOrAppendPlacementNodeIntoContainer(node, before, parent), node = node.sibling;
+    }
+    function insertOrAppendPlacementNode(node, before, parent) {
+      var tag = node.tag;
+      if (5 === tag || 6 === tag) {
+        if (node = node.stateNode, before) {
+          tag = parent._children;
+          var index = tag.indexOf(node);
+          0 <= index ? (tag.splice(index, 1), before = tag.indexOf(before), tag.splice(before, 0, node), ReactNativePrivateInterface.UIManager.manageChildren(parent._nativeTag, [index], [before], [], [], [])) : (before = tag.indexOf(before), tag.splice(before, 0, node), ReactNativePrivateInterface.UIManager.manageChildren(parent._nativeTag, [], [], ["number" === typeof node ? node : node._nativeTag], [before], []));
+        } else before = "number" === typeof node ? node : node._nativeTag, tag = parent._children, index = tag.indexOf(node), 0 <= index ? (tag.splice(index, 1), tag.push(node), ReactNativePrivateInterface.UIManager.manageChildren(parent._nativeTag, [index], [tag.length - 1], [], [], [])) : (tag.push(node), ReactNativePrivateInterface.UIManager.manageChildren(parent._nativeTag, [], [], [before], [tag.length - 1], []));
+      } else if (4 !== tag && (node = node.child, null !== node)) for (insertOrAppendPlacementNode(node, before, parent), node = node.sibling; null !== node;) insertOrAppendPlacementNode(node, before, parent), node = node.sibling;
+    }
+    function commitPlacement(finishedWork) {
+      for (var hostParentFiber, parentFiber = finishedWork.return; null !== parentFiber;) {
+        if (isHostParent(parentFiber)) {
+          hostParentFiber = parentFiber;
+          break;
+        }
+        parentFiber = parentFiber.return;
+      }
+      if (null == hostParentFiber) throw Error("Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue.");
+      switch (hostParentFiber.tag) {
+        case 27:
+        case 5:
+          parentFiber = hostParentFiber.stateNode;
+          hostParentFiber.flags & 32 && (hostParentFiber.flags &= -33);
+          hostParentFiber = getHostSibling(finishedWork);
+          insertOrAppendPlacementNode(finishedWork, hostParentFiber, parentFiber);
+          break;
+        case 3:
+        case 4:
+          hostParentFiber = hostParentFiber.stateNode.containerInfo;
+          parentFiber = getHostSibling(finishedWork);
+          insertOrAppendPlacementNodeIntoContainer(finishedWork, parentFiber, hostParentFiber);
+          break;
+        default:
+          throw Error("Invalid host parent fiber. This error is likely caused by a bug in React. Please file an issue.");
+      }
+    }
+    function commitBeforeMutationEffects(root, firstChild) {
+      for (nextEffect = firstChild; null !== nextEffect;) if (root = nextEffect, firstChild = root.child, 0 !== (root.subtreeFlags & 1024) && null !== firstChild) firstChild.return = root, nextEffect = firstChild;else for (; null !== nextEffect;) {
+        root = nextEffect;
+        firstChild = root.alternate;
+        var flags = root.flags;
+        switch (root.tag) {
+          case 0:
+            break;
+          case 11:
+          case 15:
+            break;
+          case 1:
+            0 !== (flags & 1024) && null !== firstChild && commitClassSnapshot(root, firstChild);
+            break;
+          case 3:
+            break;
+          case 5:
+          case 26:
+          case 27:
+          case 6:
+          case 4:
+          case 17:
+            break;
+          default:
+            if (0 !== (flags & 1024)) throw Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue.");
+        }
+        firstChild = root.sibling;
+        if (null !== firstChild) {
+          firstChild.return = root.return;
+          nextEffect = firstChild;
+          break;
+        }
+        nextEffect = root.return;
+      }
+    }
+    function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork) {
+      var flags = finishedWork.flags;
+      switch (finishedWork.tag) {
+        case 0:
+        case 11:
+        case 15:
+          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+          flags & 4 && commitHookLayoutEffects(finishedWork, Layout | HasEffect);
+          break;
+        case 1:
+          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+          if (flags & 4) if (finishedRoot = finishedWork.stateNode, null === current) finishedWork.type.defaultProps || "ref" in finishedWork.memoizedProps || didWarnAboutReassigningProps || (finishedRoot.props !== finishedWork.memoizedProps && console.error("Expected %s props to match memoized props before componentDidMount. This might either be because of a bug in React, or because a component reassigns its own `this.props`. Please file an issue.", getComponentNameFromFiber(finishedWork) || "instance"), finishedRoot.state !== finishedWork.memoizedState && console.error("Expected %s state to match memoized state before componentDidMount. This might either be because of a bug in React, or because a component reassigns its own `this.state`. Please file an issue.", getComponentNameFromFiber(finishedWork) || "instance")), shouldProfile(finishedWork) ? (startEffectTimer(), runWithFiberInDEV(finishedWork, callComponentDidMountInDEV, finishedWork, finishedRoot), recordEffectDuration()) : runWithFiberInDEV(finishedWork, callComponentDidMountInDEV, finishedWork, finishedRoot);else {
+            var prevProps = resolveClassComponentProps(finishedWork.type, current.memoizedProps);
+            current = current.memoizedState;
+            finishedWork.type.defaultProps || "ref" in finishedWork.memoizedProps || didWarnAboutReassigningProps || (finishedRoot.props !== finishedWork.memoizedProps && console.error("Expected %s props to match memoized props before componentDidUpdate. This might either be because of a bug in React, or because a component reassigns its own `this.props`. Please file an issue.", getComponentNameFromFiber(finishedWork) || "instance"), finishedRoot.state !== finishedWork.memoizedState && console.error("Expected %s state to match memoized state before componentDidUpdate. This might either be because of a bug in React, or because a component reassigns its own `this.state`. Please file an issue.", getComponentNameFromFiber(finishedWork) || "instance"));
+            shouldProfile(finishedWork) ? (startEffectTimer(), runWithFiberInDEV(finishedWork, callComponentDidUpdateInDEV, finishedWork, finishedRoot, prevProps, current, finishedRoot.__reactInternalSnapshotBeforeUpdate), recordEffectDuration()) : runWithFiberInDEV(finishedWork, callComponentDidUpdateInDEV, finishedWork, finishedRoot, prevProps, current, finishedRoot.__reactInternalSnapshotBeforeUpdate);
+          }
+          flags & 64 && commitClassCallbacks(finishedWork);
+          flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
+          break;
+        case 3:
+          current = pushNestedEffectDurations();
+          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+          if (flags & 64 && (flags = finishedWork.updateQueue, null !== flags)) {
+            prevProps = null;
+            if (null !== finishedWork.child) switch (finishedWork.child.tag) {
+              case 27:
+              case 5:
+                prevProps = getPublicInstance(finishedWork.child.stateNode);
+                break;
+              case 1:
+                prevProps = finishedWork.child.stateNode;
+            }
+            try {
+              runWithFiberInDEV(finishedWork, commitCallbacks, flags, prevProps);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+          finishedRoot.effectDuration += popNestedEffectDurations(current);
+          break;
+        case 27:
+        case 26:
+        case 5:
+          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+          null === current && flags & 4 && commitHostMount(finishedWork);
+          flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
+          break;
+        case 12:
+          if (flags & 4) {
+            flags = pushNestedEffectDurations();
+            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+            finishedRoot = finishedWork.stateNode;
+            finishedRoot.effectDuration += bubbleNestedEffectDurations(flags);
+            try {
+              runWithFiberInDEV(finishedWork, commitProfiler, finishedWork, current, commitStartTime, finishedRoot.effectDuration);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          } else recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+          break;
+        case 13:
+          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+          flags & 64 && (finishedRoot = finishedWork.memoizedState, null !== finishedRoot && null !== finishedRoot.dehydrated && (retryDehydratedSuspenseBoundary.bind(null, finishedWork), registerSuspenseInstanceRetry()));
+          break;
+        case 22:
+          if (0 !== (finishedWork.mode & 1)) {
+            if (flags = null !== finishedWork.memoizedState || offscreenSubtreeIsHidden, !flags) {
+              current = null !== current && null !== current.memoizedState || offscreenSubtreeWasHidden;
+              prevProps = offscreenSubtreeIsHidden;
+              var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+              offscreenSubtreeIsHidden = flags;
+              (offscreenSubtreeWasHidden = current) && !prevOffscreenSubtreeWasHidden ? recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, 0 !== (finishedWork.subtreeFlags & 8772)) : recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+              offscreenSubtreeIsHidden = prevProps;
+              offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+            }
+          } else recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+          break;
+        case 30:
+          break;
+        default:
+          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+      }
+    }
+    function detachFiberAfterEffects(fiber) {
+      var alternate = fiber.alternate;
+      null !== alternate && (fiber.alternate = null, detachFiberAfterEffects(alternate));
+      fiber.child = null;
+      fiber.deletions = null;
+      fiber.sibling = null;
+      fiber.stateNode = null;
+      fiber._debugOwner = null;
+      fiber.return = null;
+      fiber.dependencies = null;
+      fiber.memoizedProps = null;
+      fiber.memoizedState = null;
+      fiber.pendingProps = null;
+      fiber.stateNode = null;
+      fiber.updateQueue = null;
+    }
+    function recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, parent) {
+      for (parent = parent.child; null !== parent;) commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, parent), parent = parent.sibling;
+    }
+    function commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, deletedFiber) {
+      if (injectedHook && "function" === typeof injectedHook.onCommitFiberUnmount) try {
+        injectedHook.onCommitFiberUnmount(rendererID, deletedFiber);
+      } catch (err) {
+        hasLoggedError || (hasLoggedError = !0, console.error("React instrumentation encountered an error: %s", err));
+      }
+      switch (deletedFiber.tag) {
+        case 26:
+        case 27:
+        case 5:
+          offscreenSubtreeWasHidden || safelyDetachRef(deletedFiber, nearestMountedAncestor);
+        case 6:
+          var _prevHostParent = hostParent,
+            _prevHostParentIsContainer = hostParentIsContainer;
+          hostParent = null;
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          hostParent = _prevHostParent;
+          hostParentIsContainer = _prevHostParentIsContainer;
+          if (null !== hostParent) if (hostParentIsContainer) try {
+            runWithFiberInDEV(deletedFiber, removeChildFromContainer, hostParent, deletedFiber.stateNode);
+          } catch (error) {
+            captureCommitPhaseError(deletedFiber, nearestMountedAncestor, error);
+          } else try {
+            runWithFiberInDEV(deletedFiber, removeChild, hostParent, deletedFiber.stateNode);
+          } catch (error) {
+            captureCommitPhaseError(deletedFiber, nearestMountedAncestor, error);
+          }
+          break;
+        case 18:
+          null !== hostParent && (hostParentIsContainer ? clearSuspenseBoundaryFromContainer() : clearSuspenseBoundary());
+          break;
+        case 4:
+          _prevHostParent = hostParent;
+          _prevHostParentIsContainer = hostParentIsContainer;
+          hostParent = deletedFiber.stateNode.containerInfo;
+          hostParentIsContainer = !0;
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          hostParent = _prevHostParent;
+          hostParentIsContainer = _prevHostParentIsContainer;
+          break;
+        case 0:
+        case 11:
+        case 14:
+        case 15:
+          offscreenSubtreeWasHidden || commitHookEffectListUnmount(Insertion, deletedFiber, nearestMountedAncestor);
+          offscreenSubtreeWasHidden || commitHookLayoutUnmountEffects(deletedFiber, nearestMountedAncestor, Layout);
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          break;
+        case 1:
+          offscreenSubtreeWasHidden || (safelyDetachRef(deletedFiber, nearestMountedAncestor), _prevHostParent = deletedFiber.stateNode, "function" === typeof _prevHostParent.componentWillUnmount && safelyCallComponentWillUnmount(deletedFiber, nearestMountedAncestor, _prevHostParent));
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          break;
+        case 21:
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          break;
+        case 22:
+          deletedFiber.mode & 1 ? (offscreenSubtreeWasHidden = (_prevHostParent = offscreenSubtreeWasHidden) || null !== deletedFiber.memoizedState, recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber), offscreenSubtreeWasHidden = _prevHostParent) : recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          break;
+        default:
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+      }
+    }
+    function getRetryCache(finishedWork) {
+      switch (finishedWork.tag) {
+        case 13:
+        case 19:
+          var retryCache = finishedWork.stateNode;
+          null === retryCache && (retryCache = finishedWork.stateNode = new PossiblyWeakSet());
+          return retryCache;
+        case 22:
+          return finishedWork = finishedWork.stateNode, retryCache = finishedWork._retryCache, null === retryCache && (retryCache = finishedWork._retryCache = new PossiblyWeakSet()), retryCache;
+        default:
+          throw Error("Unexpected Suspense handler tag (" + finishedWork.tag + "). This is a bug in React.");
+      }
+    }
+    function attachSuspenseRetryListeners(finishedWork, wakeables) {
+      var retryCache = getRetryCache(finishedWork);
+      wakeables.forEach(function (wakeable) {
+        var retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
+        if (!retryCache.has(wakeable)) {
+          retryCache.add(wakeable);
+          if (isDevToolsPresent) if (null !== inProgressLanes && null !== inProgressRoot) restorePendingUpdaters(inProgressRoot, inProgressLanes);else throw Error("Expected finished root and lanes to be set. This is a bug in React.");
+          wakeable.then(retry, retry);
+        }
+      });
+    }
+    function recursivelyTraverseMutationEffects(root$jscomp$0, parentFiber) {
+      var deletions = parentFiber.deletions;
+      if (null !== deletions) for (var i = 0; i < deletions.length; i++) {
+        var root = root$jscomp$0,
+          returnFiber = parentFiber,
+          deletedFiber = deletions[i],
+          parent = returnFiber;
+        a: for (; null !== parent;) {
+          switch (parent.tag) {
+            case 27:
+            case 5:
+              hostParent = parent.stateNode;
+              hostParentIsContainer = !1;
+              break a;
+            case 3:
+            case 4:
+              hostParent = parent.stateNode.containerInfo;
+              hostParentIsContainer = !0;
+              break a;
+          }
+          parent = parent.return;
+        }
+        if (null === hostParent) throw Error("Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue.");
+        commitDeletionEffectsOnFiber(root, returnFiber, deletedFiber);
+        hostParent = null;
+        hostParentIsContainer = !1;
+        root = deletedFiber;
+        returnFiber = root.alternate;
+        null !== returnFiber && (returnFiber.return = null);
+        root.return = null;
+      }
+      if (parentFiber.subtreeFlags & 13878) for (parentFiber = parentFiber.child; null !== parentFiber;) commitMutationEffectsOnFiber(parentFiber, root$jscomp$0), parentFiber = parentFiber.sibling;
+    }
+    function commitMutationEffectsOnFiber(finishedWork, root) {
+      var current = finishedWork.alternate,
+        flags = finishedWork.flags;
+      switch (finishedWork.tag) {
+        case 0:
+        case 11:
+        case 14:
+        case 15:
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          flags & 4 && (commitHookEffectListUnmount(Insertion | HasEffect, finishedWork, finishedWork.return), commitHookEffectListMount(Insertion | HasEffect, finishedWork), commitHookLayoutUnmountEffects(finishedWork, finishedWork.return, Layout | HasEffect));
+          break;
+        case 1:
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          flags & 512 && (offscreenSubtreeWasHidden || null === current || safelyDetachRef(current, current.return));
+          if (flags & 64 && offscreenSubtreeIsHidden && (finishedWork = finishedWork.updateQueue, null !== finishedWork && (flags = finishedWork.callbacks, null !== flags))) {
+            var existingHiddenCallbacks = finishedWork.shared.hiddenCallbacks;
+            finishedWork.shared.hiddenCallbacks = null === existingHiddenCallbacks ? flags : existingHiddenCallbacks.concat(flags);
+          }
+          break;
+        case 26:
+        case 27:
+        case 5:
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          flags & 512 && (offscreenSubtreeWasHidden || null === current || safelyDetachRef(current, current.return));
+          if (finishedWork.flags & 32) {
+            existingHiddenCallbacks = finishedWork.stateNode;
+            try {
+              runWithFiberInDEV(finishedWork, resetTextContent, existingHiddenCallbacks);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+          if (flags & 4 && null != finishedWork.stateNode) {
+            existingHiddenCallbacks = finishedWork.memoizedProps;
+            var _oldProps = null !== current ? current.memoizedProps : existingHiddenCallbacks;
+            try {
+              runWithFiberInDEV(finishedWork, commitUpdate, finishedWork.stateNode, finishedWork.type, _oldProps, existingHiddenCallbacks, finishedWork);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+          flags & 1024 && "form" !== finishedWork.type && console.error("Unexpected host component type. Expected a form. This is a bug in React.");
+          break;
+        case 6:
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          if (flags & 4) {
+            if (null === finishedWork.stateNode) throw Error("This should have a text node initialized. This error is likely caused by a bug in React. Please file an issue.");
+            flags = finishedWork.memoizedProps;
+            existingHiddenCallbacks = null !== current ? current.memoizedProps : flags;
+            _oldProps = finishedWork.stateNode;
+            try {
+              runWithFiberInDEV(finishedWork, commitTextUpdate, _oldProps, existingHiddenCallbacks, flags);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+          break;
+        case 3:
+          flags = pushNestedEffectDurations();
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          root.effectDuration += popNestedEffectDurations(flags);
+          break;
+        case 4:
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          break;
+        case 12:
+          flags = pushNestedEffectDurations();
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          finishedWork.stateNode.effectDuration += bubbleNestedEffectDurations(flags);
+          break;
+        case 13:
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          finishedWork.child.flags & 8192 && (existingHiddenCallbacks = null !== current && null !== current.memoizedState, null === finishedWork.memoizedState || existingHiddenCallbacks || (globalMostRecentFallbackTime = now$1()));
+          flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (finishedWork.updateQueue = null, attachSuspenseRetryListeners(finishedWork, flags)));
+          break;
+        case 22:
+          existingHiddenCallbacks = null !== finishedWork.memoizedState;
+          var wasHidden = null !== current && null !== current.memoizedState;
+          if (finishedWork.mode & 1) {
+            var prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden,
+              prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+            offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden || existingHiddenCallbacks;
+            offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || wasHidden;
+            recursivelyTraverseMutationEffects(root, finishedWork);
+            offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+            offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
+          } else recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          if (flags & 8192) a: for (root = finishedWork.stateNode, root._visibility = existingHiddenCallbacks ? root._visibility & -2 : root._visibility | 1, existingHiddenCallbacks && (null === current || wasHidden || offscreenSubtreeIsHidden || offscreenSubtreeWasHidden || 0 !== (finishedWork.mode & 1) && recursivelyTraverseDisappearLayoutEffects(finishedWork)), current = null, root = finishedWork;;) {
+            if (5 === root.tag) {
+              if (null === current) {
+                wasHidden = current = root;
+                try {
+                  _oldProps = wasHidden.stateNode, existingHiddenCallbacks ? runWithFiberInDEV(wasHidden, hideInstance, _oldProps) : runWithFiberInDEV(wasHidden, unhideInstance, wasHidden.stateNode, wasHidden.memoizedProps);
+                } catch (error) {
+                  captureCommitPhaseError(wasHidden, wasHidden.return, error);
+                }
+              }
+            } else if (6 === root.tag) {
+              if (null === current) {
+                wasHidden = root;
+                try {
+                  var instance = wasHidden.stateNode;
+                  existingHiddenCallbacks ? runWithFiberInDEV(wasHidden, hideTextInstance, instance) : runWithFiberInDEV(wasHidden, unhideTextInstance, instance, wasHidden.memoizedProps);
+                } catch (error) {
+                  captureCommitPhaseError(wasHidden, wasHidden.return, error);
+                }
+              }
+            } else if ((22 !== root.tag && 23 !== root.tag || null === root.memoizedState || root === finishedWork) && null !== root.child) {
+              root.child.return = root;
+              root = root.child;
+              continue;
+            }
+            if (root === finishedWork) break a;
+            for (; null === root.sibling;) {
+              if (null === root.return || root.return === finishedWork) break a;
+              current === root && (current = null);
+              root = root.return;
+            }
+            current === root && (current = null);
+            root.sibling.return = root.return;
+            root = root.sibling;
+          }
+          flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (existingHiddenCallbacks = flags.retryQueue, null !== existingHiddenCallbacks && (flags.retryQueue = null, attachSuspenseRetryListeners(finishedWork, existingHiddenCallbacks))));
+          break;
+        case 19:
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          commitReconciliationEffects(finishedWork);
+          flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (finishedWork.updateQueue = null, attachSuspenseRetryListeners(finishedWork, flags)));
+          break;
+        case 30:
+          break;
+        case 21:
+          break;
+        default:
+          recursivelyTraverseMutationEffects(root, finishedWork), commitReconciliationEffects(finishedWork);
+      }
+    }
+    function commitReconciliationEffects(finishedWork) {
+      var flags = finishedWork.flags;
+      if (flags & 2) {
+        try {
+          runWithFiberInDEV(finishedWork, commitPlacement, finishedWork);
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        }
+        finishedWork.flags &= -3;
+      }
+      flags & 4096 && (finishedWork.flags &= -4097);
+    }
+    function recursivelyTraverseLayoutEffects(root, parentFiber) {
+      if (parentFiber.subtreeFlags & 8772) for (parentFiber = parentFiber.child; null !== parentFiber;) commitLayoutEffectOnFiber(root, parentFiber.alternate, parentFiber), parentFiber = parentFiber.sibling;
+    }
+    function disappearLayoutEffects(finishedWork) {
+      switch (finishedWork.tag) {
+        case 0:
+        case 11:
+        case 14:
+        case 15:
+          commitHookLayoutUnmountEffects(finishedWork, finishedWork.return, Layout);
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+          break;
+        case 1:
+          safelyDetachRef(finishedWork, finishedWork.return);
+          var instance = finishedWork.stateNode;
+          "function" === typeof instance.componentWillUnmount && safelyCallComponentWillUnmount(finishedWork, finishedWork.return, instance);
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+          break;
+        case 27:
+        case 26:
+        case 5:
+          safelyDetachRef(finishedWork, finishedWork.return);
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+          break;
+        case 22:
+          null === finishedWork.memoizedState && recursivelyTraverseDisappearLayoutEffects(finishedWork);
+          break;
+        case 30:
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+          break;
+        default:
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+      }
+    }
+    function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
+      for (parentFiber = parentFiber.child; null !== parentFiber;) disappearLayoutEffects(parentFiber), parentFiber = parentFiber.sibling;
+    }
+    function reappearLayoutEffects(finishedRoot, current, finishedWork, includeWorkInProgressEffects) {
+      var flags = finishedWork.flags;
+      switch (finishedWork.tag) {
+        case 0:
+        case 11:
+        case 15:
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+          commitHookLayoutEffects(finishedWork, Layout);
+          break;
+        case 1:
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+          commitClassDidMount(finishedWork);
+          current = finishedWork.updateQueue;
+          if (null !== current) {
+            finishedRoot = finishedWork.stateNode;
+            try {
+              runWithFiberInDEV(finishedWork, commitHiddenCallbacks, current, finishedRoot);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+          includeWorkInProgressEffects && flags & 64 && commitClassCallbacks(finishedWork);
+          safelyAttachRef(finishedWork, finishedWork.return);
+          break;
+        case 27:
+        case 26:
+        case 5:
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+          includeWorkInProgressEffects && null === current && flags & 4 && commitHostMount(finishedWork);
+          safelyAttachRef(finishedWork, finishedWork.return);
+          break;
+        case 12:
+          if (includeWorkInProgressEffects && flags & 4) {
+            flags = pushNestedEffectDurations();
+            recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+            includeWorkInProgressEffects = finishedWork.stateNode;
+            includeWorkInProgressEffects.effectDuration += bubbleNestedEffectDurations(flags);
+            try {
+              runWithFiberInDEV(finishedWork, commitProfiler, finishedWork, current, commitStartTime, includeWorkInProgressEffects.effectDuration);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          } else recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+          break;
+        case 13:
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+          break;
+        case 22:
+          null === finishedWork.memoizedState && recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+          safelyAttachRef(finishedWork, finishedWork.return);
+          break;
+        case 30:
+          break;
+        default:
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+      }
+    }
+    function recursivelyTraverseReappearLayoutEffects(finishedRoot, parentFiber, includeWorkInProgressEffects) {
+      includeWorkInProgressEffects = includeWorkInProgressEffects && 0 !== (parentFiber.subtreeFlags & 8772);
+      for (parentFiber = parentFiber.child; null !== parentFiber;) reappearLayoutEffects(finishedRoot, parentFiber.alternate, parentFiber, includeWorkInProgressEffects), parentFiber = parentFiber.sibling;
+    }
+    function commitOffscreenPassiveMountEffects(current, finishedWork) {
+      var previousCache = null;
+      null !== current && null !== current.memoizedState && null !== current.memoizedState.cachePool && (previousCache = current.memoizedState.cachePool.pool);
+      current = null;
+      null !== finishedWork.memoizedState && null !== finishedWork.memoizedState.cachePool && (current = finishedWork.memoizedState.cachePool.pool);
+      current !== previousCache && (null != current && retainCache(current), null != previousCache && releaseCache(previousCache));
+    }
+    function commitCachePassiveMountEffect(current, finishedWork) {
+      current = null;
+      null !== finishedWork.alternate && (current = finishedWork.alternate.memoizedState.cache);
+      finishedWork = finishedWork.memoizedState.cache;
+      finishedWork !== current && (retainCache(finishedWork), null != current && releaseCache(current));
+    }
+    function recursivelyTraversePassiveMountEffects(root, parentFiber, committedLanes, committedTransitions) {
+      if (parentFiber.subtreeFlags & 10256) for (parentFiber = parentFiber.child; null !== parentFiber;) commitPassiveMountOnFiber(root, parentFiber, committedLanes, committedTransitions), parentFiber = parentFiber.sibling;
+    }
+    function commitPassiveMountOnFiber(finishedRoot, finishedWork, committedLanes, committedTransitions) {
+      var flags = finishedWork.flags;
+      switch (finishedWork.tag) {
+        case 0:
+        case 11:
+        case 15:
+          recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+          flags & 2048 && commitHookPassiveMountEffects(finishedWork, Passive | HasEffect);
+          break;
+        case 1:
+          recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+          break;
+        case 3:
+          var prevEffectDuration = pushNestedEffectDurations();
+          recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+          flags & 2048 && (committedLanes = null, null !== finishedWork.alternate && (committedLanes = finishedWork.alternate.memoizedState.cache), finishedWork = finishedWork.memoizedState.cache, finishedWork !== committedLanes && (retainCache(finishedWork), null != committedLanes && releaseCache(committedLanes)));
+          finishedRoot.passiveEffectDuration += popNestedEffectDurations(prevEffectDuration);
+          break;
+        case 12:
+          if (flags & 2048) {
+            flags = pushNestedEffectDurations();
+            recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+            finishedRoot = finishedWork.stateNode;
+            finishedRoot.passiveEffectDuration += bubbleNestedEffectDurations(flags);
+            try {
+              runWithFiberInDEV(finishedWork, commitProfilerPostCommitImpl, finishedWork, finishedWork.alternate, commitStartTime, finishedRoot.passiveEffectDuration);
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          } else recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+          break;
+        case 13:
+          recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+          break;
+        case 23:
+          break;
+        case 22:
+          prevEffectDuration = finishedWork.stateNode;
+          var _current = finishedWork.alternate;
+          null !== finishedWork.memoizedState ? prevEffectDuration._visibility & 2 ? recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions) : finishedWork.mode & 1 ? recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork) : (prevEffectDuration._visibility |= 2, recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions)) : prevEffectDuration._visibility & 2 ? recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions) : (prevEffectDuration._visibility |= 2, recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, 0 !== (finishedWork.subtreeFlags & 10256)));
+          flags & 2048 && commitOffscreenPassiveMountEffects(_current, finishedWork);
+          break;
+        case 24:
+          recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+          flags & 2048 && commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
+          break;
+        default:
+          recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+      }
+    }
+    function recursivelyTraverseReconnectPassiveEffects(finishedRoot, parentFiber, committedLanes, committedTransitions, includeWorkInProgressEffects) {
+      includeWorkInProgressEffects = includeWorkInProgressEffects && 0 !== (parentFiber.subtreeFlags & 10256);
+      for (parentFiber = parentFiber.child; null !== parentFiber;) reconnectPassiveEffects(finishedRoot, parentFiber, committedLanes, committedTransitions, includeWorkInProgressEffects), parentFiber = parentFiber.sibling;
+    }
+    function reconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects) {
+      var flags = finishedWork.flags;
+      switch (finishedWork.tag) {
+        case 0:
+        case 11:
+        case 15:
+          recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+          commitHookPassiveMountEffects(finishedWork, Passive);
+          break;
+        case 23:
+          break;
+        case 22:
+          var _instance2 = finishedWork.stateNode;
+          null !== finishedWork.memoizedState ? _instance2._visibility & 2 ? recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects) : finishedWork.mode & 1 ? recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork) : (_instance2._visibility |= 2, recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects)) : (_instance2._visibility |= 2, recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects));
+          includeWorkInProgressEffects && flags & 2048 && commitOffscreenPassiveMountEffects(finishedWork.alternate, finishedWork);
+          break;
+        case 24:
+          recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+          includeWorkInProgressEffects && flags & 2048 && commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
+          break;
+        default:
+          recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+      }
+    }
+    function recursivelyTraverseAtomicPassiveEffects(finishedRoot$jscomp$0, parentFiber) {
+      if (parentFiber.subtreeFlags & 10256) for (parentFiber = parentFiber.child; null !== parentFiber;) {
+        var finishedRoot = finishedRoot$jscomp$0,
+          finishedWork = parentFiber,
+          flags = finishedWork.flags;
+        switch (finishedWork.tag) {
+          case 22:
+            recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+            flags & 2048 && commitOffscreenPassiveMountEffects(finishedWork.alternate, finishedWork);
+            break;
+          case 24:
+            recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+            flags & 2048 && commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
+            break;
+          default:
+            recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+        }
+        parentFiber = parentFiber.sibling;
+      }
+    }
+    function recursivelyAccumulateSuspenseyCommit(parentFiber) {
+      if (parentFiber.subtreeFlags & suspenseyCommitFlag) for (parentFiber = parentFiber.child; null !== parentFiber;) accumulateSuspenseyCommitOnFiber(parentFiber), parentFiber = parentFiber.sibling;
+    }
+    function accumulateSuspenseyCommitOnFiber(fiber) {
+      switch (fiber.tag) {
+        case 26:
+          recursivelyAccumulateSuspenseyCommit(fiber);
+          fiber.flags & suspenseyCommitFlag && null !== fiber.memoizedState && suspendResource();
+          break;
+        case 5:
+          recursivelyAccumulateSuspenseyCommit(fiber);
+          break;
+        case 3:
+        case 4:
+          recursivelyAccumulateSuspenseyCommit(fiber);
+          break;
+        case 22:
+          if (null === fiber.memoizedState) {
+            var current = fiber.alternate;
+            null !== current && null !== current.memoizedState ? (current = suspenseyCommitFlag, suspenseyCommitFlag = 16777216, recursivelyAccumulateSuspenseyCommit(fiber), suspenseyCommitFlag = current) : recursivelyAccumulateSuspenseyCommit(fiber);
+          }
+          break;
+        default:
+          recursivelyAccumulateSuspenseyCommit(fiber);
+      }
+    }
+    function detachAlternateSiblings(parentFiber) {
+      var previousFiber = parentFiber.alternate;
+      if (null !== previousFiber && (parentFiber = previousFiber.child, null !== parentFiber)) {
+        previousFiber.child = null;
+        do previousFiber = parentFiber.sibling, parentFiber.sibling = null, parentFiber = previousFiber; while (null !== parentFiber);
+      }
+    }
+    function recursivelyTraversePassiveUnmountEffects(parentFiber) {
+      var deletions = parentFiber.deletions;
+      if (0 !== (parentFiber.flags & 16)) {
+        if (null !== deletions) for (var i = 0; i < deletions.length; i++) {
+          var childToDelete = deletions[i];
+          nextEffect = childToDelete;
+          commitPassiveUnmountEffectsInsideOfDeletedTree_begin(childToDelete, parentFiber);
+        }
+        detachAlternateSiblings(parentFiber);
+      }
+      if (parentFiber.subtreeFlags & 10256) for (parentFiber = parentFiber.child; null !== parentFiber;) commitPassiveUnmountOnFiber(parentFiber), parentFiber = parentFiber.sibling;
+    }
+    function commitPassiveUnmountOnFiber(finishedWork) {
+      switch (finishedWork.tag) {
+        case 0:
+        case 11:
+        case 15:
+          recursivelyTraversePassiveUnmountEffects(finishedWork);
+          finishedWork.flags & 2048 && commitHookPassiveUnmountEffects(finishedWork, finishedWork.return, Passive | HasEffect);
+          break;
+        case 3:
+          var prevEffectDuration = pushNestedEffectDurations();
+          recursivelyTraversePassiveUnmountEffects(finishedWork);
+          finishedWork.stateNode.passiveEffectDuration += popNestedEffectDurations(prevEffectDuration);
+          break;
+        case 12:
+          prevEffectDuration = pushNestedEffectDurations();
+          recursivelyTraversePassiveUnmountEffects(finishedWork);
+          finishedWork.stateNode.passiveEffectDuration += bubbleNestedEffectDurations(prevEffectDuration);
+          break;
+        case 22:
+          prevEffectDuration = finishedWork.stateNode;
+          null !== finishedWork.memoizedState && prevEffectDuration._visibility & 2 && (null === finishedWork.return || 13 !== finishedWork.return.tag) ? (prevEffectDuration._visibility &= -3, recursivelyTraverseDisconnectPassiveEffects(finishedWork)) : recursivelyTraversePassiveUnmountEffects(finishedWork);
+          break;
+        default:
+          recursivelyTraversePassiveUnmountEffects(finishedWork);
+      }
+    }
+    function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
+      var deletions = parentFiber.deletions;
+      if (0 !== (parentFiber.flags & 16)) {
+        if (null !== deletions) for (var i = 0; i < deletions.length; i++) {
+          var childToDelete = deletions[i];
+          nextEffect = childToDelete;
+          commitPassiveUnmountEffectsInsideOfDeletedTree_begin(childToDelete, parentFiber);
+        }
+        detachAlternateSiblings(parentFiber);
+      }
+      for (parentFiber = parentFiber.child; null !== parentFiber;) disconnectPassiveEffect(parentFiber), parentFiber = parentFiber.sibling;
+    }
+    function disconnectPassiveEffect(finishedWork) {
+      switch (finishedWork.tag) {
+        case 0:
+        case 11:
+        case 15:
+          commitHookPassiveUnmountEffects(finishedWork, finishedWork.return, Passive);
+          recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+          break;
+        case 22:
+          var instance = finishedWork.stateNode;
+          instance._visibility & 2 && (instance._visibility &= -3, recursivelyTraverseDisconnectPassiveEffects(finishedWork));
+          break;
+        default:
+          recursivelyTraverseDisconnectPassiveEffects(finishedWork);
+      }
+    }
+    function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(deletedSubtreeRoot, nearestMountedAncestor) {
+      for (; null !== nextEffect;) {
+        var fiber = nextEffect,
+          current = fiber;
+        switch (current.tag) {
+          case 0:
+          case 11:
+          case 15:
+            commitHookPassiveUnmountEffects(current, nearestMountedAncestor, Passive);
+            break;
+          case 23:
+          case 22:
+            null !== current.memoizedState && null !== current.memoizedState.cachePool && (current = current.memoizedState.cachePool.pool, null != current && retainCache(current));
+            break;
+          case 24:
+            releaseCache(current.memoizedState.cache);
+        }
+        current = fiber.child;
+        if (null !== current) current.return = fiber, nextEffect = current;else a: for (fiber = deletedSubtreeRoot; null !== nextEffect;) {
+          current = nextEffect;
+          var sibling = current.sibling,
+            returnFiber = current.return;
+          detachFiberAfterEffects(current);
+          if (current === fiber) {
+            nextEffect = null;
+            break a;
+          }
+          if (null !== sibling) {
+            sibling.return = returnFiber;
+            nextEffect = sibling;
+            break a;
+          }
+          nextEffect = returnFiber;
+        }
+      }
+    }
+    function invokeLayoutEffectMountInDEV(fiber) {
+      switch (fiber.tag) {
+        case 0:
+        case 11:
+        case 15:
+          commitHookEffectListMount(Layout | HasEffect, fiber);
+          break;
+        case 1:
+          commitClassDidMount(fiber);
+      }
+    }
+    function invokePassiveEffectMountInDEV(fiber) {
+      switch (fiber.tag) {
+        case 0:
+        case 11:
+        case 15:
+          commitHookEffectListMount(Passive | HasEffect, fiber);
+      }
+    }
+    function invokeLayoutEffectUnmountInDEV(fiber) {
+      switch (fiber.tag) {
+        case 0:
+        case 11:
+        case 15:
+          commitHookEffectListUnmount(Layout | HasEffect, fiber, fiber.return);
+          break;
+        case 1:
+          var instance = fiber.stateNode;
+          "function" === typeof instance.componentWillUnmount && safelyCallComponentWillUnmount(fiber, fiber.return, instance);
+      }
+    }
+    function invokePassiveEffectUnmountInDEV(fiber) {
+      switch (fiber.tag) {
+        case 0:
+        case 11:
+        case 15:
+          commitHookEffectListUnmount(Passive | HasEffect, fiber, fiber.return);
+      }
+    }
+    function isLegacyActEnvironment() {
+      var isReactActEnvironmentGlobal = "undefined" !== typeof IS_REACT_ACT_ENVIRONMENT ? IS_REACT_ACT_ENVIRONMENT : void 0;
+      return "undefined" !== typeof jest && !1 !== isReactActEnvironmentGlobal;
+    }
+    function isConcurrentActEnvironment() {
+      var isReactActEnvironmentGlobal = "undefined" !== typeof IS_REACT_ACT_ENVIRONMENT ? IS_REACT_ACT_ENVIRONMENT : void 0;
+      isReactActEnvironmentGlobal || null === ReactSharedInternals.actQueue || console.error("The current testing environment is not configured to support act(...)");
+      return isReactActEnvironmentGlobal;
+    }
+    function requestUpdateLane(fiber) {
+      if (0 === (fiber.mode & 1)) return 2;
+      if ((executionContext & RenderContext) !== NoContext && 0 !== workInProgressRootRenderLanes) return workInProgressRootRenderLanes & -workInProgressRootRenderLanes;
+      var transition = ReactSharedInternals.T;
+      if (null !== transition) return transition._updatedFibers || (transition._updatedFibers = new Set()), transition._updatedFibers.add(fiber), fiber = currentEntangledLane, 0 !== fiber ? fiber : requestTransitionLane();
+      fiber = 0 !== currentUpdatePriority ? currentUpdatePriority : DefaultEventPriority;
+      return fiber;
+    }
+    function requestDeferredLane() {
+      0 === workInProgressDeferredLane && (workInProgressDeferredLane = 0 !== (workInProgressRootRenderLanes & 536870912) ? 536870912 : claimNextTransitionLane());
+      var suspenseHandler = suspenseHandlerStackCursor.current;
+      null !== suspenseHandler && (suspenseHandler.flags |= 32);
+      return workInProgressDeferredLane;
+    }
+    function scheduleUpdateOnFiber(root, fiber, lane) {
+      isRunningInsertionEffect && console.error("useInsertionEffect must not schedule updates.");
+      isFlushingPassiveEffects && (didScheduleUpdateDuringPassiveEffects = !0);
+      if (root === workInProgressRoot && (workInProgressSuspendedReason === SuspendedOnData || workInProgressSuspendedReason === SuspendedOnAction) || null !== root.cancelPendingCommit) prepareFreshStack(root, 0), markRootSuspended(root, workInProgressRootRenderLanes, workInProgressDeferredLane, !1);
+      markRootUpdated$1(root, lane);
+      if (0 !== (executionContext & RenderContext) && root === workInProgressRoot) {
+        if (isRendering) switch (fiber.tag) {
+          case 0:
+          case 11:
+          case 15:
+            root = workInProgress && getComponentNameFromFiber(workInProgress) || "Unknown";
+            didWarnAboutUpdateInRenderForAnotherComponent.has(root) || (didWarnAboutUpdateInRenderForAnotherComponent.add(root), fiber = getComponentNameFromFiber(fiber) || "Unknown", console.error("Cannot update a component (`%s`) while rendering a different component (`%s`). To locate the bad setState() call inside `%s`, follow the stack trace as described in https://react.dev/link/setstate-in-render", fiber, root, root));
+            break;
+          case 1:
+            didWarnAboutUpdateInRender || (console.error("Cannot update during an existing state transition (such as within `render`). Render methods should be a pure function of props and state."), didWarnAboutUpdateInRender = !0);
+        }
+      } else isDevToolsPresent && addFiberToLanesMap(root, fiber, lane), warnIfUpdatesNotWrappedWithActDEV(fiber), root === workInProgressRoot && ((executionContext & RenderContext) === NoContext && (workInProgressRootInterleavedUpdatedLanes |= lane), workInProgressRootExitStatus === RootSuspendedWithDelay && markRootSuspended(root, workInProgressRootRenderLanes, workInProgressDeferredLane, !1)), ensureRootIsScheduled(root), 2 !== lane || executionContext !== NoContext || 0 !== (fiber.mode & 1) || ReactSharedInternals.isBatchingLegacy || (workInProgressRootRenderTargetTime = now$1() + RENDER_TIMEOUT_MS, flushSyncWorkAcrossRoots_impl(0, !0));
+    }
+    function performWorkOnRoot(root, lanes, forceSync) {
+      if ((executionContext & (RenderContext | CommitContext)) !== NoContext) throw Error("Should not already be working.");
+      var shouldTimeSlice = !forceSync && 0 === (lanes & 124) && 0 === (lanes & root.expiredLanes) || checkIfRootIsPrerendering(root, lanes),
+        exitStatus = shouldTimeSlice ? renderRootConcurrent(root, lanes) : renderRootSync(root, lanes, !0),
+        renderWasConcurrent = shouldTimeSlice;
+      do {
+        if (exitStatus === RootInProgress) {
+          workInProgressRootIsPrerendering && !shouldTimeSlice && markRootSuspended(root, lanes, 0, !1);
+          break;
+        } else {
+          forceSync = root.current.alternate;
+          if (renderWasConcurrent && !isRenderConsistentWithExternalStores(forceSync)) {
+            exitStatus = renderRootSync(root, lanes, !1);
+            renderWasConcurrent = !1;
+            continue;
+          }
+          if (0 !== root.tag && exitStatus === RootErrored) {
+            var lanesThatJustErrored = lanes;
+            root.errorRecoveryDisabledLanes & lanesThatJustErrored ? renderWasConcurrent = 0 : (renderWasConcurrent = root.pendingLanes & -536870913, renderWasConcurrent = 0 !== renderWasConcurrent ? renderWasConcurrent : renderWasConcurrent & 536870912 ? 536870912 : 0);
+            if (0 !== renderWasConcurrent) {
+              lanes = renderWasConcurrent;
+              a: {
+                exitStatus = root;
+                var originallyAttemptedLanes = lanesThatJustErrored;
+                lanesThatJustErrored = workInProgressRootConcurrentErrors;
+                renderWasConcurrent = renderRootSync(exitStatus, renderWasConcurrent, !1);
+                if (renderWasConcurrent !== RootErrored) {
+                  if (workInProgressRootDidAttachPingListener) {
+                    exitStatus.errorRecoveryDisabledLanes |= originallyAttemptedLanes;
+                    workInProgressRootInterleavedUpdatedLanes |= originallyAttemptedLanes;
+                    exitStatus = RootSuspendedWithDelay;
+                    break a;
+                  }
+                  exitStatus = workInProgressRootRecoverableErrors;
+                  workInProgressRootRecoverableErrors = lanesThatJustErrored;
+                  null !== exitStatus && (null === workInProgressRootRecoverableErrors ? workInProgressRootRecoverableErrors = exitStatus : workInProgressRootRecoverableErrors.push.apply(workInProgressRootRecoverableErrors, exitStatus));
+                }
+                exitStatus = renderWasConcurrent;
+              }
+              renderWasConcurrent = !1;
+              if (exitStatus !== RootErrored) continue;
+            }
+          }
+          if (exitStatus === RootFatalErrored) {
+            prepareFreshStack(root, 0);
+            markRootSuspended(root, lanes, 0, !0);
+            break;
+          }
+          a: {
+            shouldTimeSlice = root;
+            switch (exitStatus) {
+              case RootInProgress:
+              case RootFatalErrored:
+                throw Error("Root did not complete. This is a bug in React.");
+              case RootSuspendedWithDelay:
+                if ((lanes & 4194048) !== lanes) break;
+              case RootSuspendedAtTheShell:
+                markRootSuspended(shouldTimeSlice, lanes, workInProgressDeferredLane, !workInProgressRootDidSkipSuspendedSiblings);
+                break a;
+              case RootErrored:
+                workInProgressRootRecoverableErrors = null;
+                break;
+              case RootSuspended:
+              case RootCompleted:
+                break;
+              default:
+                throw Error("Unknown root exit status.");
+            }
+            if (null !== ReactSharedInternals.actQueue) commitRoot(shouldTimeSlice, forceSync, lanes, workInProgressRootRecoverableErrors, workInProgressTransitions, workInProgressRootDidIncludeRecursiveRenderUpdate, workInProgressDeferredLane, workInProgressRootInterleavedUpdatedLanes, workInProgressSuspendedRetryLanes);else {
+              if ((lanes & 62914560) === lanes && exitStatus === RootSuspended && (renderWasConcurrent = globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now$1(), 10 < renderWasConcurrent)) {
+                markRootSuspended(shouldTimeSlice, lanes, workInProgressDeferredLane, !workInProgressRootDidSkipSuspendedSiblings);
+                if (0 !== getNextLanes(shouldTimeSlice, 0, !0)) break a;
+                shouldTimeSlice.timeoutHandle = scheduleTimeout(commitRootWhenReady.bind(null, shouldTimeSlice, forceSync, workInProgressRootRecoverableErrors, workInProgressTransitions, workInProgressRootDidIncludeRecursiveRenderUpdate, lanes, workInProgressDeferredLane, workInProgressRootInterleavedUpdatedLanes, workInProgressSuspendedRetryLanes, workInProgressRootDidSkipSuspendedSiblings, exitStatus, THROTTLED_COMMIT, -0, 0), renderWasConcurrent);
+                break a;
+              }
+              commitRootWhenReady(shouldTimeSlice, forceSync, workInProgressRootRecoverableErrors, workInProgressTransitions, workInProgressRootDidIncludeRecursiveRenderUpdate, lanes, workInProgressDeferredLane, workInProgressRootInterleavedUpdatedLanes, workInProgressSuspendedRetryLanes, workInProgressRootDidSkipSuspendedSiblings, exitStatus, IMMEDIATE_COMMIT, -0, 0);
+            }
+          }
+        }
+        break;
+      } while (1);
+      ensureRootIsScheduled(root);
+    }
+    function commitRootWhenReady(root, finishedWork, recoverableErrors, transitions, didIncludeRenderPhaseUpdate, lanes, spawnedLane, updatedLanes, suspendedRetryLanes) {
+      root.timeoutHandle = -1;
+      var subtreeFlags = finishedWork.subtreeFlags;
+      (subtreeFlags & 8192 || 16785408 === (subtreeFlags & 16785408)) && accumulateSuspenseyCommitOnFiber(finishedWork);
+      commitRoot(root, finishedWork, lanes, recoverableErrors, transitions, didIncludeRenderPhaseUpdate, spawnedLane, updatedLanes, suspendedRetryLanes);
+    }
+    function isRenderConsistentWithExternalStores(finishedWork) {
+      for (var node = finishedWork;;) {
+        var tag = node.tag;
+        if ((0 === tag || 11 === tag || 15 === tag) && node.flags & 16384 && (tag = node.updateQueue, null !== tag && (tag = tag.stores, null !== tag))) for (var i = 0; i < tag.length; i++) {
+          var check = tag[i],
+            getSnapshot = check.getSnapshot;
+          check = check.value;
+          try {
+            if (!objectIs(getSnapshot(), check)) return !1;
+          } catch (error) {
+            return !1;
+          }
+        }
+        tag = node.child;
+        if (node.subtreeFlags & 16384 && null !== tag) tag.return = node, node = tag;else {
+          if (node === finishedWork) break;
+          for (; null === node.sibling;) {
+            if (null === node.return || node.return === finishedWork) return !0;
+            node = node.return;
+          }
+          node.sibling.return = node.return;
+          node = node.sibling;
+        }
+      }
+      return !0;
+    }
+    function markRootSuspended(root, suspendedLanes, spawnedLane, didAttemptEntireTree) {
+      suspendedLanes &= ~workInProgressRootPingedLanes;
+      suspendedLanes &= ~workInProgressRootInterleavedUpdatedLanes;
+      root.suspendedLanes |= suspendedLanes;
+      root.pingedLanes &= ~suspendedLanes;
+      didAttemptEntireTree && (root.warmLanes |= suspendedLanes);
+      didAttemptEntireTree = root.expirationTimes;
+      for (var lanes = suspendedLanes; 0 < lanes;) {
+        var index = 31 - clz32(lanes),
+          lane = 1 << index;
+        didAttemptEntireTree[index] = -1;
+        lanes &= ~lane;
+      }
+      0 !== spawnedLane && markSpawnedDeferredLane(root, spawnedLane, suspendedLanes);
+    }
+    function flushSyncWork() {
+      return (executionContext & (RenderContext | CommitContext)) === NoContext ? (flushSyncWorkAcrossRoots_impl(0, !1), !1) : !0;
+    }
+    function resetWorkInProgressStack() {
+      if (null !== workInProgress) {
+        if (workInProgressSuspendedReason === NotSuspended) var interruptedWork = workInProgress.return;else interruptedWork = workInProgress, resetContextDependencies(), resetHooksOnUnwind(interruptedWork), thenableState = null, thenableIndexCounter = 0, interruptedWork = workInProgress;
+        for (; null !== interruptedWork;) unwindInterruptedWork(interruptedWork.alternate, interruptedWork), interruptedWork = interruptedWork.return;
+        workInProgress = null;
+      }
+    }
+    function prepareFreshStack(root, lanes) {
+      var timeoutHandle = root.timeoutHandle;
+      -1 !== timeoutHandle && (root.timeoutHandle = -1, cancelTimeout(timeoutHandle));
+      timeoutHandle = root.cancelPendingCommit;
+      null !== timeoutHandle && (root.cancelPendingCommit = null, timeoutHandle());
+      resetWorkInProgressStack();
+      workInProgressRoot = root;
+      workInProgress = timeoutHandle = createWorkInProgress(root.current, null);
+      workInProgressRootRenderLanes = lanes;
+      workInProgressSuspendedReason = NotSuspended;
+      workInProgressThrownValue = null;
+      workInProgressRootDidSkipSuspendedSiblings = !1;
+      workInProgressRootIsPrerendering = checkIfRootIsPrerendering(root, lanes);
+      workInProgressRootDidAttachPingListener = !1;
+      workInProgressRootExitStatus = RootInProgress;
+      workInProgressSuspendedRetryLanes = workInProgressDeferredLane = workInProgressRootPingedLanes = workInProgressRootInterleavedUpdatedLanes = workInProgressRootSkippedLanes = 0;
+      workInProgressRootRecoverableErrors = workInProgressRootConcurrentErrors = null;
+      workInProgressRootDidIncludeRecursiveRenderUpdate = !1;
+      0 !== (lanes & 8) && (lanes |= lanes & 32);
+      var allEntangledLanes = root.entangledLanes;
+      if (0 !== allEntangledLanes) for (root = root.entanglements, allEntangledLanes &= lanes; 0 < allEntangledLanes;) {
+        var index = 31 - clz32(allEntangledLanes),
+          lane = 1 << index;
+        lanes |= root[index];
+        allEntangledLanes &= ~lane;
+      }
+      entangledRenderLanes = lanes;
+      finishQueueingConcurrentUpdates();
+      lanes = getCurrentTime();
+      1e3 < lanes - lastResetTime && (ReactSharedInternals.recentlyCreatedOwnerStacks = 0, lastResetTime = lanes);
+      ReactStrictModeWarnings.discardPendingWarnings();
+      return timeoutHandle;
+    }
+    function handleThrow(root, thrownValue) {
+      currentlyRenderingFiber = null;
+      ReactSharedInternals.H = ContextOnlyDispatcher;
+      ReactSharedInternals.getCurrentStack = null;
+      isRendering = !1;
+      current = null;
+      thrownValue === SuspenseException || thrownValue === SuspenseActionException ? (thrownValue = getSuspendedThenable(), workInProgressSuspendedReason = SuspendedOnImmediate) : thrownValue === SuspenseyCommitException ? (thrownValue = getSuspendedThenable(), workInProgressSuspendedReason = SuspendedOnInstance) : workInProgressSuspendedReason = thrownValue === SelectiveHydrationException ? SuspendedOnHydration : null !== thrownValue && "object" === typeof thrownValue && "function" === typeof thrownValue.then ? SuspendedOnDeprecatedThrowPromise : SuspendedOnError;
+      workInProgressThrownValue = thrownValue;
+      var erroredWork = workInProgress;
+      if (null === erroredWork) workInProgressRootExitStatus = RootFatalErrored, logUncaughtError(root, createCapturedValueAtFiber(thrownValue, root.current));else switch (erroredWork.mode & 2 && stopProfilerTimerIfRunningAndRecordDuration(erroredWork), markComponentRenderStopped(), workInProgressSuspendedReason) {
+        case SuspendedOnError:
+          null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markComponentErrored && injectedProfilingHooks.markComponentErrored(erroredWork, thrownValue, workInProgressRootRenderLanes);
+          break;
+        case SuspendedOnData:
+        case SuspendedOnAction:
+        case SuspendedOnImmediate:
+        case SuspendedOnDeprecatedThrowPromise:
+        case SuspendedAndReadyToContinue:
+          null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markComponentSuspended && injectedProfilingHooks.markComponentSuspended(erroredWork, thrownValue, workInProgressRootRenderLanes);
+      }
+    }
+    function pushDispatcher() {
+      var prevDispatcher = ReactSharedInternals.H;
+      ReactSharedInternals.H = ContextOnlyDispatcher;
+      return null === prevDispatcher ? ContextOnlyDispatcher : prevDispatcher;
+    }
+    function pushAsyncDispatcher() {
+      var prevAsyncDispatcher = ReactSharedInternals.A;
+      ReactSharedInternals.A = DefaultAsyncDispatcher;
+      return prevAsyncDispatcher;
+    }
+    function renderDidSuspendDelayIfPossible() {
+      workInProgressRootExitStatus = RootSuspendedWithDelay;
+      workInProgressRootDidSkipSuspendedSiblings || (workInProgressRootRenderLanes & 4194048) !== workInProgressRootRenderLanes && null !== suspenseHandlerStackCursor.current || (workInProgressRootIsPrerendering = !0);
+      0 === (workInProgressRootSkippedLanes & 134217727) && 0 === (workInProgressRootInterleavedUpdatedLanes & 134217727) || null === workInProgressRoot || markRootSuspended(workInProgressRoot, workInProgressRootRenderLanes, workInProgressDeferredLane, !1);
+    }
+    function renderRootSync(root, lanes, shouldYieldForPrerendering) {
+      var prevExecutionContext = executionContext;
+      executionContext |= RenderContext;
+      var prevDispatcher = pushDispatcher(),
+        prevAsyncDispatcher = pushAsyncDispatcher();
+      if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
+        if (isDevToolsPresent) {
+          var memoizedUpdaters = root.memoizedUpdaters;
+          0 < memoizedUpdaters.size && (restorePendingUpdaters(root, workInProgressRootRenderLanes), memoizedUpdaters.clear());
+          movePendingFibersToMemoized(root, lanes);
+        }
+        workInProgressTransitions = null;
+        prepareFreshStack(root, lanes);
+      }
+      markRenderStarted(lanes);
+      lanes = !1;
+      memoizedUpdaters = workInProgressRootExitStatus;
+      a: do try {
+        if (workInProgressSuspendedReason !== NotSuspended && null !== workInProgress) {
+          var unitOfWork = workInProgress,
+            thrownValue = workInProgressThrownValue;
+          switch (workInProgressSuspendedReason) {
+            case SuspendedOnHydration:
+              resetWorkInProgressStack();
+              memoizedUpdaters = RootSuspendedAtTheShell;
+              break a;
+            case SuspendedOnImmediate:
+            case SuspendedOnData:
+            case SuspendedOnAction:
+            case SuspendedOnDeprecatedThrowPromise:
+              null === suspenseHandlerStackCursor.current && (lanes = !0);
+              var reason = workInProgressSuspendedReason;
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              throwAndUnwindWorkLoop(root, unitOfWork, thrownValue, reason);
+              if (shouldYieldForPrerendering && workInProgressRootIsPrerendering) {
+                memoizedUpdaters = RootInProgress;
+                break a;
+              }
+              break;
+            default:
+              reason = workInProgressSuspendedReason, workInProgressSuspendedReason = NotSuspended, workInProgressThrownValue = null, throwAndUnwindWorkLoop(root, unitOfWork, thrownValue, reason);
+          }
+        }
+        workLoopSync();
+        memoizedUpdaters = workInProgressRootExitStatus;
+        break;
+      } catch (thrownValue$4) {
+        handleThrow(root, thrownValue$4);
+      } while (1);
+      lanes && root.shellSuspendCounter++;
+      resetContextDependencies();
+      executionContext = prevExecutionContext;
+      ReactSharedInternals.H = prevDispatcher;
+      ReactSharedInternals.A = prevAsyncDispatcher;
+      markRenderStopped();
+      null === workInProgress && (workInProgressRoot = null, workInProgressRootRenderLanes = 0, finishQueueingConcurrentUpdates());
+      return memoizedUpdaters;
+    }
+    function workLoopSync() {
+      for (; null !== workInProgress;) performUnitOfWork(workInProgress);
+    }
+    function renderRootConcurrent(root, lanes) {
+      var prevExecutionContext = executionContext;
+      executionContext |= RenderContext;
+      var prevDispatcher = pushDispatcher(),
+        prevAsyncDispatcher = pushAsyncDispatcher();
+      if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
+        if (isDevToolsPresent) {
+          var memoizedUpdaters = root.memoizedUpdaters;
+          0 < memoizedUpdaters.size && (restorePendingUpdaters(root, workInProgressRootRenderLanes), memoizedUpdaters.clear());
+          movePendingFibersToMemoized(root, lanes);
+        }
+        workInProgressTransitions = null;
+        workInProgressRootRenderTargetTime = now$1() + RENDER_TIMEOUT_MS;
+        prepareFreshStack(root, lanes);
+      } else workInProgressRootIsPrerendering = checkIfRootIsPrerendering(root, lanes);
+      markRenderStarted(lanes);
+      a: do try {
+        if (workInProgressSuspendedReason !== NotSuspended && null !== workInProgress) b: switch (lanes = workInProgress, memoizedUpdaters = workInProgressThrownValue, workInProgressSuspendedReason) {
+          case SuspendedOnError:
+            workInProgressSuspendedReason = NotSuspended;
+            workInProgressThrownValue = null;
+            throwAndUnwindWorkLoop(root, lanes, memoizedUpdaters, SuspendedOnError);
+            break;
+          case SuspendedOnData:
+          case SuspendedOnAction:
+            if (isThenableResolved(memoizedUpdaters)) {
+              workInProgressSuspendedReason = NotSuspended;
+              workInProgressThrownValue = null;
+              replaySuspendedUnitOfWork(lanes);
+              break;
+            }
+            lanes = function lanes() {
+              workInProgressSuspendedReason !== SuspendedOnData && workInProgressSuspendedReason !== SuspendedOnAction || workInProgressRoot !== root || (workInProgressSuspendedReason = SuspendedAndReadyToContinue);
+              ensureRootIsScheduled(root);
+            };
+            memoizedUpdaters.then(lanes, lanes);
+            break a;
+          case SuspendedOnImmediate:
+            workInProgressSuspendedReason = SuspendedAndReadyToContinue;
+            break a;
+          case SuspendedOnInstance:
+            workInProgressSuspendedReason = SuspendedOnInstanceAndReadyToContinue;
+            break a;
+          case SuspendedAndReadyToContinue:
+            isThenableResolved(memoizedUpdaters) ? (workInProgressSuspendedReason = NotSuspended, workInProgressThrownValue = null, replaySuspendedUnitOfWork(lanes)) : (workInProgressSuspendedReason = NotSuspended, workInProgressThrownValue = null, throwAndUnwindWorkLoop(root, lanes, memoizedUpdaters, SuspendedAndReadyToContinue));
+            break;
+          case SuspendedOnInstanceAndReadyToContinue:
+            var resource = null;
+            switch (workInProgress.tag) {
+              case 26:
+                resource = workInProgress.memoizedState;
+              case 5:
+              case 27:
+                var hostFiber = workInProgress;
+                if (resource ? preloadResource(resource) : 1) {
+                  workInProgressSuspendedReason = NotSuspended;
+                  workInProgressThrownValue = null;
+                  var sibling = hostFiber.sibling;
+                  if (null !== sibling) workInProgress = sibling;else {
+                    var returnFiber = hostFiber.return;
+                    null !== returnFiber ? (workInProgress = returnFiber, completeUnitOfWork(returnFiber)) : workInProgress = null;
+                  }
+                  break b;
+                }
+                break;
+              default:
+                console.error("Unexpected type of fiber triggered a suspensey commit. This is a bug in React.");
+            }
+            workInProgressSuspendedReason = NotSuspended;
+            workInProgressThrownValue = null;
+            throwAndUnwindWorkLoop(root, lanes, memoizedUpdaters, SuspendedOnInstanceAndReadyToContinue);
+            break;
+          case SuspendedOnDeprecatedThrowPromise:
+            workInProgressSuspendedReason = NotSuspended;
+            workInProgressThrownValue = null;
+            throwAndUnwindWorkLoop(root, lanes, memoizedUpdaters, SuspendedOnDeprecatedThrowPromise);
+            break;
+          case SuspendedOnHydration:
+            resetWorkInProgressStack();
+            workInProgressRootExitStatus = RootSuspendedAtTheShell;
+            break a;
+          default:
+            throw Error("Unexpected SuspendedReason. This is a bug in React.");
+        }
+        null !== ReactSharedInternals.actQueue ? workLoopSync() : workLoopConcurrentByScheduler();
+        break;
+      } catch (thrownValue$5) {
+        handleThrow(root, thrownValue$5);
+      } while (1);
+      resetContextDependencies();
+      ReactSharedInternals.H = prevDispatcher;
+      ReactSharedInternals.A = prevAsyncDispatcher;
+      executionContext = prevExecutionContext;
+      if (null !== workInProgress) return null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markRenderYielded && injectedProfilingHooks.markRenderYielded(), RootInProgress;
+      markRenderStopped();
+      workInProgressRoot = null;
+      workInProgressRootRenderLanes = 0;
+      finishQueueingConcurrentUpdates();
+      return workInProgressRootExitStatus;
+    }
+    function workLoopConcurrentByScheduler() {
+      for (; null !== workInProgress && !shouldYield();) performUnitOfWork(workInProgress);
+    }
+    function performUnitOfWork(unitOfWork) {
+      var current = unitOfWork.alternate;
+      0 !== (unitOfWork.mode & 2) ? (startProfilerTimer(unitOfWork), current = runWithFiberInDEV(unitOfWork, beginWork, current, unitOfWork, entangledRenderLanes), stopProfilerTimerIfRunningAndRecordDuration(unitOfWork)) : current = runWithFiberInDEV(unitOfWork, beginWork, current, unitOfWork, entangledRenderLanes);
+      unitOfWork.memoizedProps = unitOfWork.pendingProps;
+      null === current ? completeUnitOfWork(unitOfWork) : workInProgress = current;
+    }
+    function replaySuspendedUnitOfWork(unitOfWork) {
+      var next = runWithFiberInDEV(unitOfWork, replayBeginWork, unitOfWork);
+      unitOfWork.memoizedProps = unitOfWork.pendingProps;
+      null === next ? completeUnitOfWork(unitOfWork) : workInProgress = next;
+    }
+    function replayBeginWork(unitOfWork) {
+      var current = unitOfWork.alternate,
+        isProfilingMode = 0 !== (unitOfWork.mode & 2);
+      isProfilingMode && startProfilerTimer(unitOfWork);
+      switch (unitOfWork.tag) {
+        case 15:
+        case 0:
+          current = replayFunctionComponent(current, unitOfWork, unitOfWork.pendingProps, unitOfWork.type, void 0, workInProgressRootRenderLanes);
+          break;
+        case 11:
+          current = replayFunctionComponent(current, unitOfWork, unitOfWork.pendingProps, unitOfWork.type.render, unitOfWork.ref, workInProgressRootRenderLanes);
+          break;
+        case 5:
+          resetHooksOnUnwind(unitOfWork);
+        default:
+          unwindInterruptedWork(current, unitOfWork), unitOfWork = workInProgress = resetWorkInProgress(unitOfWork, entangledRenderLanes), current = beginWork(current, unitOfWork, entangledRenderLanes);
+      }
+      isProfilingMode && stopProfilerTimerIfRunningAndRecordDuration(unitOfWork);
+      return current;
+    }
+    function throwAndUnwindWorkLoop(root, unitOfWork, thrownValue, suspendedReason) {
+      resetContextDependencies();
+      resetHooksOnUnwind(unitOfWork);
+      thenableState = null;
+      thenableIndexCounter = 0;
+      var returnFiber = unitOfWork.return;
+      try {
+        if (throwException(root, returnFiber, unitOfWork, thrownValue, workInProgressRootRenderLanes)) {
+          workInProgressRootExitStatus = RootFatalErrored;
+          logUncaughtError(root, createCapturedValueAtFiber(thrownValue, root.current));
+          workInProgress = null;
+          return;
+        }
+      } catch (error) {
+        if (null !== returnFiber) throw workInProgress = returnFiber, error;
+        workInProgressRootExitStatus = RootFatalErrored;
+        logUncaughtError(root, createCapturedValueAtFiber(thrownValue, root.current));
+        workInProgress = null;
+        return;
+      }
+      if (unitOfWork.flags & 32768) {
+        if (suspendedReason === SuspendedOnError) root = !0;else if (workInProgressRootIsPrerendering || 0 !== (workInProgressRootRenderLanes & 536870912)) root = !1;else if (workInProgressRootDidSkipSuspendedSiblings = root = !0, suspendedReason === SuspendedOnData || suspendedReason === SuspendedOnAction || suspendedReason === SuspendedOnImmediate || suspendedReason === SuspendedOnDeprecatedThrowPromise) suspendedReason = suspenseHandlerStackCursor.current, null !== suspendedReason && 13 === suspendedReason.tag && (suspendedReason.flags |= 16384);
+        unwindUnitOfWork(unitOfWork, root);
+      } else completeUnitOfWork(unitOfWork);
+    }
+    function completeUnitOfWork(unitOfWork) {
+      var completedWork = unitOfWork;
+      do {
+        if (0 !== (completedWork.flags & 32768)) {
+          unwindUnitOfWork(completedWork, workInProgressRootDidSkipSuspendedSiblings);
+          return;
+        }
+        var current = completedWork.alternate;
+        unitOfWork = completedWork.return;
+        startProfilerTimer(completedWork);
+        current = runWithFiberInDEV(completedWork, completeWork, current, completedWork, entangledRenderLanes);
+        0 !== (completedWork.mode & 2) && stopProfilerTimerIfRunningAndRecordIncompleteDuration(completedWork);
+        if (null !== current) {
+          workInProgress = current;
+          return;
+        }
+        completedWork = completedWork.sibling;
+        if (null !== completedWork) {
+          workInProgress = completedWork;
+          return;
+        }
+        workInProgress = completedWork = unitOfWork;
+      } while (null !== completedWork);
+      workInProgressRootExitStatus === RootInProgress && (workInProgressRootExitStatus = RootCompleted);
+    }
+    function unwindUnitOfWork(unitOfWork, skipSiblings) {
+      do {
+        var next = unwindWork(unitOfWork.alternate, unitOfWork);
+        if (null !== next) {
+          next.flags &= 32767;
+          workInProgress = next;
+          return;
+        }
+        if (0 !== (unitOfWork.mode & 2)) {
+          stopProfilerTimerIfRunningAndRecordIncompleteDuration(unitOfWork);
+          next = unitOfWork.actualDuration;
+          for (var child = unitOfWork.child; null !== child;) next += child.actualDuration, child = child.sibling;
+          unitOfWork.actualDuration = next;
+        }
+        next = unitOfWork.return;
+        null !== next && (next.flags |= 32768, next.subtreeFlags = 0, next.deletions = null);
+        if (!skipSiblings && (unitOfWork = unitOfWork.sibling, null !== unitOfWork)) {
+          workInProgress = unitOfWork;
+          return;
+        }
+        workInProgress = unitOfWork = next;
+      } while (null !== unitOfWork);
+      workInProgressRootExitStatus = RootSuspendedAtTheShell;
+      workInProgress = null;
+    }
+    function commitRoot(root, finishedWork, lanes, recoverableErrors, transitions, didIncludeRenderPhaseUpdate, spawnedLane, updatedLanes, suspendedRetryLanes) {
+      root.cancelPendingCommit = null;
+      do flushPendingEffects(); while (pendingEffectsStatus !== NO_PENDING_EFFECTS);
+      ReactStrictModeWarnings.flushLegacyContextWarning();
+      ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();
+      if ((executionContext & (RenderContext | CommitContext)) !== NoContext) throw Error("Should not already be working.");
+      null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markCommitStarted && injectedProfilingHooks.markCommitStarted(lanes);
+      if (null === finishedWork) markCommitStopped();else {
+        0 === lanes && console.error("finishedLanes should not be empty during a commit. This is a bug in React.");
+        if (finishedWork === root.current) throw Error("Cannot commit the same tree as before. This error is likely caused by a bug in React. Please file an issue.");
+        didIncludeRenderPhaseUpdate = finishedWork.lanes | finishedWork.childLanes;
+        didIncludeRenderPhaseUpdate |= concurrentlyUpdatedLanes;
+        markRootFinished(root, lanes, didIncludeRenderPhaseUpdate, spawnedLane, updatedLanes, suspendedRetryLanes);
+        root === workInProgressRoot && (workInProgress = workInProgressRoot = null, workInProgressRootRenderLanes = 0);
+        pendingFinishedWork = finishedWork;
+        pendingEffectsRoot = root;
+        pendingEffectsLanes = lanes;
+        pendingEffectsRemainingLanes = didIncludeRenderPhaseUpdate;
+        pendingPassiveTransitions = transitions;
+        pendingRecoverableErrors = recoverableErrors;
+        0 !== (finishedWork.subtreeFlags & 10256) || 0 !== (finishedWork.flags & 10256) ? (root.callbackNode = null, root.callbackPriority = 0, scheduleCallback(NormalPriority$1, function () {
+          flushPassiveEffects(!0);
+          return null;
+        })) : (root.callbackNode = null, root.callbackPriority = 0);
+        commitStartTime = now();
+        recoverableErrors = 0 !== (finishedWork.flags & 13878);
+        if (0 !== (finishedWork.subtreeFlags & 13878) || recoverableErrors) {
+          recoverableErrors = ReactSharedInternals.T;
+          ReactSharedInternals.T = null;
+          transitions = currentUpdatePriority;
+          currentUpdatePriority = DiscreteEventPriority;
+          spawnedLane = executionContext;
+          executionContext |= CommitContext;
+          try {
+            commitBeforeMutationEffects(root, finishedWork, lanes);
+          } finally {
+            executionContext = spawnedLane, currentUpdatePriority = transitions, ReactSharedInternals.T = recoverableErrors;
+          }
+        }
+        pendingEffectsStatus = PENDING_MUTATION_PHASE;
+        flushMutationEffects();
+        flushLayoutEffects();
+        flushSpawnedWork();
+      }
+    }
+    function flushMutationEffects() {
+      if (pendingEffectsStatus === PENDING_MUTATION_PHASE) {
+        pendingEffectsStatus = NO_PENDING_EFFECTS;
+        var root = pendingEffectsRoot,
+          finishedWork = pendingFinishedWork,
+          lanes = pendingEffectsLanes,
+          rootMutationHasEffect = 0 !== (finishedWork.flags & 13878);
+        if (0 !== (finishedWork.subtreeFlags & 13878) || rootMutationHasEffect) {
+          rootMutationHasEffect = ReactSharedInternals.T;
+          ReactSharedInternals.T = null;
+          var previousPriority = currentUpdatePriority;
+          currentUpdatePriority = DiscreteEventPriority;
+          var prevExecutionContext = executionContext;
+          executionContext |= CommitContext;
+          try {
+            inProgressLanes = lanes, inProgressRoot = root, commitMutationEffectsOnFiber(finishedWork, root), inProgressRoot = inProgressLanes = null;
+          } finally {
+            executionContext = prevExecutionContext, currentUpdatePriority = previousPriority, ReactSharedInternals.T = rootMutationHasEffect;
+          }
+        }
+        root.current = finishedWork;
+        pendingEffectsStatus = PENDING_LAYOUT_PHASE;
+      }
+    }
+    function flushLayoutEffects() {
+      if (pendingEffectsStatus === PENDING_LAYOUT_PHASE) {
+        pendingEffectsStatus = NO_PENDING_EFFECTS;
+        var root = pendingEffectsRoot,
+          finishedWork = pendingFinishedWork,
+          lanes = pendingEffectsLanes,
+          rootHasLayoutEffect = 0 !== (finishedWork.flags & 8772);
+        if (0 !== (finishedWork.subtreeFlags & 8772) || rootHasLayoutEffect) {
+          rootHasLayoutEffect = ReactSharedInternals.T;
+          ReactSharedInternals.T = null;
+          var previousPriority = currentUpdatePriority;
+          currentUpdatePriority = DiscreteEventPriority;
+          var prevExecutionContext = executionContext;
+          executionContext |= CommitContext;
+          try {
+            null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markLayoutEffectsStarted && injectedProfilingHooks.markLayoutEffectsStarted(lanes), inProgressLanes = lanes, inProgressRoot = root, commitLayoutEffectOnFiber(root, finishedWork.alternate, finishedWork), inProgressRoot = inProgressLanes = null, null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markLayoutEffectsStopped && injectedProfilingHooks.markLayoutEffectsStopped();
+          } finally {
+            executionContext = prevExecutionContext, currentUpdatePriority = previousPriority, ReactSharedInternals.T = rootHasLayoutEffect;
+          }
+        }
+        pendingEffectsStatus = PENDING_AFTER_MUTATION_PHASE;
+      }
+    }
+    function flushSpawnedWork() {
+      if (pendingEffectsStatus === PENDING_SPAWNED_WORK || pendingEffectsStatus === PENDING_AFTER_MUTATION_PHASE) {
+        pendingEffectsStatus = NO_PENDING_EFFECTS;
+        requestPaint();
+        var root = pendingEffectsRoot,
+          finishedWork = pendingFinishedWork,
+          lanes = pendingEffectsLanes,
+          recoverableErrors = pendingRecoverableErrors,
+          rootDidHavePassiveEffects = 0 !== (finishedWork.subtreeFlags & 10256) || 0 !== (finishedWork.flags & 10256);
+        rootDidHavePassiveEffects ? pendingEffectsStatus = PENDING_PASSIVE_PHASE : (pendingEffectsStatus = NO_PENDING_EFFECTS, pendingFinishedWork = pendingEffectsRoot = null, releaseRootPooledCache(root, root.pendingLanes), nestedPassiveUpdateCount = 0, rootWithPassiveNestedUpdates = null);
+        var remainingLanes = root.pendingLanes;
+        0 === remainingLanes && (legacyErrorBoundariesThatAlreadyFailed = null);
+        rootDidHavePassiveEffects || commitDoubleInvokeEffectsInDEV(root, !1);
+        rootDidHavePassiveEffects = lanesToEventPriority(lanes);
+        finishedWork = finishedWork.stateNode;
+        if (injectedHook && "function" === typeof injectedHook.onCommitFiberRoot) try {
+          var didError = 128 === (finishedWork.current.flags & 128);
+          switch (rootDidHavePassiveEffects) {
+            case DiscreteEventPriority:
+              var schedulerPriority = ImmediatePriority;
+              break;
+            case ContinuousEventPriority:
+              schedulerPriority = UserBlockingPriority;
+              break;
+            case DefaultEventPriority:
+              schedulerPriority = NormalPriority$1;
+              break;
+            case IdleEventPriority:
+              schedulerPriority = IdlePriority;
+              break;
+            default:
+              schedulerPriority = NormalPriority$1;
+          }
+          injectedHook.onCommitFiberRoot(rendererID, finishedWork, schedulerPriority, didError);
+        } catch (err) {
+          hasLoggedError || (hasLoggedError = !0, console.error("React instrumentation encountered an error: %s", err));
+        }
+        isDevToolsPresent && root.memoizedUpdaters.clear();
+        if (null !== recoverableErrors) {
+          didError = ReactSharedInternals.T;
+          schedulerPriority = currentUpdatePriority;
+          currentUpdatePriority = DiscreteEventPriority;
+          ReactSharedInternals.T = null;
+          try {
+            var onRecoverableError = root.onRecoverableError;
+            for (finishedWork = 0; finishedWork < recoverableErrors.length; finishedWork++) {
+              var recoverableError = recoverableErrors[finishedWork],
+                errorInfo = makeErrorInfo(recoverableError.stack);
+              runWithFiberInDEV(recoverableError.source, onRecoverableError, recoverableError.value, errorInfo);
+            }
+          } finally {
+            ReactSharedInternals.T = didError, currentUpdatePriority = schedulerPriority;
+          }
+        }
+        0 !== (pendingEffectsLanes & 3) && 0 !== root.tag && flushPendingEffects();
+        ensureRootIsScheduled(root);
+        remainingLanes = root.pendingLanes;
+        0 !== (lanes & 4194090) && 0 !== (remainingLanes & 42) ? (nestedUpdateScheduled = !0, root === rootWithNestedUpdates ? nestedUpdateCount++ : (nestedUpdateCount = 0, rootWithNestedUpdates = root)) : nestedUpdateCount = 0;
+        flushSyncWorkAcrossRoots_impl(0, !1);
+        markCommitStopped();
+      }
+    }
+    function makeErrorInfo(componentStack) {
+      componentStack = {
+        componentStack: componentStack
+      };
+      Object.defineProperty(componentStack, "digest", {
+        get: function get() {
+          console.error('You are accessing "digest" from the errorInfo object passed to onRecoverableError. This property is no longer provided as part of errorInfo but can be accessed as a property of the Error instance itself.');
+        }
+      });
+      return componentStack;
+    }
+    function releaseRootPooledCache(root, remainingLanes) {
+      0 === (root.pooledCacheLanes &= remainingLanes) && (remainingLanes = root.pooledCache, null != remainingLanes && (root.pooledCache = null, releaseCache(remainingLanes)));
+    }
+    function flushPendingEffects(wasDelayedCommit) {
+      flushMutationEffects();
+      flushLayoutEffects();
+      flushSpawnedWork();
+      return flushPassiveEffects(wasDelayedCommit);
+    }
+    function flushPassiveEffects() {
+      if (pendingEffectsStatus !== PENDING_PASSIVE_PHASE) return !1;
+      var root = pendingEffectsRoot,
+        remainingLanes = pendingEffectsRemainingLanes;
+      pendingEffectsRemainingLanes = 0;
+      var renderPriority = lanesToEventPriority(pendingEffectsLanes),
+        priority = 0 === DefaultEventPriority || DefaultEventPriority > renderPriority ? DefaultEventPriority : renderPriority;
+      renderPriority = ReactSharedInternals.T;
+      var previousPriority = currentUpdatePriority;
+      try {
+        currentUpdatePriority = priority;
+        ReactSharedInternals.T = null;
+        priority = pendingPassiveTransitions;
+        pendingPassiveTransitions = null;
+        var root$jscomp$0 = pendingEffectsRoot,
+          lanes = pendingEffectsLanes;
+        pendingEffectsStatus = NO_PENDING_EFFECTS;
+        pendingFinishedWork = pendingEffectsRoot = null;
+        pendingEffectsLanes = 0;
+        if ((executionContext & (RenderContext | CommitContext)) !== NoContext) throw Error("Cannot flush passive effects while already rendering.");
+        isFlushingPassiveEffects = !0;
+        didScheduleUpdateDuringPassiveEffects = !1;
+        null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markPassiveEffectsStarted && injectedProfilingHooks.markPassiveEffectsStarted(lanes);
+        var prevExecutionContext = executionContext;
+        executionContext |= CommitContext;
+        commitPassiveUnmountOnFiber(root$jscomp$0.current);
+        commitPassiveMountOnFiber(root$jscomp$0, root$jscomp$0.current, lanes, priority);
+        null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markPassiveEffectsStopped && injectedProfilingHooks.markPassiveEffectsStopped();
+        commitDoubleInvokeEffectsInDEV(root$jscomp$0, !0);
+        executionContext = prevExecutionContext;
+        flushSyncWorkAcrossRoots_impl(0, !1);
+        didScheduleUpdateDuringPassiveEffects ? root$jscomp$0 === rootWithPassiveNestedUpdates ? nestedPassiveUpdateCount++ : (nestedPassiveUpdateCount = 0, rootWithPassiveNestedUpdates = root$jscomp$0) : nestedPassiveUpdateCount = 0;
+        didScheduleUpdateDuringPassiveEffects = isFlushingPassiveEffects = !1;
+        if (injectedHook && "function" === typeof injectedHook.onPostCommitFiberRoot) try {
+          injectedHook.onPostCommitFiberRoot(rendererID, root$jscomp$0);
+        } catch (err) {
+          hasLoggedError || (hasLoggedError = !0, console.error("React instrumentation encountered an error: %s", err));
+        }
+        var stateNode = root$jscomp$0.current.stateNode;
+        stateNode.effectDuration = 0;
+        stateNode.passiveEffectDuration = 0;
+        return !0;
+      } finally {
+        currentUpdatePriority = previousPriority, ReactSharedInternals.T = renderPriority, releaseRootPooledCache(root, remainingLanes);
+      }
+    }
+    function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
+      sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
+      sourceFiber = createRootErrorUpdate(rootFiber.stateNode, sourceFiber, 2);
+      rootFiber = enqueueUpdate(rootFiber, sourceFiber, 2);
+      null !== rootFiber && (markRootUpdated$1(rootFiber, 2), ensureRootIsScheduled(rootFiber));
+    }
+    function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {
+      isRunningInsertionEffect = !1;
+      if (3 === sourceFiber.tag) captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);else {
+        for (; null !== nearestMountedAncestor;) {
+          if (3 === nearestMountedAncestor.tag) {
+            captureCommitPhaseErrorOnRoot(nearestMountedAncestor, sourceFiber, error);
+            return;
+          }
+          if (1 === nearestMountedAncestor.tag) {
+            var instance = nearestMountedAncestor.stateNode;
+            if ("function" === typeof nearestMountedAncestor.type.getDerivedStateFromError || "function" === typeof instance.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(instance))) {
+              sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
+              error = createClassErrorUpdate(2);
+              instance = enqueueUpdate(nearestMountedAncestor, error, 2);
+              null !== instance && (initializeClassErrorUpdate(error, instance, nearestMountedAncestor, sourceFiber), markRootUpdated$1(instance, 2), ensureRootIsScheduled(instance));
+              return;
+            }
+          }
+          nearestMountedAncestor = nearestMountedAncestor.return;
+        }
+        console.error("Internal React error: Attempted to capture a commit phase error inside a detached tree. This indicates a bug in React. Potential causes include deleting the same fiber more than once, committing an already-finished tree, or an inconsistent return pointer.\n\nError message:\n\n%s", error);
+      }
+    }
+    function attachPingListener(root, wakeable, lanes) {
+      var pingCache = root.pingCache;
+      if (null === pingCache) {
+        pingCache = root.pingCache = new PossiblyWeakMap();
+        var threadIDs = new Set();
+        pingCache.set(wakeable, threadIDs);
+      } else threadIDs = pingCache.get(wakeable), void 0 === threadIDs && (threadIDs = new Set(), pingCache.set(wakeable, threadIDs));
+      threadIDs.has(lanes) || (workInProgressRootDidAttachPingListener = !0, threadIDs.add(lanes), pingCache = pingSuspendedRoot.bind(null, root, wakeable, lanes), isDevToolsPresent && restorePendingUpdaters(root, lanes), wakeable.then(pingCache, pingCache));
+    }
+    function pingSuspendedRoot(root, wakeable, pingedLanes) {
+      var pingCache = root.pingCache;
+      null !== pingCache && pingCache.delete(wakeable);
+      root.pingedLanes |= root.suspendedLanes & pingedLanes;
+      root.warmLanes &= ~pingedLanes;
+      0 !== root.tag && isConcurrentActEnvironment() && null === ReactSharedInternals.actQueue && console.error("A suspended resource finished loading inside a test, but the event was not wrapped in act(...).\n\nWhen testing, code that resolves suspended data should be wrapped into act(...):\n\nact(() => {\n  /* finish loading suspended data */\n});\n/* assert on the output */\n\nThis ensures that you're testing the behavior the user would see in the browser. Learn more at https://react.dev/link/wrap-tests-with-act");
+      workInProgressRoot === root && (workInProgressRootRenderLanes & pingedLanes) === pingedLanes && (workInProgressRootExitStatus === RootSuspendedWithDelay || workInProgressRootExitStatus === RootSuspended && (workInProgressRootRenderLanes & 62914560) === workInProgressRootRenderLanes && now$1() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS ? (executionContext & RenderContext) === NoContext && prepareFreshStack(root, 0) : workInProgressRootPingedLanes |= pingedLanes, workInProgressSuspendedRetryLanes === workInProgressRootRenderLanes && (workInProgressSuspendedRetryLanes = 0));
+      ensureRootIsScheduled(root);
+    }
+    function retryTimedOutBoundary(boundaryFiber, retryLane) {
+      0 === retryLane && (retryLane = 0 === (boundaryFiber.mode & 1) ? 2 : claimNextRetryLane());
+      boundaryFiber = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
+      null !== boundaryFiber && (markRootUpdated$1(boundaryFiber, retryLane), ensureRootIsScheduled(boundaryFiber));
+    }
+    function retryDehydratedSuspenseBoundary(boundaryFiber) {
+      var suspenseState = boundaryFiber.memoizedState,
+        retryLane = 0;
+      null !== suspenseState && (retryLane = suspenseState.retryLane);
+      retryTimedOutBoundary(boundaryFiber, retryLane);
+    }
+    function resolveRetryWakeable(boundaryFiber, wakeable) {
+      var retryLane = 0;
+      switch (boundaryFiber.tag) {
+        case 13:
+          var retryCache = boundaryFiber.stateNode;
+          var suspenseState = boundaryFiber.memoizedState;
+          null !== suspenseState && (retryLane = suspenseState.retryLane);
+          break;
+        case 19:
+          retryCache = boundaryFiber.stateNode;
+          break;
+        case 22:
+          retryCache = boundaryFiber.stateNode._retryCache;
+          break;
+        default:
+          throw Error("Pinged unknown suspense boundary type. This is probably a bug in React.");
+      }
+      null !== retryCache && retryCache.delete(wakeable);
+      retryTimedOutBoundary(boundaryFiber, retryLane);
+    }
+    function recursivelyTraverseAndDoubleInvokeEffectsInDEV(root$jscomp$0, parentFiber, isInStrictMode) {
+      if (0 !== (parentFiber.subtreeFlags & 67117056)) for (parentFiber = parentFiber.child; null !== parentFiber;) {
+        var root = root$jscomp$0,
+          fiber = parentFiber,
+          isStrictModeFiber = fiber.type === REACT_STRICT_MODE_TYPE;
+        isStrictModeFiber = isInStrictMode || isStrictModeFiber;
+        22 !== fiber.tag ? fiber.flags & 67108864 ? isStrictModeFiber && runWithFiberInDEV(fiber, doubleInvokeEffectsOnFiber, root, fiber, 0 === (fiber.mode & 64)) : recursivelyTraverseAndDoubleInvokeEffectsInDEV(root, fiber, isStrictModeFiber) : null === fiber.memoizedState && (isStrictModeFiber && fiber.flags & 8192 ? runWithFiberInDEV(fiber, doubleInvokeEffectsOnFiber, root, fiber) : fiber.subtreeFlags & 67108864 && runWithFiberInDEV(fiber, recursivelyTraverseAndDoubleInvokeEffectsInDEV, root, fiber, isStrictModeFiber));
+        parentFiber = parentFiber.sibling;
+      }
+    }
+    function doubleInvokeEffectsOnFiber(root, fiber) {
+      var shouldDoubleInvokePassiveEffects = 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : !0;
+      setIsStrictModeForDevtools(!0);
+      try {
+        disappearLayoutEffects(fiber), shouldDoubleInvokePassiveEffects && disconnectPassiveEffect(fiber), reappearLayoutEffects(root, fiber.alternate, fiber, !1), shouldDoubleInvokePassiveEffects && reconnectPassiveEffects(root, fiber, 0, null, !1, 0);
+      } finally {
+        setIsStrictModeForDevtools(!1);
+      }
+    }
+    function commitDoubleInvokeEffectsInDEV(root, hasPassiveEffects) {
+      0 !== root.tag ? (hasPassiveEffects = !0, 1 !== root.tag || root.current.mode & (StrictLegacyMode | 16) || (hasPassiveEffects = !1), recursivelyTraverseAndDoubleInvokeEffectsInDEV(root, root.current, hasPassiveEffects)) : runWithFiberInDEV(root.current, legacyCommitDoubleInvokeEffectsInDEV, root.current, hasPassiveEffects);
+    }
+    function legacyCommitDoubleInvokeEffectsInDEV(fiber, hasPassiveEffects) {
+      invokeEffectsInDev(fiber, 134217728, invokeLayoutEffectUnmountInDEV);
+      hasPassiveEffects && invokeEffectsInDev(fiber, 268435456, invokePassiveEffectUnmountInDEV);
+      invokeEffectsInDev(fiber, 134217728, invokeLayoutEffectMountInDEV);
+      hasPassiveEffects && invokeEffectsInDev(fiber, 268435456, invokePassiveEffectMountInDEV);
+    }
+    function invokeEffectsInDev(firstChild, fiberFlags, invokeEffectFn) {
+      for (var subtreeRoot = null; null != firstChild;) {
+        var primarySubtreeFlag = firstChild.subtreeFlags & fiberFlags;
+        firstChild !== subtreeRoot && null != firstChild.child && 0 !== primarySubtreeFlag ? firstChild = firstChild.child : (0 !== (firstChild.flags & fiberFlags) && invokeEffectFn(firstChild), firstChild = null !== firstChild.sibling ? firstChild.sibling : subtreeRoot = firstChild.return);
+      }
+    }
+    function warnAboutUpdateOnNotYetMountedFiberInDEV(fiber) {
+      if ((executionContext & RenderContext) === NoContext && fiber.mode & 1) {
+        var tag = fiber.tag;
+        if (3 === tag || 1 === tag || 0 === tag || 11 === tag || 14 === tag || 15 === tag) {
+          tag = getComponentNameFromFiber(fiber) || "ReactComponent";
+          if (null !== didWarnStateUpdateForNotYetMountedComponent) {
+            if (didWarnStateUpdateForNotYetMountedComponent.has(tag)) return;
+            didWarnStateUpdateForNotYetMountedComponent.add(tag);
+          } else didWarnStateUpdateForNotYetMountedComponent = new Set([tag]);
+          runWithFiberInDEV(fiber, function () {
+            console.error("Can't perform a React state update on a component that hasn't mounted yet. This indicates that you have a side-effect in your render function that asynchronously later calls tries to update the component. Move this work to useEffect instead.");
+          });
+        }
+      }
+    }
+    function restorePendingUpdaters(root, lanes) {
+      isDevToolsPresent && root.memoizedUpdaters.forEach(function (schedulingFiber) {
+        addFiberToLanesMap(root, schedulingFiber, lanes);
+      });
+    }
+    function scheduleCallback(priorityLevel, callback) {
+      var actQueue = ReactSharedInternals.actQueue;
+      return null !== actQueue ? (actQueue.push(callback), fakeActCallbackNode) : scheduleCallback$3(priorityLevel, callback);
+    }
+    function warnIfUpdatesNotWrappedWithActDEV(fiber) {
+      if (fiber.mode & 1) {
+        if (!isConcurrentActEnvironment()) return;
+      } else if (!isLegacyActEnvironment() || executionContext !== NoContext || 0 !== fiber.tag && 11 !== fiber.tag && 15 !== fiber.tag) return;
+      null === ReactSharedInternals.actQueue && runWithFiberInDEV(fiber, function () {
+        console.error("An update to %s inside a test was not wrapped in act(...).\n\nWhen testing, code that causes React state updates should be wrapped into act(...):\n\nact(() => {\n  /* fire events that update state */\n});\n/* assert on the output */\n\nThis ensures that you're testing the behavior the user would see in the browser. Learn more at https://react.dev/link/wrap-tests-with-act", getComponentNameFromFiber(fiber));
+      });
+    }
+    function resolveFunctionForHotReloading(type) {
+      if (null === resolveFamily) return type;
+      var family = resolveFamily(type);
+      return void 0 === family ? type : family.current;
+    }
+    function resolveForwardRefForHotReloading(type) {
+      if (null === resolveFamily) return type;
+      var family = resolveFamily(type);
+      return void 0 === family ? null !== type && void 0 !== type && "function" === typeof type.render && (family = resolveFunctionForHotReloading(type.render), type.render !== family) ? (family = {
+        $$typeof: REACT_FORWARD_REF_TYPE,
+        render: family
+      }, void 0 !== type.displayName && (family.displayName = type.displayName), family) : type : family.current;
+    }
+    function isCompatibleFamilyForHotReloading(fiber, element) {
+      if (null === resolveFamily) return !1;
+      var prevType = fiber.elementType;
+      element = element.type;
+      var needsCompareFamilies = !1,
+        $$typeofNextType = "object" === typeof element && null !== element ? element.$$typeof : null;
+      switch (fiber.tag) {
+        case 1:
+          "function" === typeof element && (needsCompareFamilies = !0);
+          break;
+        case 0:
+          "function" === typeof element ? needsCompareFamilies = !0 : $$typeofNextType === REACT_LAZY_TYPE && (needsCompareFamilies = !0);
+          break;
+        case 11:
+          $$typeofNextType === REACT_FORWARD_REF_TYPE ? needsCompareFamilies = !0 : $$typeofNextType === REACT_LAZY_TYPE && (needsCompareFamilies = !0);
+          break;
+        case 14:
+        case 15:
+          $$typeofNextType === REACT_MEMO_TYPE ? needsCompareFamilies = !0 : $$typeofNextType === REACT_LAZY_TYPE && (needsCompareFamilies = !0);
+          break;
+        default:
+          return !1;
+      }
+      return needsCompareFamilies && (fiber = resolveFamily(prevType), void 0 !== fiber && fiber === resolveFamily(element)) ? !0 : !1;
+    }
+    function markFailedErrorBoundaryForHotReloading(fiber) {
+      null !== resolveFamily && "function" === typeof WeakSet && (null === failedBoundaries && (failedBoundaries = new WeakSet()), failedBoundaries.add(fiber));
+    }
+    function scheduleFibersWithFamiliesRecursively(fiber, updatedFamilies, staleFamilies) {
+      var alternate = fiber.alternate,
+        child = fiber.child,
+        sibling = fiber.sibling,
+        tag = fiber.tag,
+        type = fiber.type,
+        candidateType = null;
+      switch (tag) {
+        case 0:
+        case 15:
+        case 1:
+          candidateType = type;
+          break;
+        case 11:
+          candidateType = type.render;
+      }
+      if (null === resolveFamily) throw Error("Expected resolveFamily to be set during hot reload.");
+      var needsRender = !1;
+      type = !1;
+      null !== candidateType && (candidateType = resolveFamily(candidateType), void 0 !== candidateType && (staleFamilies.has(candidateType) ? type = !0 : updatedFamilies.has(candidateType) && (1 === tag ? type = !0 : needsRender = !0)));
+      null !== failedBoundaries && (failedBoundaries.has(fiber) || null !== alternate && failedBoundaries.has(alternate)) && (type = !0);
+      type && (fiber._debugNeedsRemount = !0);
+      if (type || needsRender) alternate = enqueueConcurrentRenderForLane(fiber, 2), null !== alternate && scheduleUpdateOnFiber(alternate, fiber, 2);
+      null === child || type || scheduleFibersWithFamiliesRecursively(child, updatedFamilies, staleFamilies);
+      null !== sibling && scheduleFibersWithFamiliesRecursively(sibling, updatedFamilies, staleFamilies);
+    }
+    function FiberNode(tag, pendingProps, key, mode) {
+      this.tag = tag;
+      this.key = key;
+      this.sibling = this.child = this.return = this.stateNode = this.type = this.elementType = null;
+      this.index = 0;
+      this.refCleanup = this.ref = null;
+      this.pendingProps = pendingProps;
+      this.dependencies = this.memoizedState = this.updateQueue = this.memoizedProps = null;
+      this.mode = mode;
+      this.subtreeFlags = this.flags = 0;
+      this.deletions = null;
+      this.childLanes = this.lanes = 0;
+      this.alternate = null;
+      this.actualDuration = -0;
+      this.actualStartTime = -1.1;
+      this.treeBaseDuration = this.selfBaseDuration = -0;
+      this._debugTask = this._debugStack = this._debugOwner = this._debugInfo = null;
+      this._debugNeedsRemount = !1;
+      this._debugHookTypes = null;
+      hasBadMapPolyfill || "function" !== typeof Object.preventExtensions || Object.preventExtensions(this);
+    }
+    function shouldConstruct(Component) {
+      Component = Component.prototype;
+      return !(!Component || !Component.isReactComponent);
+    }
+    function createWorkInProgress(current, pendingProps) {
+      var workInProgress = current.alternate;
+      null === workInProgress ? (workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode), workInProgress.elementType = current.elementType, workInProgress.type = current.type, workInProgress.stateNode = current.stateNode, workInProgress._debugOwner = current._debugOwner, workInProgress._debugStack = current._debugStack, workInProgress._debugTask = current._debugTask, workInProgress._debugHookTypes = current._debugHookTypes, workInProgress.alternate = current, current.alternate = workInProgress) : (workInProgress.pendingProps = pendingProps, workInProgress.type = current.type, workInProgress.flags = 0, workInProgress.subtreeFlags = 0, workInProgress.deletions = null, workInProgress.actualDuration = -0, workInProgress.actualStartTime = -1.1);
+      workInProgress.flags = current.flags & 65011712;
+      workInProgress.childLanes = current.childLanes;
+      workInProgress.lanes = current.lanes;
+      workInProgress.child = current.child;
+      workInProgress.memoizedProps = current.memoizedProps;
+      workInProgress.memoizedState = current.memoizedState;
+      workInProgress.updateQueue = current.updateQueue;
+      pendingProps = current.dependencies;
+      workInProgress.dependencies = null === pendingProps ? null : {
+        lanes: pendingProps.lanes,
+        firstContext: pendingProps.firstContext,
+        _debugThenableState: pendingProps._debugThenableState
+      };
+      workInProgress.sibling = current.sibling;
+      workInProgress.index = current.index;
+      workInProgress.ref = current.ref;
+      workInProgress.refCleanup = current.refCleanup;
+      workInProgress.selfBaseDuration = current.selfBaseDuration;
+      workInProgress.treeBaseDuration = current.treeBaseDuration;
+      workInProgress._debugInfo = current._debugInfo;
+      workInProgress._debugNeedsRemount = current._debugNeedsRemount;
+      switch (workInProgress.tag) {
+        case 0:
+        case 15:
+          workInProgress.type = resolveFunctionForHotReloading(current.type);
+          break;
+        case 1:
+          workInProgress.type = resolveFunctionForHotReloading(current.type);
+          break;
+        case 11:
+          workInProgress.type = resolveForwardRefForHotReloading(current.type);
+      }
+      return workInProgress;
+    }
+    function resetWorkInProgress(workInProgress, renderLanes) {
+      workInProgress.flags &= 65011714;
+      var current = workInProgress.alternate;
+      null === current ? (workInProgress.childLanes = 0, workInProgress.lanes = renderLanes, workInProgress.child = null, workInProgress.subtreeFlags = 0, workInProgress.memoizedProps = null, workInProgress.memoizedState = null, workInProgress.updateQueue = null, workInProgress.dependencies = null, workInProgress.stateNode = null, workInProgress.selfBaseDuration = 0, workInProgress.treeBaseDuration = 0) : (workInProgress.childLanes = current.childLanes, workInProgress.lanes = current.lanes, workInProgress.child = current.child, workInProgress.subtreeFlags = 0, workInProgress.deletions = null, workInProgress.memoizedProps = current.memoizedProps, workInProgress.memoizedState = current.memoizedState, workInProgress.updateQueue = current.updateQueue, workInProgress.type = current.type, renderLanes = current.dependencies, workInProgress.dependencies = null === renderLanes ? null : {
+        lanes: renderLanes.lanes,
+        firstContext: renderLanes.firstContext,
+        _debugThenableState: renderLanes._debugThenableState
+      }, workInProgress.selfBaseDuration = current.selfBaseDuration, workInProgress.treeBaseDuration = current.treeBaseDuration);
+      return workInProgress;
+    }
+    function createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, lanes) {
+      var fiberTag = 0,
+        resolvedType = type;
+      if ("function" === typeof type) shouldConstruct(type) && (fiberTag = 1), resolvedType = resolveFunctionForHotReloading(resolvedType);else if ("string" === typeof type) fiberTag = 5;else a: switch (type) {
+        case REACT_ACTIVITY_TYPE:
+          return key = createFiber(31, pendingProps, key, mode), key.elementType = REACT_ACTIVITY_TYPE, key.lanes = lanes, key;
+        case REACT_FRAGMENT_TYPE:
+          return createFiberFromFragment(pendingProps.children, mode, lanes, key);
+        case REACT_STRICT_MODE_TYPE:
+          fiberTag = 8;
+          mode |= StrictLegacyMode;
+          0 !== (mode & 1) && (mode |= 16);
+          break;
+        case REACT_PROFILER_TYPE:
+          return type = pendingProps, owner = mode, "string" !== typeof type.id && console.error('Profiler must specify an "id" of type `string` as a prop. Received the type `%s` instead.', typeof type.id), key = createFiber(12, type, key, owner | 2), key.elementType = REACT_PROFILER_TYPE, key.lanes = lanes, key.stateNode = {
+            effectDuration: 0,
+            passiveEffectDuration: 0
+          }, key;
+        case REACT_SUSPENSE_TYPE:
+          return key = createFiber(13, pendingProps, key, mode), key.elementType = REACT_SUSPENSE_TYPE, key.lanes = lanes, key;
+        case REACT_SUSPENSE_LIST_TYPE:
+          return key = createFiber(19, pendingProps, key, mode), key.elementType = REACT_SUSPENSE_LIST_TYPE, key.lanes = lanes, key;
+        default:
+          if ("object" === typeof type && null !== type) switch (type.$$typeof) {
+            case REACT_PROVIDER_TYPE:
+            case REACT_CONTEXT_TYPE:
+              fiberTag = 10;
+              break a;
+            case REACT_CONSUMER_TYPE:
+              fiberTag = 9;
+              break a;
+            case REACT_FORWARD_REF_TYPE:
+              fiberTag = 11;
+              resolvedType = resolveForwardRefForHotReloading(resolvedType);
+              break a;
+            case REACT_MEMO_TYPE:
+              fiberTag = 14;
+              break a;
+            case REACT_LAZY_TYPE:
+              fiberTag = 16;
+              resolvedType = null;
+              break a;
+          }
+          resolvedType = "";
+          if (void 0 === type || "object" === typeof type && null !== type && 0 === Object.keys(type).length) resolvedType += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.";
+          null === type ? pendingProps = "null" : isArrayImpl(type) ? pendingProps = "array" : void 0 !== type && type.$$typeof === REACT_ELEMENT_TYPE ? (pendingProps = "<" + (getComponentNameFromType(type.type) || "Unknown") + " />", resolvedType = " Did you accidentally export a JSX literal instead of a component?") : pendingProps = typeof type;
+          fiberTag = owner ? "number" === typeof owner.tag ? getComponentNameFromFiber(owner) : "string" === typeof owner.name ? owner.name : null : null;
+          fiberTag && (resolvedType += "\n\nCheck the render method of `" + fiberTag + "`.");
+          fiberTag = 29;
+          pendingProps = Error("Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: " + (pendingProps + "." + resolvedType));
+          resolvedType = null;
+      }
+      key = createFiber(fiberTag, pendingProps, key, mode);
+      key.elementType = type;
+      key.type = resolvedType;
+      key.lanes = lanes;
+      key._debugOwner = owner;
+      return key;
+    }
+    function createFiberFromElement(element, mode, lanes) {
+      mode = createFiberFromTypeAndProps(element.type, element.key, element.props, element._owner, mode, lanes);
+      mode._debugOwner = element._owner;
+      mode._debugStack = element._debugStack;
+      mode._debugTask = element._debugTask;
+      return mode;
+    }
+    function createFiberFromFragment(elements, mode, lanes, key) {
+      elements = createFiber(7, elements, key, mode);
+      elements.lanes = lanes;
+      return elements;
+    }
+    function createFiberFromText(content, mode, lanes) {
+      content = createFiber(6, content, null, mode);
+      content.lanes = lanes;
+      return content;
+    }
+    function createFiberFromPortal(portal, mode, lanes) {
+      mode = createFiber(4, null !== portal.children ? portal.children : [], portal.key, mode);
+      mode.lanes = lanes;
+      mode.stateNode = {
+        containerInfo: portal.containerInfo,
+        pendingChildren: null,
+        implementation: portal.implementation
+      };
+      return mode;
+    }
+    function FiberRootNode(containerInfo, tag, hydrate, identifierPrefix, onUncaughtError, onCaughtError, onRecoverableError, formState) {
+      this.tag = tag;
+      this.containerInfo = containerInfo;
+      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 = createLaneMap(-1);
+      this.entangledLanes = this.shellSuspendCounter = this.errorRecoveryDisabledLanes = this.expiredLanes = this.warmLanes = this.pingedLanes = this.suspendedLanes = this.pendingLanes = 0;
+      this.entanglements = createLaneMap(0);
+      this.hiddenUpdates = createLaneMap(null);
+      this.identifierPrefix = identifierPrefix;
+      this.onUncaughtError = onUncaughtError;
+      this.onCaughtError = onCaughtError;
+      this.onRecoverableError = onRecoverableError;
+      this.pooledCache = null;
+      this.pooledCacheLanes = 0;
+      this.formState = formState;
+      this.incompleteTransitions = new Map();
+      this.passiveEffectDuration = this.effectDuration = -0;
+      this.memoizedUpdaters = new Set();
+      containerInfo = this.pendingUpdatersLaneMap = [];
+      for (identifierPrefix = 0; 31 > identifierPrefix; identifierPrefix++) containerInfo.push(new Set());
+      switch (tag) {
+        case 1:
+          this._debugRootType = hydrate ? "hydrateRoot()" : "createRoot()";
+          break;
+        case 0:
+          this._debugRootType = hydrate ? "hydrate()" : "render()";
+      }
+    }
+    function testStringCoercion(value) {
+      return "" + value;
+    }
+    function createPortal$1(children, containerInfo, implementation) {
+      var key = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
+      try {
+        testStringCoercion(key);
+        var JSCompiler_inline_result = !1;
+      } catch (e$6) {
+        JSCompiler_inline_result = !0;
+      }
+      JSCompiler_inline_result && (console.error("The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", "function" === typeof Symbol && Symbol.toStringTag && key[Symbol.toStringTag] || key.constructor.name || "Object"), testStringCoercion(key));
+      return {
+        $$typeof: REACT_PORTAL_TYPE,
+        key: null == key ? null : "" + key,
+        children: children,
+        containerInfo: containerInfo,
+        implementation: implementation
+      };
+    }
+    function findHostInstanceWithWarning(component, methodName) {
+      var fiber = component._reactInternals;
+      if (void 0 === fiber) {
+        if ("function" === typeof component.render) throw Error("Unable to find node on an unmounted component.");
+        component = Object.keys(component).join(",");
+        throw Error("Argument appears to not be a ReactComponent. Keys: " + component);
+      }
+      component = findCurrentHostFiber(fiber);
+      if (null === component) return null;
+      if (component.mode & StrictLegacyMode) {
+        var componentName = getComponentNameFromFiber(fiber) || "Component";
+        didWarnAboutFindNodeInStrictMode[componentName] || (didWarnAboutFindNodeInStrictMode[componentName] = !0, runWithFiberInDEV(component, function () {
+          fiber.mode & StrictLegacyMode ? console.error("%s is deprecated in StrictMode. %s was passed an instance of %s which is inside StrictMode. Instead, add a ref directly to the element you want to reference. Learn more about using refs safely here: https://react.dev/link/strict-mode-find-node", methodName, methodName, componentName) : console.error("%s is deprecated in StrictMode. %s was passed an instance of %s which renders StrictMode children. Instead, add a ref directly to the element you want to reference. Learn more about using refs safely here: https://react.dev/link/strict-mode-find-node", methodName, methodName, componentName);
+        }));
+      }
+      return getPublicInstance(component.stateNode);
+    }
+    function updateContainer(element, container, parentComponent, callback) {
+      var current = container.current,
+        lane = requestUpdateLane(current);
+      updateContainerImpl(current, lane, element, container, parentComponent, callback);
+      return lane;
+    }
+    function updateContainerImpl(rootFiber, lane, element, container, parentComponent, callback) {
+      if (injectedHook && "function" === typeof injectedHook.onScheduleFiberRoot) try {
+        injectedHook.onScheduleFiberRoot(rendererID, container, element);
+      } catch (err) {
+        hasLoggedError || (hasLoggedError = !0, console.error("React instrumentation encountered an error: %s", err));
+      }
+      null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markRenderScheduled && injectedProfilingHooks.markRenderScheduled(lane);
+      parentComponent = emptyContextObject;
+      null === container.context ? container.context = parentComponent : container.pendingContext = parentComponent;
+      isRendering && null !== current && !didWarnAboutNestedUpdates && (didWarnAboutNestedUpdates = !0, console.error("Render methods should be a pure function of props and state; triggering nested component updates from render is not allowed. If necessary, trigger nested updates in componentDidUpdate.\n\nCheck the render method of %s.", getComponentNameFromFiber(current) || "Unknown"));
+      container = createUpdate(lane);
+      container.payload = {
+        element: element
+      };
+      callback = void 0 === callback ? null : callback;
+      null !== callback && ("function" !== typeof callback && console.error("Expected the last optional `callback` argument to be a function. Instead received: %s.", callback), container.callback = callback);
+      element = enqueueUpdate(rootFiber, container, lane);
+      null !== element && (scheduleUpdateOnFiber(element, rootFiber, lane), entangleTransitions(element, rootFiber, lane));
+    }
+    function getCurrentFiberForDevTools() {
+      return current;
+    }
+    function getLaneLabelMap() {
+      for (var map = new Map(), lane = 1, index = 0; 31 > index; index++) {
+        var label = getLabelForLane(lane);
+        map.set(lane, label);
+        lane *= 2;
+      }
+      return map;
+    }
+    function nativeOnUncaughtError(error, errorInfo) {
+      !1 !== ReactNativePrivateInterface.ReactFiberErrorDialog.showErrorDialog({
+        errorBoundary: null,
+        error: error,
+        componentStack: null != errorInfo.componentStack ? errorInfo.componentStack : ""
+      }) && (reportGlobalError(error), console.warn("%s\n\n%s\n", componentName ? "An error occurred in the <" + componentName + "> component." : "An error occurred in one of your React components.", "Consider adding an error boundary to your tree to customize error handling behavior.\nVisit https://react.dev/link/error-boundaries to learn more about error boundaries."));
+    }
+    function nativeOnCaughtError(error, errorInfo) {
+      if (!1 !== ReactNativePrivateInterface.ReactFiberErrorDialog.showErrorDialog({
+        errorBoundary: errorInfo.errorBoundary,
+        error: error,
+        componentStack: null != errorInfo.componentStack ? errorInfo.componentStack : ""
+      })) {
+        var componentNameMessage = componentName ? "The above error occurred in the <" + componentName + "> component." : "The above error occurred in one of your React components.",
+          recreateMessage = "React will try to recreate this component tree from scratch using the error boundary you provided, " + ((errorBoundaryName || "Anonymous") + ".");
+        "object" === typeof error && null !== error && "string" === typeof error.environmentName ? (errorInfo = error.environmentName, error = ["%o\n\n%s\n\n%s\n", error, componentNameMessage, recreateMessage].slice(0), "string" === typeof error[0] ? error.splice(0, 1, "[%s] " + error[0], " " + errorInfo + " ") : error.splice(0, 0, "[%s] ", " " + errorInfo + " "), error.unshift(console), error = bind.apply(console.error, error), error()) : console.error("%o\n\n%s\n\n%s\n", error, componentNameMessage, recreateMessage);
+      }
+    }
+    function unmountComponentAtNode(containerTag) {
+      var root = roots.get(containerTag);
+      root && updateContainer(null, root, null, function () {
+        roots.delete(containerTag);
+      });
+    }
+    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    _$$_REQUIRE(_dependencyMap[0], "react-native/Libraries/ReactPrivate/ReactNativePrivateInitializeCore");
+    var React = _$$_REQUIRE(_dependencyMap[1], "react"),
+      ReactNativePrivateInterface = _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface"),
+      Scheduler = _$$_REQUIRE(_dependencyMap[3], "scheduler"),
+      isArrayImpl = Array.isArray,
+      ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,
+      assign = Object.assign,
+      disabledDepth = 0,
+      prevLog,
+      prevInfo,
+      prevWarn,
+      prevError,
+      prevGroup,
+      prevGroupCollapsed,
+      prevGroupEnd;
+    disabledLog.__reactDisabledLog = !0;
+    var prefix,
+      suffix,
+      reentry = !1;
+    var componentFrameCache = new ("function" === typeof WeakMap ? WeakMap : Map)();
+    var REACT_LEGACY_ELEMENT_TYPE = Symbol.for("react.element"),
+      REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
+      REACT_PORTAL_TYPE = Symbol.for("react.portal"),
+      REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
+      REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
+      REACT_PROFILER_TYPE = Symbol.for("react.profiler"),
+      REACT_PROVIDER_TYPE = Symbol.for("react.provider"),
+      REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
+      REACT_CONTEXT_TYPE = Symbol.for("react.context"),
+      REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
+      REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
+      REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
+      REACT_MEMO_TYPE = Symbol.for("react.memo"),
+      REACT_LAZY_TYPE = Symbol.for("react.lazy");
+    Symbol.for("react.scope");
+    var REACT_ACTIVITY_TYPE = Symbol.for("react.activity");
+    Symbol.for("react.legacy_hidden");
+    Symbol.for("react.tracing_marker");
+    var REACT_MEMO_CACHE_SENTINEL = Symbol.for("react.memo_cache_sentinel");
+    Symbol.for("react.view_transition");
+    var MAYBE_ITERATOR_SYMBOL = Symbol.iterator,
+      REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"),
+      current = null,
+      isRendering = !1,
+      hasError = !1,
+      caughtError = null,
+      getFiberCurrentPropsFromNode$1 = null,
+      getInstanceFromNode = null,
+      getNodeFromInstance = null;
+    assign(SyntheticEvent.prototype, {
+      preventDefault: function preventDefault() {
+        this.defaultPrevented = !0;
+        var event = this.nativeEvent;
+        event && (event.preventDefault ? event.preventDefault() : "unknown" !== typeof event.returnValue && (event.returnValue = !1), this.isDefaultPrevented = functionThatReturnsTrue);
+      },
+      stopPropagation: function stopPropagation() {
+        var event = this.nativeEvent;
+        event && (event.stopPropagation ? event.stopPropagation() : "unknown" !== typeof event.cancelBubble && (event.cancelBubble = !0), this.isPropagationStopped = functionThatReturnsTrue);
+      },
+      persist: function persist() {
+        this.isPersistent = functionThatReturnsTrue;
+      },
+      isPersistent: functionThatReturnsFalse,
+      destructor: function destructor() {
+        var Interface = this.constructor.Interface,
+          propName;
+        for (propName in Interface) Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName]));
+        this.nativeEvent = this._targetInst = this.dispatchConfig = null;
+        this.isPropagationStopped = this.isDefaultPrevented = functionThatReturnsFalse;
+        this._dispatchInstances = this._dispatchListeners = null;
+        Object.defineProperty(this, "nativeEvent", getPooledWarningPropertyDefinition("nativeEvent", null));
+        Object.defineProperty(this, "isDefaultPrevented", getPooledWarningPropertyDefinition("isDefaultPrevented", functionThatReturnsFalse));
+        Object.defineProperty(this, "isPropagationStopped", getPooledWarningPropertyDefinition("isPropagationStopped", functionThatReturnsFalse));
+        Object.defineProperty(this, "preventDefault", getPooledWarningPropertyDefinition("preventDefault", function () {}));
+        Object.defineProperty(this, "stopPropagation", getPooledWarningPropertyDefinition("stopPropagation", function () {}));
+      }
+    });
+    SyntheticEvent.Interface = {
+      type: null,
+      target: null,
+      currentTarget: function currentTarget() {
+        return null;
+      },
+      eventPhase: null,
+      bubbles: null,
+      cancelable: null,
+      timeStamp: function timeStamp(event) {
+        return event.timeStamp || Date.now();
+      },
+      defaultPrevented: null,
+      isTrusted: null
+    };
+    SyntheticEvent.extend = function (Interface) {
+      function E() {}
+      function Class() {
+        return Super.apply(this, arguments);
+      }
+      var Super = this;
+      E.prototype = Super.prototype;
+      var prototype = new E();
+      assign(prototype, Class.prototype);
+      Class.prototype = prototype;
+      Class.prototype.constructor = Class;
+      Class.Interface = assign({}, Super.Interface, Interface);
+      Class.extend = Super.extend;
+      addEventPoolingTo(Class);
+      return Class;
+    };
+    addEventPoolingTo(SyntheticEvent);
+    var ResponderSyntheticEvent = SyntheticEvent.extend({
+        touchHistory: function touchHistory() {
+          return null;
+        }
+      }),
+      startDependencies = ["topTouchStart"],
+      moveDependencies = ["topTouchMove"],
+      endDependencies = ["topTouchCancel", "topTouchEnd"],
+      touchBank = [],
+      touchHistory = {
+        touchBank: touchBank,
+        numberActiveTouches: 0,
+        indexOfSingleActiveTouch: -1,
+        mostRecentTimeStamp: 0
+      },
+      instrumentationCallback,
+      ResponderTouchHistoryStore = {
+        instrument: function instrument(callback) {
+          instrumentationCallback = callback;
+        },
+        recordTouchTrack: function recordTouchTrack(topLevelType, nativeEvent) {
+          null != instrumentationCallback && instrumentationCallback(topLevelType, nativeEvent);
+          if (isMoveish(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchMove);else if (isStartish(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchStart), touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches && (touchHistory.indexOfSingleActiveTouch = nativeEvent.touches[0].identifier);else if ("topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType) if (nativeEvent.changedTouches.forEach(recordTouchEnd), touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches) {
+            for (topLevelType = 0; topLevelType < touchBank.length; topLevelType++) if (nativeEvent = touchBank[topLevelType], null != nativeEvent && nativeEvent.touchActive) {
+              touchHistory.indexOfSingleActiveTouch = topLevelType;
+              break;
+            }
+            topLevelType = touchBank[touchHistory.indexOfSingleActiveTouch];
+            null != topLevelType && topLevelType.touchActive || console.error("Cannot find single active touch.");
+          }
+        },
+        touchHistory: touchHistory
+      },
+      responderInst = null,
+      trackedTouchCount = 0,
+      eventTypes = {
+        startShouldSetResponder: {
+          phasedRegistrationNames: {
+            bubbled: "onStartShouldSetResponder",
+            captured: "onStartShouldSetResponderCapture"
+          },
+          dependencies: startDependencies
+        },
+        scrollShouldSetResponder: {
+          phasedRegistrationNames: {
+            bubbled: "onScrollShouldSetResponder",
+            captured: "onScrollShouldSetResponderCapture"
+          },
+          dependencies: ["topScroll"]
+        },
+        selectionChangeShouldSetResponder: {
+          phasedRegistrationNames: {
+            bubbled: "onSelectionChangeShouldSetResponder",
+            captured: "onSelectionChangeShouldSetResponderCapture"
+          },
+          dependencies: ["topSelectionChange"]
+        },
+        moveShouldSetResponder: {
+          phasedRegistrationNames: {
+            bubbled: "onMoveShouldSetResponder",
+            captured: "onMoveShouldSetResponderCapture"
+          },
+          dependencies: moveDependencies
+        },
+        responderStart: {
+          registrationName: "onResponderStart",
+          dependencies: startDependencies
+        },
+        responderMove: {
+          registrationName: "onResponderMove",
+          dependencies: moveDependencies
+        },
+        responderEnd: {
+          registrationName: "onResponderEnd",
+          dependencies: endDependencies
+        },
+        responderRelease: {
+          registrationName: "onResponderRelease",
+          dependencies: endDependencies
+        },
+        responderTerminationRequest: {
+          registrationName: "onResponderTerminationRequest",
+          dependencies: []
+        },
+        responderGrant: {
+          registrationName: "onResponderGrant",
+          dependencies: []
+        },
+        responderReject: {
+          registrationName: "onResponderReject",
+          dependencies: []
+        },
+        responderTerminate: {
+          registrationName: "onResponderTerminate",
+          dependencies: []
+        }
+      },
+      ResponderEventPlugin = {
+        _getResponder: function _getResponder() {
+          return responderInst;
+        },
+        eventTypes: eventTypes,
+        extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+          if (isStartish(topLevelType)) trackedTouchCount += 1;else if ("topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType) if (0 <= trackedTouchCount) --trackedTouchCount;else return console.warn("Ended a touch event which was not counted in `trackedTouchCount`."), null;
+          ResponderTouchHistoryStore.recordTouchTrack(topLevelType, nativeEvent);
+          if (targetInst && ("topScroll" === topLevelType && !nativeEvent.responderIgnoreScroll || 0 < trackedTouchCount && "topSelectionChange" === topLevelType || isStartish(topLevelType) || isMoveish(topLevelType))) {
+            var shouldSetEventType = isStartish(topLevelType) ? eventTypes.startShouldSetResponder : isMoveish(topLevelType) ? eventTypes.moveShouldSetResponder : "topSelectionChange" === topLevelType ? eventTypes.selectionChangeShouldSetResponder : eventTypes.scrollShouldSetResponder;
+            if (responderInst) b: {
+              var JSCompiler_temp = responderInst;
+              for (var depthA = 0, tempA = JSCompiler_temp; tempA; tempA = getParent$1(tempA)) depthA++;
+              tempA = 0;
+              for (var tempB = targetInst; tempB; tempB = getParent$1(tempB)) tempA++;
+              for (; 0 < depthA - tempA;) JSCompiler_temp = getParent$1(JSCompiler_temp), depthA--;
+              for (; 0 < tempA - depthA;) targetInst = getParent$1(targetInst), tempA--;
+              for (; depthA--;) {
+                if (JSCompiler_temp === targetInst || JSCompiler_temp === targetInst.alternate) break b;
+                JSCompiler_temp = getParent$1(JSCompiler_temp);
+                targetInst = getParent$1(targetInst);
+              }
+              JSCompiler_temp = null;
+            } else JSCompiler_temp = targetInst;
+            targetInst = JSCompiler_temp === responderInst;
+            JSCompiler_temp = ResponderSyntheticEvent.getPooled(shouldSetEventType, JSCompiler_temp, nativeEvent, nativeEventTarget);
+            JSCompiler_temp.touchHistory = ResponderTouchHistoryStore.touchHistory;
+            targetInst ? forEachAccumulated(JSCompiler_temp, accumulateTwoPhaseDispatchesSingleSkipTarget) : forEachAccumulated(JSCompiler_temp, accumulateTwoPhaseDispatchesSingle$1);
+            b: {
+              shouldSetEventType = JSCompiler_temp._dispatchListeners;
+              targetInst = JSCompiler_temp._dispatchInstances;
+              validateEventDispatches(JSCompiler_temp);
+              if (isArrayImpl(shouldSetEventType)) for (depthA = 0; depthA < shouldSetEventType.length && !JSCompiler_temp.isPropagationStopped(); depthA++) {
+                if (shouldSetEventType[depthA](JSCompiler_temp, targetInst[depthA])) {
+                  shouldSetEventType = targetInst[depthA];
+                  break b;
+                }
+              } else if (shouldSetEventType && shouldSetEventType(JSCompiler_temp, targetInst)) {
+                shouldSetEventType = targetInst;
+                break b;
+              }
+              shouldSetEventType = null;
+            }
+            JSCompiler_temp._dispatchInstances = null;
+            JSCompiler_temp._dispatchListeners = null;
+            JSCompiler_temp.isPersistent() || JSCompiler_temp.constructor.release(JSCompiler_temp);
+            if (shouldSetEventType && shouldSetEventType !== responderInst) {
+              if (JSCompiler_temp = ResponderSyntheticEvent.getPooled(eventTypes.responderGrant, shouldSetEventType, nativeEvent, nativeEventTarget), JSCompiler_temp.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(JSCompiler_temp, accumulateDirectDispatchesSingle$1), targetInst = !0 === executeDirectDispatch(JSCompiler_temp), responderInst) {
+                if (depthA = ResponderSyntheticEvent.getPooled(eventTypes.responderTerminationRequest, responderInst, nativeEvent, nativeEventTarget), depthA.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(depthA, accumulateDirectDispatchesSingle$1), tempA = !depthA._dispatchListeners || executeDirectDispatch(depthA), depthA.isPersistent() || depthA.constructor.release(depthA), tempA) {
+                  depthA = ResponderSyntheticEvent.getPooled(eventTypes.responderTerminate, responderInst, nativeEvent, nativeEventTarget);
+                  depthA.touchHistory = ResponderTouchHistoryStore.touchHistory;
+                  forEachAccumulated(depthA, accumulateDirectDispatchesSingle$1);
+                  var JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, [JSCompiler_temp, depthA]);
+                  changeResponder(shouldSetEventType, targetInst);
+                } else shouldSetEventType = ResponderSyntheticEvent.getPooled(eventTypes.responderReject, shouldSetEventType, nativeEvent, nativeEventTarget), shouldSetEventType.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(shouldSetEventType, accumulateDirectDispatchesSingle$1), JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, shouldSetEventType);
+              } else JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, JSCompiler_temp), changeResponder(shouldSetEventType, targetInst);
+            } else JSCompiler_temp$jscomp$0 = null;
+          } else JSCompiler_temp$jscomp$0 = null;
+          shouldSetEventType = responderInst && isStartish(topLevelType);
+          JSCompiler_temp = responderInst && isMoveish(topLevelType);
+          targetInst = responderInst && ("topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType);
+          if (shouldSetEventType = shouldSetEventType ? eventTypes.responderStart : JSCompiler_temp ? eventTypes.responderMove : targetInst ? eventTypes.responderEnd : null) shouldSetEventType = ResponderSyntheticEvent.getPooled(shouldSetEventType, responderInst, nativeEvent, nativeEventTarget), shouldSetEventType.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(shouldSetEventType, accumulateDirectDispatchesSingle$1), JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, shouldSetEventType);
+          shouldSetEventType = responderInst && "topTouchCancel" === topLevelType;
+          if (topLevelType = responderInst && !shouldSetEventType && ("topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType)) a: {
+            if ((topLevelType = nativeEvent.touches) && 0 !== topLevelType.length) for (JSCompiler_temp = 0; JSCompiler_temp < topLevelType.length; JSCompiler_temp++) if (targetInst = topLevelType[JSCompiler_temp].target, null !== targetInst && void 0 !== targetInst && 0 !== targetInst) {
+              depthA = getInstanceFromNode(targetInst);
+              b: {
+                for (targetInst = responderInst; depthA;) {
+                  if (targetInst === depthA || targetInst === depthA.alternate) {
+                    targetInst = !0;
+                    break b;
+                  }
+                  depthA = getParent$1(depthA);
+                }
+                targetInst = !1;
+              }
+              if (targetInst) {
+                topLevelType = !1;
+                break a;
+              }
+            }
+            topLevelType = !0;
+          }
+          if (topLevelType = shouldSetEventType ? eventTypes.responderTerminate : topLevelType ? eventTypes.responderRelease : null) nativeEvent = ResponderSyntheticEvent.getPooled(topLevelType, responderInst, nativeEvent, nativeEventTarget), nativeEvent.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(nativeEvent, accumulateDirectDispatchesSingle$1), JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, nativeEvent), changeResponder(null);
+          return JSCompiler_temp$jscomp$0;
+        },
+        GlobalResponderHandler: null,
+        injection: {
+          injectGlobalResponderHandler: function injectGlobalResponderHandler(GlobalResponderHandler) {
+            ResponderEventPlugin.GlobalResponderHandler = GlobalResponderHandler;
+          }
+        }
+      },
+      eventPluginOrder = null,
+      namesToPlugins = {},
+      plugins = [],
+      eventNameDispatchConfigs = {},
+      registrationNameModules = {},
+      customBubblingEventTypes = ReactNativePrivateInterface.ReactNativeViewConfigRegistry.customBubblingEventTypes,
+      customDirectEventTypes = ReactNativePrivateInterface.ReactNativeViewConfigRegistry.customDirectEventTypes;
+    if (eventPluginOrder) throw Error("EventPluginRegistry: Cannot inject event plugin ordering more than once. You are likely trying to load more than one copy of React.");
+    eventPluginOrder = Array.prototype.slice.call(["ResponderEventPlugin", "ReactNativeBridgeEventPlugin"]);
+    recomputePluginOrdering();
+    (function (injectedNamesToPlugins) {
+      var isOrderingDirty = !1,
+        pluginName;
+      for (pluginName in injectedNamesToPlugins) if (injectedNamesToPlugins.hasOwnProperty(pluginName)) {
+        var pluginModule = injectedNamesToPlugins[pluginName];
+        if (!namesToPlugins.hasOwnProperty(pluginName) || namesToPlugins[pluginName] !== pluginModule) {
+          if (namesToPlugins[pluginName]) throw Error("EventPluginRegistry: Cannot inject two different event plugins using the same name, `" + (pluginName + "`."));
+          namesToPlugins[pluginName] = pluginModule;
+          isOrderingDirty = !0;
+        }
+      }
+      isOrderingDirty && recomputePluginOrdering();
+    })({
+      ResponderEventPlugin: ResponderEventPlugin,
+      ReactNativeBridgeEventPlugin: {
+        eventTypes: {},
+        extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+          if (null == targetInst) return null;
+          var bubbleDispatchConfig = customBubblingEventTypes[topLevelType],
+            directDispatchConfig = customDirectEventTypes[topLevelType];
+          if (!bubbleDispatchConfig && !directDispatchConfig) throw Error('Unsupported top level event type "' + topLevelType + '" dispatched');
+          topLevelType = SyntheticEvent.getPooled(bubbleDispatchConfig || directDispatchConfig, targetInst, nativeEvent, nativeEventTarget);
+          if (bubbleDispatchConfig) null != topLevelType && null != topLevelType.dispatchConfig.phasedRegistrationNames && topLevelType.dispatchConfig.phasedRegistrationNames.skipBubbling ? topLevelType && topLevelType.dispatchConfig.phasedRegistrationNames && traverseTwoPhase(topLevelType._targetInst, accumulateDirectionalDispatches, topLevelType, !0) : forEachAccumulated(topLevelType, accumulateTwoPhaseDispatchesSingle);else if (directDispatchConfig) forEachAccumulated(topLevelType, accumulateDirectDispatchesSingle);else return null;
+          return topLevelType;
+        }
+      }
+    });
+    var instanceCache = new Map(),
+      instanceProps = new Map(),
+      isInsideEventHandler = !1,
+      eventQueue = null,
+      EMPTY_NATIVE_EVENT = {};
+    ReactNativePrivateInterface.RCTEventEmitter.register({
+      receiveEvent: function receiveEvent(rootNodeID, topLevelType, nativeEventParam) {
+        _receiveRootNodeIDEvent(rootNodeID, topLevelType, nativeEventParam);
+      },
+      receiveTouches: function receiveTouches(eventTopLevelType, touches, changedIndices) {
+        if ("topTouchEnd" === eventTopLevelType || "topTouchCancel" === eventTopLevelType) {
+          var JSCompiler_temp = [];
+          for (var i = 0; i < changedIndices.length; i++) {
+            var index = changedIndices[i];
+            JSCompiler_temp.push(touches[index]);
+            touches[index] = null;
+          }
+          for (i = changedIndices = 0; i < touches.length; i++) index = touches[i], null !== index && (touches[changedIndices++] = index);
+          touches.length = changedIndices;
+        } else for (JSCompiler_temp = [], i = 0; i < changedIndices.length; i++) JSCompiler_temp.push(touches[changedIndices[i]]);
+        for (changedIndices = 0; changedIndices < JSCompiler_temp.length; changedIndices++) {
+          i = JSCompiler_temp[changedIndices];
+          i.changedTouches = JSCompiler_temp;
+          i.touches = touches;
+          index = null;
+          var target = i.target;
+          null !== target && void 0 !== target && (1 > target ? console.error("A view is reporting that a touch occurred on tag zero.") : index = target);
+          _receiveRootNodeIDEvent(index, eventTopLevelType, i);
+        }
+      }
+    });
+    (function (getFiberCurrentPropsFromNodeImpl, getInstanceFromNodeImpl, getNodeFromInstanceImpl) {
+      getFiberCurrentPropsFromNode$1 = getFiberCurrentPropsFromNodeImpl;
+      getInstanceFromNode = getInstanceFromNodeImpl;
+      (getNodeFromInstance = getNodeFromInstanceImpl) && getInstanceFromNode || console.error("Injected module is missing getNodeFromInstance or getInstanceFromNode.");
+    })(function (stateNode) {
+      return instanceProps.get(stateNode._nativeTag) || null;
+    }, getInstanceFromTag, function (inst) {
+      inst = inst.stateNode;
+      var tag = inst._nativeTag;
+      void 0 === tag && null != inst.canonical && (tag = inst.canonical.nativeTag, inst = inst.canonical.publicInstance);
+      if (!tag) throw Error("All native instances should have a tag.");
+      return inst;
+    });
+    ResponderEventPlugin.injection.injectGlobalResponderHandler({
+      onChange: function onChange(from, to, blockNativeResponder) {
+        null !== to ? ReactNativePrivateInterface.UIManager.setJSResponder(to.stateNode._nativeTag, blockNativeResponder) : ReactNativePrivateInterface.UIManager.clearJSResponder();
+      }
+    });
+    var emptyObject$1 = {},
+      removedKeys = null,
+      removedKeyCount = 0,
+      deepDifferOptions = {
+        unsafelyIgnoreFunctions: !0
+      },
+      ReactNativeFiberHostComponent = function () {
+        function ReactNativeFiberHostComponent(tag, viewConfig, internalInstanceHandleDEV) {
+          this.viewConfig = void 0;
+          this._nativeTag = tag;
+          this._children = [];
+          this.viewConfig = viewConfig;
+          this._internalFiberInstanceHandleDEV = internalInstanceHandleDEV;
+        }
+        var _proto = ReactNativeFiberHostComponent.prototype;
+        _proto.blur = function () {
+          ReactNativePrivateInterface.TextInputState.blurTextInput(this);
+        };
+        _proto.focus = function () {
+          ReactNativePrivateInterface.TextInputState.focusTextInput(this);
+        };
+        _proto.measure = function (callback) {
+          ReactNativePrivateInterface.UIManager.measure(this._nativeTag, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+        };
+        _proto.measureInWindow = function (callback) {
+          ReactNativePrivateInterface.UIManager.measureInWindow(this._nativeTag, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+        };
+        _proto.measureLayout = function (relativeToNativeNode, onSuccess, onFail) {
+          if ("number" === typeof relativeToNativeNode) var relativeNode = relativeToNativeNode;else relativeToNativeNode._nativeTag && (relativeNode = relativeToNativeNode._nativeTag);
+          null == relativeNode ? console.error("ref.measureLayout must be called with a node handle or a ref to a native component.") : ReactNativePrivateInterface.UIManager.measureLayout(this._nativeTag, relativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+        };
+        _proto.setNativeProps = function (nativeProps) {
+          var validAttributes = this.viewConfig.validAttributes,
+            key;
+          for (key in validAttributes.style) validAttributes[key] || void 0 === nativeProps[key] || console.error("You are setting the style `{ %s: ... }` as a prop. You should nest it in a style object. E.g. `{ style: { %s: ... } }`", key, key);
+          nativeProps = diffProperties(null, emptyObject$1, nativeProps, this.viewConfig.validAttributes);
+          null != nativeProps && ReactNativePrivateInterface.UIManager.updateView(this._nativeTag, this.viewConfig.uiViewClassName, nativeProps);
+        };
+        return ReactNativeFiberHostComponent;
+      }(),
+      scheduleCallback$3 = Scheduler.unstable_scheduleCallback,
+      cancelCallback$1 = Scheduler.unstable_cancelCallback,
+      shouldYield = Scheduler.unstable_shouldYield,
+      requestPaint = Scheduler.unstable_requestPaint,
+      now$1 = Scheduler.unstable_now,
+      ImmediatePriority = Scheduler.unstable_ImmediatePriority,
+      UserBlockingPriority = Scheduler.unstable_UserBlockingPriority,
+      NormalPriority$1 = Scheduler.unstable_NormalPriority,
+      IdlePriority = Scheduler.unstable_IdlePriority,
+      log$1 = Scheduler.log,
+      unstable_setDisableYieldValue = Scheduler.unstable_setDisableYieldValue,
+      rendererID = null,
+      injectedHook = null,
+      injectedProfilingHooks = null,
+      hasLoggedError = !1,
+      isDevToolsPresent = "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__,
+      clz32 = Math.clz32 ? Math.clz32 : clz32Fallback,
+      log = Math.log,
+      LN2 = Math.LN2,
+      nextTransitionLane = 256,
+      nextRetryLane = 4194304,
+      DiscreteEventPriority = 2,
+      ContinuousEventPriority = 8,
+      DefaultEventPriority = 32,
+      IdleEventPriority = 268435456,
+      emptyObject = Object.freeze({});
+    var getInspectorDataForInstance = function getInspectorDataForInstance(closestInstance) {
+      if (!closestInstance) return {
+        hierarchy: [],
+        props: emptyObject,
+        selectedIndex: null,
+        componentStack: ""
+      };
+      closestInstance = findCurrentFiberUsingSlowPath(closestInstance);
+      if (null === closestInstance) return {
+        hierarchy: [],
+        props: emptyObject,
+        selectedIndex: null,
+        componentStack: ""
+      };
+      var hierarchy = [];
+      traverseOwnerTreeUp(hierarchy, closestInstance);
+      var instance;
+      a: {
+        for (instance = hierarchy.length - 1; 1 < instance; instance--) {
+          var instance$jscomp$0 = hierarchy[instance];
+          if (5 !== instance$jscomp$0.tag) {
+            instance = instance$jscomp$0;
+            break a;
+          }
+        }
+        instance = hierarchy[0];
+      }
+      instance$jscomp$0 = createHierarchy(hierarchy);
+      var props = getHostProps(instance);
+      hierarchy = hierarchy.indexOf(instance);
+      closestInstance = getStackByFiberInDevAndProd(closestInstance);
+      return {
+        closestInstance: instance,
+        hierarchy: instance$jscomp$0,
+        props: props,
+        selectedIndex: hierarchy,
+        componentStack: closestInstance
+      };
+    };
+    var isSuspenseInstancePending = shim$1,
+      isSuspenseInstanceFallback = shim$1,
+      getSuspenseInstanceFallbackErrorDetails = shim$1,
+      registerSuspenseInstanceRetry = shim$1,
+      clearSuspenseBoundary = shim$1,
+      clearSuspenseBoundaryFromContainer = shim$1,
+      preloadResource = shim,
+      suspendResource = shim,
+      extraDevToolsConfig = {
+        getInspectorDataForInstance: getInspectorDataForInstance,
+        getInspectorDataForViewTag: function getInspectorDataForViewTag(viewTag) {
+          viewTag = getInstanceFromTag(viewTag);
+          return getInspectorDataForInstance(viewTag);
+        },
+        getInspectorDataForViewAtPoint: function getInspectorDataForViewAtPoint(inspectedView, locationX, locationY, callback) {
+          var closestInstance = null,
+            fabricNode = ReactNativePrivateInterface.getNodeFromPublicInstance(inspectedView);
+          fabricNode ? nativeFabricUIManager.findNodeAtPoint(fabricNode, locationX, locationY, function (internalInstanceHandle) {
+            var node = null != internalInstanceHandle ? internalInstanceHandle && internalInstanceHandle.stateNode && internalInstanceHandle.stateNode.node : null;
+            if (null == internalInstanceHandle || null == node) callback(assign({
+              pointerY: locationY,
+              frame: {
+                left: 0,
+                top: 0,
+                width: 0,
+                height: 0
+              }
+            }, getInspectorDataForInstance(closestInstance)));else {
+              closestInstance = internalInstanceHandle.stateNode.canonical.internalInstanceHandle;
+              var closestPublicInstance = internalInstanceHandle.stateNode.canonical.publicInstance,
+                nativeViewTag = internalInstanceHandle.stateNode.canonical.nativeTag;
+              nativeFabricUIManager.measure(node, function (x, y, width, height, pageX, pageY) {
+                x = getInspectorDataForInstance(closestInstance);
+                callback(assign({}, x, {
+                  pointerY: locationY,
+                  frame: {
+                    left: pageX,
+                    top: pageY,
+                    width: width,
+                    height: height
+                  },
+                  touchedViewTag: nativeViewTag,
+                  closestPublicInstance: closestPublicInstance
+                }));
+              });
+            }
+          }) : null != inspectedView._internalFiberInstanceHandleDEV ? ReactNativePrivateInterface.UIManager.findSubviewIn(findNodeHandle(inspectedView), [locationX, locationY], function (nativeViewTag, left, top, width, height) {
+            var inspectorData = getInspectorDataForInstance(getInstanceFromTag(nativeViewTag));
+            callback(assign({}, inspectorData, {
+              pointerY: locationY,
+              frame: {
+                left: left,
+                top: top,
+                width: width,
+                height: height
+              },
+              touchedViewTag: nativeViewTag,
+              closestPublicInstance: nativeViewTag
+            }));
+          }) : console.error("getInspectorDataForViewAtPoint expects to receive a host component");
+        }
+      },
+      getViewConfigForType = ReactNativePrivateInterface.ReactNativeViewConfigRegistry.get,
+      nextReactTag = 3,
+      scheduleTimeout = setTimeout,
+      cancelTimeout = clearTimeout,
+      currentUpdatePriority = 0,
+      HostTransitionContext = {
+        $$typeof: REACT_CONTEXT_TYPE,
+        Provider: null,
+        Consumer: null,
+        _currentValue: null,
+        _currentValue2: null,
+        _threadCount: 0
+      },
+      bind = Function.prototype.bind,
+      valueStack = [];
+    var fiberStack = [];
+    var index$jscomp$0 = -1,
+      emptyContextObject = {};
+    Object.freeze(emptyContextObject);
+    var CapturedStacks = new WeakMap(),
+      contextStackCursor = createCursor(null),
+      contextFiberStackCursor = createCursor(null),
+      rootInstanceStackCursor = createCursor(null),
+      hostTransitionProviderCursor = createCursor(null),
+      needsEscaping = /["'&<>\n\t]|^\s|\s$/,
+      hydrationDiffRootDEV = null,
+      hydrationErrors = null,
+      lastResetTime = 0;
+    if ("object" === typeof performance && "function" === typeof performance.now) {
+      var localPerformance = performance;
+      var getCurrentTime = function getCurrentTime() {
+        return localPerformance.now();
+      };
+    } else {
+      var localDate = Date;
+      getCurrentTime = function getCurrentTime() {
+        return localDate.now();
+      };
+    }
+    var objectIs = "function" === typeof Object.is ? Object.is : is,
+      StrictLegacyMode = 8,
+      valueCursor = createCursor(null);
+    var rendererCursorDEV = createCursor(null);
+    var rendererSigil = {};
+    var currentlyRenderingFiber$1 = null,
+      lastContextDependency = null,
+      isDisallowedContextReadInDEV = !1,
+      AbortControllerLocal = "undefined" !== typeof AbortController ? AbortController : function () {
+        var listeners = [],
+          signal = this.signal = {
+            aborted: !1,
+            addEventListener: function addEventListener(type, listener) {
+              listeners.push(listener);
+            }
+          };
+        this.abort = function () {
+          signal.aborted = !0;
+          listeners.forEach(function (listener) {
+            return listener();
+          });
+        };
+      },
+      scheduleCallback$2 = Scheduler.unstable_scheduleCallback,
+      NormalPriority = Scheduler.unstable_NormalPriority,
+      CacheContext = {
+        $$typeof: REACT_CONTEXT_TYPE,
+        Consumer: null,
+        Provider: null,
+        _currentValue: null,
+        _currentValue2: null,
+        _threadCount: 0,
+        _currentRenderer: null,
+        _currentRenderer2: null
+      },
+      now = Scheduler.unstable_now,
+      commitStartTime = -0,
+      profilerStartTime = -1.1,
+      profilerEffectDuration = -0,
+      currentUpdateIsNested = !1,
+      nestedUpdateScheduled = !1,
+      firstScheduledRoot = null,
+      lastScheduledRoot = null,
+      didScheduleMicrotask = !1,
+      didScheduleMicrotask_act = !1,
+      mightHavePendingSyncWork = !1,
+      isFlushingWork = !1,
+      currentEventTransitionLane = 0,
+      fakeActCallbackNode$1 = {},
+      currentEntangledListeners = null,
+      currentEntangledPendingCount = 0,
+      currentEntangledLane = 0,
+      currentEntangledActionThenable = null,
+      prevOnStartTransitionFinish = ReactSharedInternals.S;
+    ReactSharedInternals.S = function (transition, returnValue) {
+      "object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && entangleAsyncAction(transition, returnValue);
+      null !== prevOnStartTransitionFinish && prevOnStartTransitionFinish(transition, returnValue);
+    };
+    var resumedCache = createCursor(null),
+      hasOwnProperty = Object.prototype.hasOwnProperty,
+      ReactStrictModeWarnings = {
+        recordUnsafeLifecycleWarnings: function recordUnsafeLifecycleWarnings() {},
+        flushPendingUnsafeLifecycleWarnings: function flushPendingUnsafeLifecycleWarnings() {},
+        recordLegacyContextWarning: function recordLegacyContextWarning() {},
+        flushLegacyContextWarning: function flushLegacyContextWarning() {},
+        discardPendingWarnings: function discardPendingWarnings() {}
+      },
+      pendingComponentWillMountWarnings = [],
+      pendingUNSAFE_ComponentWillMountWarnings = [],
+      pendingComponentWillReceivePropsWarnings = [],
+      pendingUNSAFE_ComponentWillReceivePropsWarnings = [],
+      pendingComponentWillUpdateWarnings = [],
+      pendingUNSAFE_ComponentWillUpdateWarnings = [],
+      didWarnAboutUnsafeLifecycles = new Set();
+    ReactStrictModeWarnings.recordUnsafeLifecycleWarnings = function (fiber, instance) {
+      didWarnAboutUnsafeLifecycles.has(fiber.type) || ("function" === typeof instance.componentWillMount && !0 !== instance.componentWillMount.__suppressDeprecationWarning && pendingComponentWillMountWarnings.push(fiber), fiber.mode & StrictLegacyMode && "function" === typeof instance.UNSAFE_componentWillMount && pendingUNSAFE_ComponentWillMountWarnings.push(fiber), "function" === typeof instance.componentWillReceiveProps && !0 !== instance.componentWillReceiveProps.__suppressDeprecationWarning && pendingComponentWillReceivePropsWarnings.push(fiber), fiber.mode & StrictLegacyMode && "function" === typeof instance.UNSAFE_componentWillReceiveProps && pendingUNSAFE_ComponentWillReceivePropsWarnings.push(fiber), "function" === typeof instance.componentWillUpdate && !0 !== instance.componentWillUpdate.__suppressDeprecationWarning && pendingComponentWillUpdateWarnings.push(fiber), fiber.mode & StrictLegacyMode && "function" === typeof instance.UNSAFE_componentWillUpdate && pendingUNSAFE_ComponentWillUpdateWarnings.push(fiber));
+    };
+    ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings = function () {
+      var componentWillMountUniqueNames = new Set();
+      0 < pendingComponentWillMountWarnings.length && (pendingComponentWillMountWarnings.forEach(function (fiber) {
+        componentWillMountUniqueNames.add(getComponentNameFromFiber(fiber) || "Component");
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      }), pendingComponentWillMountWarnings = []);
+      var UNSAFE_componentWillMountUniqueNames = new Set();
+      0 < pendingUNSAFE_ComponentWillMountWarnings.length && (pendingUNSAFE_ComponentWillMountWarnings.forEach(function (fiber) {
+        UNSAFE_componentWillMountUniqueNames.add(getComponentNameFromFiber(fiber) || "Component");
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      }), pendingUNSAFE_ComponentWillMountWarnings = []);
+      var componentWillReceivePropsUniqueNames = new Set();
+      0 < pendingComponentWillReceivePropsWarnings.length && (pendingComponentWillReceivePropsWarnings.forEach(function (fiber) {
+        componentWillReceivePropsUniqueNames.add(getComponentNameFromFiber(fiber) || "Component");
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      }), pendingComponentWillReceivePropsWarnings = []);
+      var UNSAFE_componentWillReceivePropsUniqueNames = new Set();
+      0 < pendingUNSAFE_ComponentWillReceivePropsWarnings.length && (pendingUNSAFE_ComponentWillReceivePropsWarnings.forEach(function (fiber) {
+        UNSAFE_componentWillReceivePropsUniqueNames.add(getComponentNameFromFiber(fiber) || "Component");
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      }), pendingUNSAFE_ComponentWillReceivePropsWarnings = []);
+      var componentWillUpdateUniqueNames = new Set();
+      0 < pendingComponentWillUpdateWarnings.length && (pendingComponentWillUpdateWarnings.forEach(function (fiber) {
+        componentWillUpdateUniqueNames.add(getComponentNameFromFiber(fiber) || "Component");
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      }), pendingComponentWillUpdateWarnings = []);
+      var UNSAFE_componentWillUpdateUniqueNames = new Set();
+      0 < pendingUNSAFE_ComponentWillUpdateWarnings.length && (pendingUNSAFE_ComponentWillUpdateWarnings.forEach(function (fiber) {
+        UNSAFE_componentWillUpdateUniqueNames.add(getComponentNameFromFiber(fiber) || "Component");
+        didWarnAboutUnsafeLifecycles.add(fiber.type);
+      }), pendingUNSAFE_ComponentWillUpdateWarnings = []);
+      if (0 < UNSAFE_componentWillMountUniqueNames.size) {
+        var sortedNames = setToSortedString(UNSAFE_componentWillMountUniqueNames);
+        console.error("Using UNSAFE_componentWillMount in strict mode is not recommended and may indicate bugs in your code. See https://react.dev/link/unsafe-component-lifecycles for details.\n\n* Move code with side effects to componentDidMount, and set initial state in the constructor.\n\nPlease update the following components: %s", sortedNames);
+      }
+      0 < UNSAFE_componentWillReceivePropsUniqueNames.size && (sortedNames = setToSortedString(UNSAFE_componentWillReceivePropsUniqueNames), console.error("Using UNSAFE_componentWillReceiveProps in strict mode is not recommended and may indicate bugs in your code. See https://react.dev/link/unsafe-component-lifecycles for details.\n\n* Move data fetching code or side effects to componentDidUpdate.\n* If you're updating state whenever props change, refactor your code to use memoization techniques or move it to static getDerivedStateFromProps. Learn more at: https://react.dev/link/derived-state\n\nPlease update the following components: %s", sortedNames));
+      0 < UNSAFE_componentWillUpdateUniqueNames.size && (sortedNames = setToSortedString(UNSAFE_componentWillUpdateUniqueNames), console.error("Using UNSAFE_componentWillUpdate in strict mode is not recommended and may indicate bugs in your code. See https://react.dev/link/unsafe-component-lifecycles for details.\n\n* Move data fetching code or side effects to componentDidUpdate.\n\nPlease update the following components: %s", sortedNames));
+      0 < componentWillMountUniqueNames.size && (sortedNames = setToSortedString(componentWillMountUniqueNames), console.warn("componentWillMount has been renamed, and is not recommended for use. See https://react.dev/link/unsafe-component-lifecycles for details.\n\n* Move code with side effects to componentDidMount, and set initial state in the constructor.\n* Rename componentWillMount to UNSAFE_componentWillMount to suppress this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. To rename all deprecated lifecycles to their new names, you can run `npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n\nPlease update the following components: %s", sortedNames));
+      0 < componentWillReceivePropsUniqueNames.size && (sortedNames = setToSortedString(componentWillReceivePropsUniqueNames), console.warn("componentWillReceiveProps has been renamed, and is not recommended for use. See https://react.dev/link/unsafe-component-lifecycles for details.\n\n* Move data fetching code or side effects to componentDidUpdate.\n* If you're updating state whenever props change, refactor your code to use memoization techniques or move it to static getDerivedStateFromProps. Learn more at: https://react.dev/link/derived-state\n* Rename componentWillReceiveProps to UNSAFE_componentWillReceiveProps to suppress this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. To rename all deprecated lifecycles to their new names, you can run `npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n\nPlease update the following components: %s", sortedNames));
+      0 < componentWillUpdateUniqueNames.size && (sortedNames = setToSortedString(componentWillUpdateUniqueNames), console.warn("componentWillUpdate has been renamed, and is not recommended for use. See https://react.dev/link/unsafe-component-lifecycles for details.\n\n* Move data fetching code or side effects to componentDidUpdate.\n* Rename componentWillUpdate to UNSAFE_componentWillUpdate to suppress this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. To rename all deprecated lifecycles to their new names, you can run `npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n\nPlease update the following components: %s", sortedNames));
+    };
+    var pendingLegacyContextWarning = new Map(),
+      didWarnAboutLegacyContext = new Set();
+    ReactStrictModeWarnings.recordLegacyContextWarning = function (fiber, instance) {
+      var strictRoot = null;
+      for (var node = fiber; null !== node;) node.mode & StrictLegacyMode && (strictRoot = node), node = node.return;
+      null === strictRoot ? console.error("Expected to find a StrictMode component in a strict mode tree. This error is likely caused by a bug in React. Please file an issue.") : !didWarnAboutLegacyContext.has(fiber.type) && (node = pendingLegacyContextWarning.get(strictRoot), null != fiber.type.contextTypes || null != fiber.type.childContextTypes || null !== instance && "function" === typeof instance.getChildContext) && (void 0 === node && (node = [], pendingLegacyContextWarning.set(strictRoot, node)), node.push(fiber));
+    };
+    ReactStrictModeWarnings.flushLegacyContextWarning = function () {
+      pendingLegacyContextWarning.forEach(function (fiberArray) {
+        if (0 !== fiberArray.length) {
+          var firstFiber = fiberArray[0],
+            uniqueNames = new Set();
+          fiberArray.forEach(function (fiber) {
+            uniqueNames.add(getComponentNameFromFiber(fiber) || "Component");
+            didWarnAboutLegacyContext.add(fiber.type);
+          });
+          var sortedNames = setToSortedString(uniqueNames);
+          runWithFiberInDEV(firstFiber, function () {
+            console.error("Legacy context API has been detected within a strict-mode tree.\n\nThe old API will be supported in all 16.x releases, but applications using it should migrate to the new version.\n\nPlease update the following components: %s\n\nLearn more about this warning here: https://react.dev/link/legacy-context", sortedNames);
+          });
+        }
+      });
+    };
+    ReactStrictModeWarnings.discardPendingWarnings = function () {
+      pendingComponentWillMountWarnings = [];
+      pendingUNSAFE_ComponentWillMountWarnings = [];
+      pendingComponentWillReceivePropsWarnings = [];
+      pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
+      pendingComponentWillUpdateWarnings = [];
+      pendingUNSAFE_ComponentWillUpdateWarnings = [];
+      pendingLegacyContextWarning = new Map();
+    };
+    var SuspenseException = 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`."),
+      SuspenseyCommitException = Error("Suspense Exception: This is not a real error, and should not leak into userspace. If you're seeing this, it's likely a bug in React."),
+      SuspenseActionException = Error("Suspense Exception: This is not a real error! It's an implementation detail of `useActionState` to interrupt the current render. You must either rethrow it immediately, or move the `useActionState` 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."),
+      noopSuspenseyCommitThenable = {
+        then: function then() {
+          console.error('Internal React error: A listener was unexpectedly attached to a "noop" thenable. This is a bug in React. Please file an issue.');
+        }
+      },
+      suspendedThenable = null,
+      needsToResetSuspendedThenableDEV = !1,
+      NoFlags = 0,
+      HasEffect = 1,
+      Insertion = 2,
+      Layout = 4,
+      Passive = 8,
+      concurrentQueues = [],
+      concurrentQueuesIndex = 0,
+      concurrentlyUpdatedLanes = 0,
+      UpdateState = 0,
+      ReplaceState = 1,
+      ForceUpdate = 2,
+      CaptureUpdate = 3,
+      hasForceUpdate = !1;
+    var didWarnUpdateInsideUpdate = !1;
+    var currentlyProcessingQueue = null;
+    var didReadFromEntangledAsyncAction = !1,
+      currentTreeHiddenStackCursor = createCursor(null),
+      prevEntangledRenderLanesCursor = createCursor(0),
+      didWarnUncachedGetSnapshot;
+    var didWarnAboutMismatchedHooksForComponent = new Set();
+    var didWarnAboutUseWrappedInTryCatch = new Set();
+    var didWarnAboutAsyncClientComponent = new Set();
+    var didWarnAboutUseFormState = new Set();
+    var renderLanes = 0,
+      currentlyRenderingFiber = null,
+      currentHook = null,
+      workInProgressHook = null,
+      didScheduleRenderPhaseUpdate = !1,
+      didScheduleRenderPhaseUpdateDuringThisPass = !1,
+      shouldDoubleInvokeUserFnsInHooksDEV = !1,
+      thenableIndexCounter$1 = 0,
+      thenableState$1 = null,
+      globalClientIdCounter = 0,
+      RE_RENDER_LIMIT = 25,
+      currentHookNameInDev = null,
+      hookTypesDev = null,
+      hookTypesUpdateIndexDev = -1,
+      ignorePreviousDependencies = !1,
+      ContextOnlyDispatcher = {
+        readContext: _readContext,
+        use: _use,
+        useCallback: throwInvalidHookError,
+        useContext: throwInvalidHookError,
+        useEffect: throwInvalidHookError,
+        useImperativeHandle: throwInvalidHookError,
+        useLayoutEffect: throwInvalidHookError,
+        useInsertionEffect: throwInvalidHookError,
+        useMemo: throwInvalidHookError,
+        useReducer: throwInvalidHookError,
+        useRef: throwInvalidHookError,
+        useState: throwInvalidHookError,
+        useDebugValue: throwInvalidHookError,
+        useDeferredValue: throwInvalidHookError,
+        useTransition: throwInvalidHookError,
+        useSyncExternalStore: throwInvalidHookError,
+        useId: throwInvalidHookError,
+        useHostTransitionStatus: throwInvalidHookError,
+        useFormState: throwInvalidHookError,
+        useActionState: throwInvalidHookError,
+        useOptimistic: throwInvalidHookError,
+        useMemoCache: throwInvalidHookError,
+        useCacheRefresh: throwInvalidHookError
+      },
+      HooksDispatcherOnMountInDEV = null,
+      HooksDispatcherOnMountWithHookTypesInDEV = null,
+      HooksDispatcherOnUpdateInDEV = null,
+      HooksDispatcherOnRerenderInDEV = null,
+      InvalidNestedHooksDispatcherOnMountInDEV = null,
+      InvalidNestedHooksDispatcherOnUpdateInDEV = null,
+      InvalidNestedHooksDispatcherOnRerenderInDEV = null;
+    HooksDispatcherOnMountInDEV = {
+      readContext: function readContext(context) {
+        return _readContext(context);
+      },
+      use: _use,
+      useCallback: function useCallback(callback, deps) {
+        currentHookNameInDev = "useCallback";
+        mountHookTypesDev();
+        checkDepsAreArrayDev(deps);
+        return mountCallback(callback, deps);
+      },
+      useContext: function useContext(context) {
+        currentHookNameInDev = "useContext";
+        mountHookTypesDev();
+        return _readContext(context);
+      },
+      useEffect: function useEffect(create, createDeps) {
+        currentHookNameInDev = "useEffect";
+        mountHookTypesDev();
+        checkDepsAreArrayDev(createDeps);
+        return mountEffect(create, createDeps);
+      },
+      useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+        currentHookNameInDev = "useImperativeHandle";
+        mountHookTypesDev();
+        checkDepsAreArrayDev(deps);
+        return mountImperativeHandle(ref, create, deps);
+      },
+      useInsertionEffect: function useInsertionEffect(create, deps) {
+        currentHookNameInDev = "useInsertionEffect";
+        mountHookTypesDev();
+        checkDepsAreArrayDev(deps);
+        mountEffectImpl(4, Insertion, create, deps);
+      },
+      useLayoutEffect: function useLayoutEffect(create, deps) {
+        currentHookNameInDev = "useLayoutEffect";
+        mountHookTypesDev();
+        checkDepsAreArrayDev(deps);
+        return mountLayoutEffect(create, deps);
+      },
+      useMemo: function useMemo(create, deps) {
+        currentHookNameInDev = "useMemo";
+        mountHookTypesDev();
+        checkDepsAreArrayDev(deps);
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
+        try {
+          return mountMemo(create, deps);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useReducer: function useReducer(reducer, initialArg, init) {
+        currentHookNameInDev = "useReducer";
+        mountHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
+        try {
+          return mountReducer(reducer, initialArg, init);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useRef: function useRef(initialValue) {
+        currentHookNameInDev = "useRef";
+        mountHookTypesDev();
+        return mountRef(initialValue);
+      },
+      useState: function useState(initialState) {
+        currentHookNameInDev = "useState";
+        mountHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
+        try {
+          return mountState(initialState);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useDebugValue: function useDebugValue() {
+        currentHookNameInDev = "useDebugValue";
+        mountHookTypesDev();
+      },
+      useDeferredValue: function useDeferredValue(value, initialValue) {
+        currentHookNameInDev = "useDeferredValue";
+        mountHookTypesDev();
+        return mountDeferredValue(value, initialValue);
+      },
+      useTransition: function useTransition() {
+        currentHookNameInDev = "useTransition";
+        mountHookTypesDev();
+        return mountTransition();
+      },
+      useSyncExternalStore: function useSyncExternalStore(subscribe, getSnapshot) {
+        currentHookNameInDev = "useSyncExternalStore";
+        mountHookTypesDev();
+        return mountSyncExternalStore(subscribe, getSnapshot);
+      },
+      useId: function useId() {
+        currentHookNameInDev = "useId";
+        mountHookTypesDev();
+        return mountId();
+      },
+      useFormState: function useFormState(action, initialState) {
+        currentHookNameInDev = "useFormState";
+        mountHookTypesDev();
+        warnOnUseFormStateInDev();
+        return mountActionState(action, initialState);
+      },
+      useActionState: function useActionState(action, initialState) {
+        currentHookNameInDev = "useActionState";
+        mountHookTypesDev();
+        return mountActionState(action, initialState);
+      },
+      useOptimistic: function useOptimistic(passthrough) {
+        currentHookNameInDev = "useOptimistic";
+        mountHookTypesDev();
+        return mountOptimistic(passthrough);
+      },
+      useHostTransitionStatus: useHostTransitionStatus,
+      useMemoCache: _useMemoCache,
+      useCacheRefresh: function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        mountHookTypesDev();
+        return mountRefresh();
+      }
+    };
+    HooksDispatcherOnMountWithHookTypesInDEV = {
+      readContext: function readContext(context) {
+        return _readContext(context);
+      },
+      use: _use,
+      useCallback: function useCallback(callback, deps) {
+        currentHookNameInDev = "useCallback";
+        updateHookTypesDev();
+        return mountCallback(callback, deps);
+      },
+      useContext: function useContext(context) {
+        currentHookNameInDev = "useContext";
+        updateHookTypesDev();
+        return _readContext(context);
+      },
+      useEffect: function useEffect(create, createDeps) {
+        currentHookNameInDev = "useEffect";
+        updateHookTypesDev();
+        return mountEffect(create, createDeps);
+      },
+      useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+        currentHookNameInDev = "useImperativeHandle";
+        updateHookTypesDev();
+        return mountImperativeHandle(ref, create, deps);
+      },
+      useInsertionEffect: function useInsertionEffect(create, deps) {
+        currentHookNameInDev = "useInsertionEffect";
+        updateHookTypesDev();
+        mountEffectImpl(4, Insertion, create, deps);
+      },
+      useLayoutEffect: function useLayoutEffect(create, deps) {
+        currentHookNameInDev = "useLayoutEffect";
+        updateHookTypesDev();
+        return mountLayoutEffect(create, deps);
+      },
+      useMemo: function useMemo(create, deps) {
+        currentHookNameInDev = "useMemo";
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
+        try {
+          return mountMemo(create, deps);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useReducer: function useReducer(reducer, initialArg, init) {
+        currentHookNameInDev = "useReducer";
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
+        try {
+          return mountReducer(reducer, initialArg, init);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useRef: function useRef(initialValue) {
+        currentHookNameInDev = "useRef";
+        updateHookTypesDev();
+        return mountRef(initialValue);
+      },
+      useState: function useState(initialState) {
+        currentHookNameInDev = "useState";
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
+        try {
+          return mountState(initialState);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useDebugValue: function useDebugValue() {
+        currentHookNameInDev = "useDebugValue";
+        updateHookTypesDev();
+      },
+      useDeferredValue: function useDeferredValue(value, initialValue) {
+        currentHookNameInDev = "useDeferredValue";
+        updateHookTypesDev();
+        return mountDeferredValue(value, initialValue);
+      },
+      useTransition: function useTransition() {
+        currentHookNameInDev = "useTransition";
+        updateHookTypesDev();
+        return mountTransition();
+      },
+      useSyncExternalStore: function useSyncExternalStore(subscribe, getSnapshot) {
+        currentHookNameInDev = "useSyncExternalStore";
+        updateHookTypesDev();
+        return mountSyncExternalStore(subscribe, getSnapshot);
+      },
+      useId: function useId() {
+        currentHookNameInDev = "useId";
+        updateHookTypesDev();
+        return mountId();
+      },
+      useActionState: function useActionState(action, initialState) {
+        currentHookNameInDev = "useActionState";
+        updateHookTypesDev();
+        return mountActionState(action, initialState);
+      },
+      useFormState: function useFormState(action, initialState) {
+        currentHookNameInDev = "useFormState";
+        updateHookTypesDev();
+        warnOnUseFormStateInDev();
+        return mountActionState(action, initialState);
+      },
+      useOptimistic: function useOptimistic(passthrough) {
+        currentHookNameInDev = "useOptimistic";
+        updateHookTypesDev();
+        return mountOptimistic(passthrough);
+      },
+      useHostTransitionStatus: useHostTransitionStatus,
+      useMemoCache: _useMemoCache,
+      useCacheRefresh: function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        updateHookTypesDev();
+        return mountRefresh();
+      }
+    };
+    HooksDispatcherOnUpdateInDEV = {
+      readContext: function readContext(context) {
+        return _readContext(context);
+      },
+      use: _use,
+      useCallback: function useCallback(callback, deps) {
+        currentHookNameInDev = "useCallback";
+        updateHookTypesDev();
+        return updateCallback(callback, deps);
+      },
+      useContext: function useContext(context) {
+        currentHookNameInDev = "useContext";
+        updateHookTypesDev();
+        return _readContext(context);
+      },
+      useEffect: function useEffect(create, createDeps) {
+        currentHookNameInDev = "useEffect";
+        updateHookTypesDev();
+        updateEffectImpl(2048, Passive, create, createDeps);
+      },
+      useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+        currentHookNameInDev = "useImperativeHandle";
+        updateHookTypesDev();
+        return updateImperativeHandle(ref, create, deps);
+      },
+      useInsertionEffect: function useInsertionEffect(create, deps) {
+        currentHookNameInDev = "useInsertionEffect";
+        updateHookTypesDev();
+        return updateEffectImpl(4, Insertion, create, deps);
+      },
+      useLayoutEffect: function useLayoutEffect(create, deps) {
+        currentHookNameInDev = "useLayoutEffect";
+        updateHookTypesDev();
+        return updateEffectImpl(4, Layout, create, deps);
+      },
+      useMemo: function useMemo(create, deps) {
+        currentHookNameInDev = "useMemo";
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
+        try {
+          return updateMemo(create, deps);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useReducer: function useReducer(reducer, initialArg, init) {
+        currentHookNameInDev = "useReducer";
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
+        try {
+          return updateReducer(reducer, initialArg, init);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useRef: function useRef() {
+        currentHookNameInDev = "useRef";
+        updateHookTypesDev();
+        return updateWorkInProgressHook().memoizedState;
+      },
+      useState: function useState() {
+        currentHookNameInDev = "useState";
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
+        try {
+          return updateReducer(basicStateReducer);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useDebugValue: function useDebugValue() {
+        currentHookNameInDev = "useDebugValue";
+        updateHookTypesDev();
+      },
+      useDeferredValue: function useDeferredValue(value, initialValue) {
+        currentHookNameInDev = "useDeferredValue";
+        updateHookTypesDev();
+        return updateDeferredValue(value, initialValue);
+      },
+      useTransition: function useTransition() {
+        currentHookNameInDev = "useTransition";
+        updateHookTypesDev();
+        return updateTransition();
+      },
+      useSyncExternalStore: function useSyncExternalStore(subscribe, getSnapshot) {
+        currentHookNameInDev = "useSyncExternalStore";
+        updateHookTypesDev();
+        return updateSyncExternalStore(subscribe, getSnapshot);
+      },
+      useId: function useId() {
+        currentHookNameInDev = "useId";
+        updateHookTypesDev();
+        return updateWorkInProgressHook().memoizedState;
+      },
+      useFormState: function useFormState(action) {
+        currentHookNameInDev = "useFormState";
+        updateHookTypesDev();
+        warnOnUseFormStateInDev();
+        return updateActionState(action);
+      },
+      useActionState: function useActionState(action) {
+        currentHookNameInDev = "useActionState";
+        updateHookTypesDev();
+        return updateActionState(action);
+      },
+      useOptimistic: function useOptimistic(passthrough, reducer) {
+        currentHookNameInDev = "useOptimistic";
+        updateHookTypesDev();
+        return updateOptimistic(passthrough, reducer);
+      },
+      useHostTransitionStatus: useHostTransitionStatus,
+      useMemoCache: _useMemoCache,
+      useCacheRefresh: function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        updateHookTypesDev();
+        return updateWorkInProgressHook().memoizedState;
+      }
+    };
+    HooksDispatcherOnRerenderInDEV = {
+      readContext: function readContext(context) {
+        return _readContext(context);
+      },
+      use: _use,
+      useCallback: function useCallback(callback, deps) {
+        currentHookNameInDev = "useCallback";
+        updateHookTypesDev();
+        return updateCallback(callback, deps);
+      },
+      useContext: function useContext(context) {
+        currentHookNameInDev = "useContext";
+        updateHookTypesDev();
+        return _readContext(context);
+      },
+      useEffect: function useEffect(create, createDeps) {
+        currentHookNameInDev = "useEffect";
+        updateHookTypesDev();
+        updateEffectImpl(2048, Passive, create, createDeps);
+      },
+      useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+        currentHookNameInDev = "useImperativeHandle";
+        updateHookTypesDev();
+        return updateImperativeHandle(ref, create, deps);
+      },
+      useInsertionEffect: function useInsertionEffect(create, deps) {
+        currentHookNameInDev = "useInsertionEffect";
+        updateHookTypesDev();
+        return updateEffectImpl(4, Insertion, create, deps);
+      },
+      useLayoutEffect: function useLayoutEffect(create, deps) {
+        currentHookNameInDev = "useLayoutEffect";
+        updateHookTypesDev();
+        return updateEffectImpl(4, Layout, create, deps);
+      },
+      useMemo: function useMemo(create, deps) {
+        currentHookNameInDev = "useMemo";
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnRerenderInDEV;
+        try {
+          return updateMemo(create, deps);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useReducer: function useReducer(reducer, initialArg, init) {
+        currentHookNameInDev = "useReducer";
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnRerenderInDEV;
+        try {
+          return rerenderReducer(reducer, initialArg, init);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useRef: function useRef() {
+        currentHookNameInDev = "useRef";
+        updateHookTypesDev();
+        return updateWorkInProgressHook().memoizedState;
+      },
+      useState: function useState() {
+        currentHookNameInDev = "useState";
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnRerenderInDEV;
+        try {
+          return rerenderReducer(basicStateReducer);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useDebugValue: function useDebugValue() {
+        currentHookNameInDev = "useDebugValue";
+        updateHookTypesDev();
+      },
+      useDeferredValue: function useDeferredValue(value, initialValue) {
+        currentHookNameInDev = "useDeferredValue";
+        updateHookTypesDev();
+        return rerenderDeferredValue(value, initialValue);
+      },
+      useTransition: function useTransition() {
+        currentHookNameInDev = "useTransition";
+        updateHookTypesDev();
+        return rerenderTransition();
+      },
+      useSyncExternalStore: function useSyncExternalStore(subscribe, getSnapshot) {
+        currentHookNameInDev = "useSyncExternalStore";
+        updateHookTypesDev();
+        return updateSyncExternalStore(subscribe, getSnapshot);
+      },
+      useId: function useId() {
+        currentHookNameInDev = "useId";
+        updateHookTypesDev();
+        return updateWorkInProgressHook().memoizedState;
+      },
+      useFormState: function useFormState(action) {
+        currentHookNameInDev = "useFormState";
+        updateHookTypesDev();
+        warnOnUseFormStateInDev();
+        return rerenderActionState(action);
+      },
+      useActionState: function useActionState(action) {
+        currentHookNameInDev = "useActionState";
+        updateHookTypesDev();
+        return rerenderActionState(action);
+      },
+      useOptimistic: function useOptimistic(passthrough, reducer) {
+        currentHookNameInDev = "useOptimistic";
+        updateHookTypesDev();
+        return rerenderOptimistic(passthrough, reducer);
+      },
+      useHostTransitionStatus: useHostTransitionStatus,
+      useMemoCache: _useMemoCache,
+      useCacheRefresh: function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        updateHookTypesDev();
+        return updateWorkInProgressHook().memoizedState;
+      }
+    };
+    InvalidNestedHooksDispatcherOnMountInDEV = {
+      readContext: function readContext(context) {
+        warnInvalidContextAccess();
+        return _readContext(context);
+      },
+      use: function use(usable) {
+        warnInvalidHookAccess();
+        return _use(usable);
+      },
+      useCallback: function useCallback(callback, deps) {
+        currentHookNameInDev = "useCallback";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountCallback(callback, deps);
+      },
+      useContext: function useContext(context) {
+        currentHookNameInDev = "useContext";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return _readContext(context);
+      },
+      useEffect: function useEffect(create, createDeps) {
+        currentHookNameInDev = "useEffect";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountEffect(create, createDeps);
+      },
+      useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+        currentHookNameInDev = "useImperativeHandle";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountImperativeHandle(ref, create, deps);
+      },
+      useInsertionEffect: function useInsertionEffect(create, deps) {
+        currentHookNameInDev = "useInsertionEffect";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        mountEffectImpl(4, Insertion, create, deps);
+      },
+      useLayoutEffect: function useLayoutEffect(create, deps) {
+        currentHookNameInDev = "useLayoutEffect";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountLayoutEffect(create, deps);
+      },
+      useMemo: function useMemo(create, deps) {
+        currentHookNameInDev = "useMemo";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
+        try {
+          return mountMemo(create, deps);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useReducer: function useReducer(reducer, initialArg, init) {
+        currentHookNameInDev = "useReducer";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
+        try {
+          return mountReducer(reducer, initialArg, init);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useRef: function useRef(initialValue) {
+        currentHookNameInDev = "useRef";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountRef(initialValue);
+      },
+      useState: function useState(initialState) {
+        currentHookNameInDev = "useState";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
+        try {
+          return mountState(initialState);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useDebugValue: function useDebugValue() {
+        currentHookNameInDev = "useDebugValue";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+      },
+      useDeferredValue: function useDeferredValue(value, initialValue) {
+        currentHookNameInDev = "useDeferredValue";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountDeferredValue(value, initialValue);
+      },
+      useTransition: function useTransition() {
+        currentHookNameInDev = "useTransition";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountTransition();
+      },
+      useSyncExternalStore: function useSyncExternalStore(subscribe, getSnapshot) {
+        currentHookNameInDev = "useSyncExternalStore";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountSyncExternalStore(subscribe, getSnapshot);
+      },
+      useId: function useId() {
+        currentHookNameInDev = "useId";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountId();
+      },
+      useFormState: function useFormState(action, initialState) {
+        currentHookNameInDev = "useFormState";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountActionState(action, initialState);
+      },
+      useActionState: function useActionState(action, initialState) {
+        currentHookNameInDev = "useActionState";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountActionState(action, initialState);
+      },
+      useOptimistic: function useOptimistic(passthrough) {
+        currentHookNameInDev = "useOptimistic";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountOptimistic(passthrough);
+      },
+      useMemoCache: function useMemoCache(size) {
+        warnInvalidHookAccess();
+        return _useMemoCache(size);
+      },
+      useHostTransitionStatus: useHostTransitionStatus,
+      useCacheRefresh: function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        mountHookTypesDev();
+        return mountRefresh();
+      }
+    };
+    InvalidNestedHooksDispatcherOnUpdateInDEV = {
+      readContext: function readContext(context) {
+        warnInvalidContextAccess();
+        return _readContext(context);
+      },
+      use: function use(usable) {
+        warnInvalidHookAccess();
+        return _use(usable);
+      },
+      useCallback: function useCallback(callback, deps) {
+        currentHookNameInDev = "useCallback";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateCallback(callback, deps);
+      },
+      useContext: function useContext(context) {
+        currentHookNameInDev = "useContext";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return _readContext(context);
+      },
+      useEffect: function useEffect(create, createDeps) {
+        currentHookNameInDev = "useEffect";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        updateEffectImpl(2048, Passive, create, createDeps);
+      },
+      useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+        currentHookNameInDev = "useImperativeHandle";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateImperativeHandle(ref, create, deps);
+      },
+      useInsertionEffect: function useInsertionEffect(create, deps) {
+        currentHookNameInDev = "useInsertionEffect";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateEffectImpl(4, Insertion, create, deps);
+      },
+      useLayoutEffect: function useLayoutEffect(create, deps) {
+        currentHookNameInDev = "useLayoutEffect";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateEffectImpl(4, Layout, create, deps);
+      },
+      useMemo: function useMemo(create, deps) {
+        currentHookNameInDev = "useMemo";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
+        try {
+          return updateMemo(create, deps);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useReducer: function useReducer(reducer, initialArg, init) {
+        currentHookNameInDev = "useReducer";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
+        try {
+          return updateReducer(reducer, initialArg, init);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useRef: function useRef() {
+        currentHookNameInDev = "useRef";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateWorkInProgressHook().memoizedState;
+      },
+      useState: function useState() {
+        currentHookNameInDev = "useState";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
+        try {
+          return updateReducer(basicStateReducer);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useDebugValue: function useDebugValue() {
+        currentHookNameInDev = "useDebugValue";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+      },
+      useDeferredValue: function useDeferredValue(value, initialValue) {
+        currentHookNameInDev = "useDeferredValue";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateDeferredValue(value, initialValue);
+      },
+      useTransition: function useTransition() {
+        currentHookNameInDev = "useTransition";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateTransition();
+      },
+      useSyncExternalStore: function useSyncExternalStore(subscribe, getSnapshot) {
+        currentHookNameInDev = "useSyncExternalStore";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateSyncExternalStore(subscribe, getSnapshot);
+      },
+      useId: function useId() {
+        currentHookNameInDev = "useId";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateWorkInProgressHook().memoizedState;
+      },
+      useFormState: function useFormState(action) {
+        currentHookNameInDev = "useFormState";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateActionState(action);
+      },
+      useActionState: function useActionState(action) {
+        currentHookNameInDev = "useActionState";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateActionState(action);
+      },
+      useOptimistic: function useOptimistic(passthrough, reducer) {
+        currentHookNameInDev = "useOptimistic";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateOptimistic(passthrough, reducer);
+      },
+      useMemoCache: function useMemoCache(size) {
+        warnInvalidHookAccess();
+        return _useMemoCache(size);
+      },
+      useHostTransitionStatus: useHostTransitionStatus,
+      useCacheRefresh: function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        updateHookTypesDev();
+        return updateWorkInProgressHook().memoizedState;
+      }
+    };
+    InvalidNestedHooksDispatcherOnRerenderInDEV = {
+      readContext: function readContext(context) {
+        warnInvalidContextAccess();
+        return _readContext(context);
+      },
+      use: function use(usable) {
+        warnInvalidHookAccess();
+        return _use(usable);
+      },
+      useCallback: function useCallback(callback, deps) {
+        currentHookNameInDev = "useCallback";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateCallback(callback, deps);
+      },
+      useContext: function useContext(context) {
+        currentHookNameInDev = "useContext";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return _readContext(context);
+      },
+      useEffect: function useEffect(create, createDeps) {
+        currentHookNameInDev = "useEffect";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        updateEffectImpl(2048, Passive, create, createDeps);
+      },
+      useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+        currentHookNameInDev = "useImperativeHandle";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateImperativeHandle(ref, create, deps);
+      },
+      useInsertionEffect: function useInsertionEffect(create, deps) {
+        currentHookNameInDev = "useInsertionEffect";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateEffectImpl(4, Insertion, create, deps);
+      },
+      useLayoutEffect: function useLayoutEffect(create, deps) {
+        currentHookNameInDev = "useLayoutEffect";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateEffectImpl(4, Layout, create, deps);
+      },
+      useMemo: function useMemo(create, deps) {
+        currentHookNameInDev = "useMemo";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
+        try {
+          return updateMemo(create, deps);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useReducer: function useReducer(reducer, initialArg, init) {
+        currentHookNameInDev = "useReducer";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
+        try {
+          return rerenderReducer(reducer, initialArg, init);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useRef: function useRef() {
+        currentHookNameInDev = "useRef";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateWorkInProgressHook().memoizedState;
+      },
+      useState: function useState() {
+        currentHookNameInDev = "useState";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
+        try {
+          return rerenderReducer(basicStateReducer);
+        } finally {
+          ReactSharedInternals.H = prevDispatcher;
+        }
+      },
+      useDebugValue: function useDebugValue() {
+        currentHookNameInDev = "useDebugValue";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+      },
+      useDeferredValue: function useDeferredValue(value, initialValue) {
+        currentHookNameInDev = "useDeferredValue";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return rerenderDeferredValue(value, initialValue);
+      },
+      useTransition: function useTransition() {
+        currentHookNameInDev = "useTransition";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return rerenderTransition();
+      },
+      useSyncExternalStore: function useSyncExternalStore(subscribe, getSnapshot) {
+        currentHookNameInDev = "useSyncExternalStore";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateSyncExternalStore(subscribe, getSnapshot);
+      },
+      useId: function useId() {
+        currentHookNameInDev = "useId";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateWorkInProgressHook().memoizedState;
+      },
+      useFormState: function useFormState(action) {
+        currentHookNameInDev = "useFormState";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return rerenderActionState(action);
+      },
+      useActionState: function useActionState(action) {
+        currentHookNameInDev = "useActionState";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return rerenderActionState(action);
+      },
+      useOptimistic: function useOptimistic(passthrough, reducer) {
+        currentHookNameInDev = "useOptimistic";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return rerenderOptimistic(passthrough, reducer);
+      },
+      useMemoCache: function useMemoCache(size) {
+        warnInvalidHookAccess();
+        return _useMemoCache(size);
+      },
+      useHostTransitionStatus: useHostTransitionStatus,
+      useCacheRefresh: function useCacheRefresh() {
+        currentHookNameInDev = "useCacheRefresh";
+        updateHookTypesDev();
+        return updateWorkInProgressHook().memoizedState;
+      }
+    };
+    var callComponent = {
+        "react-stack-bottom-frame": function reactStackBottomFrame(Component, props, secondArg) {
+          var wasRendering = isRendering;
+          isRendering = !0;
+          try {
+            return Component(props, secondArg);
+          } finally {
+            isRendering = wasRendering;
+          }
+        }
+      },
+      callComponentInDEV = callComponent["react-stack-bottom-frame"].bind(callComponent),
+      callRender = {
+        "react-stack-bottom-frame": function reactStackBottomFrame(instance) {
+          var wasRendering = isRendering;
+          isRendering = !0;
+          try {
+            return instance.render();
+          } finally {
+            isRendering = wasRendering;
+          }
+        }
+      },
+      callRenderInDEV = callRender["react-stack-bottom-frame"].bind(callRender),
+      callComponentDidMount = {
+        "react-stack-bottom-frame": function reactStackBottomFrame(finishedWork, instance) {
+          try {
+            instance.componentDidMount();
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      },
+      callComponentDidMountInDEV = callComponentDidMount["react-stack-bottom-frame"].bind(callComponentDidMount),
+      callComponentDidUpdate = {
+        "react-stack-bottom-frame": function reactStackBottomFrame(finishedWork, instance, prevProps, prevState, snapshot) {
+          try {
+            instance.componentDidUpdate(prevProps, prevState, snapshot);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      },
+      callComponentDidUpdateInDEV = callComponentDidUpdate["react-stack-bottom-frame"].bind(callComponentDidUpdate),
+      callComponentDidCatch = {
+        "react-stack-bottom-frame": function reactStackBottomFrame(instance, errorInfo) {
+          var stack = errorInfo.stack;
+          instance.componentDidCatch(errorInfo.value, {
+            componentStack: null !== stack ? stack : ""
+          });
+        }
+      },
+      callComponentDidCatchInDEV = callComponentDidCatch["react-stack-bottom-frame"].bind(callComponentDidCatch),
+      callComponentWillUnmount = {
+        "react-stack-bottom-frame": function reactStackBottomFrame(current, nearestMountedAncestor, instance) {
+          try {
+            instance.componentWillUnmount();
+          } catch (error) {
+            captureCommitPhaseError(current, nearestMountedAncestor, error);
+          }
+        }
+      },
+      callComponentWillUnmountInDEV = callComponentWillUnmount["react-stack-bottom-frame"].bind(callComponentWillUnmount),
+      callCreate = {
+        "react-stack-bottom-frame": function reactStackBottomFrame(effect) {
+          null != effect.resourceKind && console.error("Expected only SimpleEffects when enableUseEffectCRUDOverload is disabled, got %s", effect.resourceKind);
+          var create = effect.create;
+          effect = effect.inst;
+          create = create();
+          return effect.destroy = create;
+        }
+      },
+      callCreateInDEV = callCreate["react-stack-bottom-frame"].bind(callCreate),
+      callDestroy = {
+        "react-stack-bottom-frame": function reactStackBottomFrame(current, nearestMountedAncestor, destroy) {
+          try {
+            destroy();
+          } catch (error) {
+            captureCommitPhaseError(current, nearestMountedAncestor, error);
+          }
+        }
+      },
+      callDestroyInDEV = callDestroy["react-stack-bottom-frame"].bind(callDestroy),
+      callLazyInit = {
+        "react-stack-bottom-frame": function reactStackBottomFrame(lazy) {
+          var init = lazy._init;
+          return init(lazy._payload);
+        }
+      },
+      callLazyInitInDEV = callLazyInit["react-stack-bottom-frame"].bind(callLazyInit),
+      thenableState = null,
+      thenableIndexCounter = 0,
+      currentDebugInfo = null,
+      didWarnAboutMaps;
+    var didWarnAboutGenerators = didWarnAboutMaps = !1;
+    var ownerHasKeyUseWarning = {};
+    var ownerHasFunctionTypeWarning = {};
+    var ownerHasSymbolTypeWarning = {};
+    warnForMissingKey = function warnForMissingKey(returnFiber, workInProgress, child) {
+      if (null !== child && "object" === typeof child && child._store && (!child._store.validated && null == child.key || 2 === child._store.validated)) {
+        if ("object" !== typeof child._store) throw Error("React Component in warnForMissingKey should have a _store. This error is likely caused by a bug in React. Please file an issue.");
+        child._store.validated = 1;
+        var componentName = getComponentNameFromFiber(returnFiber),
+          componentKey = componentName || "null";
+        if (!ownerHasKeyUseWarning[componentKey]) {
+          ownerHasKeyUseWarning[componentKey] = !0;
+          child = child._owner;
+          returnFiber = returnFiber._debugOwner;
+          var currentComponentErrorInfo = "";
+          returnFiber && "number" === typeof returnFiber.tag && (componentKey = getComponentNameFromFiber(returnFiber)) && (currentComponentErrorInfo = "\n\nCheck the render method of `" + componentKey + "`.");
+          currentComponentErrorInfo || componentName && (currentComponentErrorInfo = "\n\nCheck the top-level render call using <" + componentName + ">.");
+          var childOwnerAppendix = "";
+          null != child && returnFiber !== child && (componentName = null, "number" === typeof child.tag ? componentName = getComponentNameFromFiber(child) : "string" === typeof child.name && (componentName = child.name), componentName && (childOwnerAppendix = " It was passed a child from " + componentName + "."));
+          runWithFiberInDEV(workInProgress, function () {
+            console.error('Each child in a list should have a unique "key" prop.%s%s See https://react.dev/link/warning-keys for more information.', currentComponentErrorInfo, childOwnerAppendix);
+          });
+        }
+      }
+    };
+    var reconcileChildFibers = createChildReconciler(!0),
+      mountChildFibers = createChildReconciler(!1),
+      suspenseHandlerStackCursor = createCursor(null),
+      shellBoundary = null,
+      SubtreeSuspenseContextMask = 1,
+      ForceSuspenseFallback = 2,
+      suspenseStackCursor = createCursor(0),
+      fakeInternalInstance = {};
+    var didWarnAboutStateAssignmentForComponent = new Set();
+    var didWarnAboutUninitializedState = new Set();
+    var didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = new Set();
+    var didWarnAboutLegacyLifecyclesAndDerivedState = new Set();
+    var didWarnAboutDirectlyAssigningPropsToState = new Set();
+    var didWarnAboutUndefinedDerivedState = new Set();
+    var didWarnAboutContextTypes$1 = new Set();
+    var didWarnAboutChildContextTypes = new Set();
+    var didWarnAboutInvalidateContextType = new Set();
+    var didWarnOnInvalidCallback = new Set();
+    Object.freeze(fakeInternalInstance);
+    var classComponentUpdater = {
+        enqueueSetState: function enqueueSetState(inst, payload, callback) {
+          inst = inst._reactInternals;
+          var lane = requestUpdateLane(inst),
+            update = createUpdate(lane);
+          update.payload = payload;
+          void 0 !== callback && null !== callback && (warnOnInvalidCallback(callback), update.callback = callback);
+          payload = enqueueUpdate(inst, update, lane);
+          null !== payload && (scheduleUpdateOnFiber(payload, inst, lane), entangleTransitions(payload, inst, lane));
+          markStateUpdateScheduled(inst, lane);
+        },
+        enqueueReplaceState: function enqueueReplaceState(inst, payload, callback) {
+          inst = inst._reactInternals;
+          var lane = requestUpdateLane(inst),
+            update = createUpdate(lane);
+          update.tag = ReplaceState;
+          update.payload = payload;
+          void 0 !== callback && null !== callback && (warnOnInvalidCallback(callback), update.callback = callback);
+          payload = enqueueUpdate(inst, update, lane);
+          null !== payload && (scheduleUpdateOnFiber(payload, inst, lane), entangleTransitions(payload, inst, lane));
+          markStateUpdateScheduled(inst, lane);
+        },
+        enqueueForceUpdate: function enqueueForceUpdate(inst, callback) {
+          inst = inst._reactInternals;
+          var lane = requestUpdateLane(inst),
+            update = createUpdate(lane);
+          update.tag = ForceUpdate;
+          void 0 !== callback && null !== callback && (warnOnInvalidCallback(callback), update.callback = callback);
+          callback = enqueueUpdate(inst, update, lane);
+          null !== callback && (scheduleUpdateOnFiber(callback, inst, lane), entangleTransitions(callback, inst, lane));
+          null !== injectedProfilingHooks && "function" === typeof injectedProfilingHooks.markForceUpdateScheduled && injectedProfilingHooks.markForceUpdateScheduled(inst, lane);
+        }
+      },
+      reportGlobalError = "function" === typeof reportError ? reportError : function (error) {
+        if ("object" === typeof window && "function" === typeof window.ErrorEvent) {
+          var event = new window.ErrorEvent("error", {
+            bubbles: !0,
+            cancelable: !0,
+            message: "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error),
+            error: error
+          });
+          if (!window.dispatchEvent(event)) return;
+        } else if ("object" === typeof process && "function" === typeof process.emit) {
+          process.emit("uncaughtException", error);
+          return;
+        }
+        console.error(error);
+      },
+      componentName = null,
+      errorBoundaryName = null,
+      SelectiveHydrationException = Error("This is not a real error. It's an implementation detail of React's selective hydration feature. If this leaks into userspace, it's a bug in React. Please file an issue."),
+      didReceiveUpdate = !1;
+    var didWarnAboutBadClass = {};
+    var didWarnAboutContextTypeOnFunctionComponent = {};
+    var didWarnAboutContextTypes = {};
+    var didWarnAboutGetDerivedStateOnFunctionComponent = {};
+    var didWarnAboutReassigningProps = !1;
+    var didWarnAboutRevealOrder = {};
+    var didWarnAboutTailOptions = {};
+    var SUSPENDED_MARKER = {
+        dehydrated: null,
+        treeContext: null,
+        retryLane: 0,
+        hydrationErrors: null
+      },
+      hasWarnedAboutUsingNoValuePropOnContextProvider = !1,
+      didWarnAboutUndefinedSnapshotBeforeUpdate = null;
+    didWarnAboutUndefinedSnapshotBeforeUpdate = new Set();
+    var offscreenSubtreeIsHidden = !1,
+      offscreenSubtreeWasHidden = !1,
+      PossiblyWeakSet = "function" === typeof WeakSet ? WeakSet : Set,
+      nextEffect = null,
+      inProgressLanes = null,
+      inProgressRoot = null,
+      hostParent = null,
+      hostParentIsContainer = !1,
+      suspenseyCommitFlag = 8192,
+      DefaultAsyncDispatcher = {
+        getCacheForType: function getCacheForType(resourceType) {
+          var cache = _readContext(CacheContext),
+            cacheForType = cache.data.get(resourceType);
+          void 0 === cacheForType && (cacheForType = resourceType(), cache.data.set(resourceType, cacheForType));
+          return cacheForType;
+        },
+        getOwner: function getOwner() {
+          return current;
+        }
+      };
+    if ("function" === typeof Symbol && Symbol.for) {
+      var symbolFor = Symbol.for;
+      symbolFor("selector.component");
+      symbolFor("selector.has_pseudo_class");
+      symbolFor("selector.role");
+      symbolFor("selector.test_id");
+      symbolFor("selector.text");
+    }
+    var PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map,
+      NoContext = 0,
+      RenderContext = 2,
+      CommitContext = 4,
+      RootInProgress = 0,
+      RootFatalErrored = 1,
+      RootErrored = 2,
+      RootSuspended = 3,
+      RootSuspendedWithDelay = 4,
+      RootSuspendedAtTheShell = 6,
+      RootCompleted = 5,
+      executionContext = NoContext,
+      workInProgressRoot = null,
+      workInProgress = null,
+      workInProgressRootRenderLanes = 0,
+      NotSuspended = 0,
+      SuspendedOnError = 1,
+      SuspendedOnData = 2,
+      SuspendedOnImmediate = 3,
+      SuspendedOnInstance = 4,
+      SuspendedOnInstanceAndReadyToContinue = 5,
+      SuspendedOnDeprecatedThrowPromise = 6,
+      SuspendedAndReadyToContinue = 7,
+      SuspendedOnHydration = 8,
+      SuspendedOnAction = 9,
+      workInProgressSuspendedReason = NotSuspended,
+      workInProgressThrownValue = null,
+      workInProgressRootDidSkipSuspendedSiblings = !1,
+      workInProgressRootIsPrerendering = !1,
+      workInProgressRootDidAttachPingListener = !1,
+      entangledRenderLanes = 0,
+      workInProgressRootExitStatus = RootInProgress,
+      workInProgressRootSkippedLanes = 0,
+      workInProgressRootInterleavedUpdatedLanes = 0,
+      workInProgressRootPingedLanes = 0,
+      workInProgressDeferredLane = 0,
+      workInProgressSuspendedRetryLanes = 0,
+      workInProgressRootConcurrentErrors = null,
+      workInProgressRootRecoverableErrors = null,
+      workInProgressRootDidIncludeRecursiveRenderUpdate = !1,
+      globalMostRecentFallbackTime = 0,
+      FALLBACK_THROTTLE_MS = 300,
+      workInProgressRootRenderTargetTime = Infinity,
+      RENDER_TIMEOUT_MS = 500,
+      workInProgressTransitions = null,
+      legacyErrorBoundariesThatAlreadyFailed = null,
+      IMMEDIATE_COMMIT = 0,
+      THROTTLED_COMMIT = 2,
+      NO_PENDING_EFFECTS = 0,
+      PENDING_MUTATION_PHASE = 1,
+      PENDING_LAYOUT_PHASE = 2,
+      PENDING_AFTER_MUTATION_PHASE = 3,
+      PENDING_SPAWNED_WORK = 4,
+      PENDING_PASSIVE_PHASE = 5,
+      pendingEffectsStatus = 0,
+      pendingEffectsRoot = null,
+      pendingFinishedWork = null,
+      pendingEffectsLanes = 0,
+      pendingEffectsRemainingLanes = 0,
+      pendingPassiveTransitions = null,
+      pendingRecoverableErrors = null,
+      NESTED_UPDATE_LIMIT = 50,
+      nestedUpdateCount = 0,
+      rootWithNestedUpdates = null,
+      isFlushingPassiveEffects = !1,
+      didScheduleUpdateDuringPassiveEffects = !1,
+      NESTED_PASSIVE_UPDATE_LIMIT = 50,
+      nestedPassiveUpdateCount = 0,
+      rootWithPassiveNestedUpdates = null,
+      isRunningInsertionEffect = !1,
+      didWarnStateUpdateForNotYetMountedComponent = null,
+      didWarnAboutUpdateInRender = !1;
+    var didWarnAboutUpdateInRenderForAnotherComponent = new Set();
+    var fakeActCallbackNode = {},
+      resolveFamily = null,
+      failedBoundaries = null;
+    var hasBadMapPolyfill = !1;
+    try {
+      var nonExtensibleObject = Object.preventExtensions({});
+      new Map([[nonExtensibleObject, null]]);
+      new Set([nonExtensibleObject]);
+    } catch (e) {
+      hasBadMapPolyfill = !0;
+    }
+    var didWarnAboutNestedUpdates = !1;
+    var didWarnAboutFindNodeInStrictMode = {};
+    var overrideHookState = null,
+      overrideHookStateDeletePath = null,
+      overrideHookStateRenamePath = null,
+      overrideProps = null,
+      overridePropsDeletePath = null,
+      overridePropsRenamePath = null,
+      scheduleUpdate = null,
+      setErrorHandler = null,
+      setSuspenseHandler = null;
+    overrideHookState = function overrideHookState(fiber, id, path, value) {
+      id = findHook(fiber, id);
+      null !== id && (path = copyWithSetImpl(id.memoizedState, path, 0, value), id.memoizedState = path, id.baseState = path, fiber.memoizedProps = assign({}, fiber.memoizedProps), path = enqueueConcurrentRenderForLane(fiber, 2), null !== path && scheduleUpdateOnFiber(path, fiber, 2));
+    };
+    overrideHookStateDeletePath = function overrideHookStateDeletePath(fiber, id, path) {
+      id = findHook(fiber, id);
+      null !== id && (path = copyWithDeleteImpl(id.memoizedState, path, 0), id.memoizedState = path, id.baseState = path, fiber.memoizedProps = assign({}, fiber.memoizedProps), path = enqueueConcurrentRenderForLane(fiber, 2), null !== path && scheduleUpdateOnFiber(path, fiber, 2));
+    };
+    overrideHookStateRenamePath = function overrideHookStateRenamePath(fiber, id, oldPath, newPath) {
+      id = findHook(fiber, id);
+      null !== id && (oldPath = copyWithRename(id.memoizedState, oldPath, newPath), id.memoizedState = oldPath, id.baseState = oldPath, fiber.memoizedProps = assign({}, fiber.memoizedProps), oldPath = enqueueConcurrentRenderForLane(fiber, 2), null !== oldPath && scheduleUpdateOnFiber(oldPath, fiber, 2));
+    };
+    overrideProps = function overrideProps(fiber, path, value) {
+      fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path, 0, value);
+      fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
+      path = enqueueConcurrentRenderForLane(fiber, 2);
+      null !== path && scheduleUpdateOnFiber(path, fiber, 2);
+    };
+    overridePropsDeletePath = function overridePropsDeletePath(fiber, path) {
+      fiber.pendingProps = copyWithDeleteImpl(fiber.memoizedProps, path, 0);
+      fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
+      path = enqueueConcurrentRenderForLane(fiber, 2);
+      null !== path && scheduleUpdateOnFiber(path, fiber, 2);
+    };
+    overridePropsRenamePath = function overridePropsRenamePath(fiber, oldPath, newPath) {
+      fiber.pendingProps = copyWithRename(fiber.memoizedProps, oldPath, newPath);
+      fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
+      oldPath = enqueueConcurrentRenderForLane(fiber, 2);
+      null !== oldPath && scheduleUpdateOnFiber(oldPath, fiber, 2);
+    };
+    scheduleUpdate = function scheduleUpdate(fiber) {
+      var root = enqueueConcurrentRenderForLane(fiber, 2);
+      null !== root && scheduleUpdateOnFiber(root, fiber, 2);
+    };
+    setErrorHandler = function setErrorHandler(newShouldErrorImpl) {
+      shouldErrorImpl = newShouldErrorImpl;
+    };
+    setSuspenseHandler = function setSuspenseHandler(newShouldSuspendImpl) {
+      shouldSuspendImpl = newShouldSuspendImpl;
+    };
+    var isomorphicReactPackageVersion = React.version;
+    if ("19.1.0" !== isomorphicReactPackageVersion) throw Error('Incompatible React versions: The "react" and "react-native-renderer" packages must have the exact same version. Instead got:\n  - react:                  ' + (isomorphicReactPackageVersion + "\n  - react-native-renderer:  19.1.0\nLearn more: https://react.dev/warnings/version-mismatch"));
+    if ("function" !== typeof ReactNativePrivateInterface.ReactFiberErrorDialog.showErrorDialog) throw Error("Expected ReactFiberErrorDialog.showErrorDialog to be a function.");
+    batchedUpdatesImpl = function batchedUpdatesImpl(fn, a) {
+      var prevExecutionContext = executionContext;
+      executionContext |= 1;
+      try {
+        return fn(a);
+      } finally {
+        executionContext = prevExecutionContext, executionContext !== NoContext || ReactSharedInternals.isBatchingLegacy || (workInProgressRootRenderTargetTime = now$1() + RENDER_TIMEOUT_MS, flushSyncWorkAcrossRoots_impl(0, !0));
+      }
+    };
+    var roots = new Map();
+    (function () {
+      var internals = {
+        bundleType: 1,
+        version: "19.1.0",
+        rendererPackageName: "react-native-renderer",
+        currentDispatcherRef: ReactSharedInternals,
+        reconcilerVersion: "19.1.0"
+      };
+      null !== extraDevToolsConfig && (internals.rendererConfig = extraDevToolsConfig);
+      internals.overrideHookState = overrideHookState;
+      internals.overrideHookStateDeletePath = overrideHookStateDeletePath;
+      internals.overrideHookStateRenamePath = overrideHookStateRenamePath;
+      internals.overrideProps = overrideProps;
+      internals.overridePropsDeletePath = overridePropsDeletePath;
+      internals.overridePropsRenamePath = overridePropsRenamePath;
+      internals.scheduleUpdate = scheduleUpdate;
+      internals.setErrorHandler = setErrorHandler;
+      internals.setSuspenseHandler = setSuspenseHandler;
+      internals.scheduleRefresh = scheduleRefresh;
+      internals.scheduleRoot = scheduleRoot;
+      internals.setRefreshHandler = setRefreshHandler;
+      internals.getCurrentFiber = getCurrentFiberForDevTools;
+      internals.getLaneLabelMap = getLaneLabelMap;
+      internals.injectProfilingHooks = injectProfilingHooks;
+      return injectInternals(internals);
+    })();
+    exports.createPortal = function (children, containerTag) {
+      return createPortal$1(children, containerTag, null, 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null);
+    };
+    exports.dispatchCommand = function (handle, command, args) {
+      var nativeTag = null != handle._nativeTag ? handle._nativeTag : ReactNativePrivateInterface.getNativeTagFromPublicInstance(handle);
+      null == nativeTag ? console.error("dispatchCommand was called with a ref that isn't a native component. Use React.forwardRef to get access to the underlying native component") : (handle = ReactNativePrivateInterface.getNodeFromPublicInstance(handle), null != handle ? nativeFabricUIManager.dispatchCommand(handle, command, args) : ReactNativePrivateInterface.UIManager.dispatchViewManagerCommand(nativeTag, command, args));
+    };
+    exports.findHostInstance_DEPRECATED = function (componentOrHandle) {
+      var owner = current;
+      null !== owner && isRendering && null !== owner.stateNode && (owner.stateNode._warnedAboutRefsInRender || console.error("%s is accessing findNodeHandle inside its render(). render() should be a pure function of props and state. It should never access something that requires stale data from the previous render, such as refs. Move this logic to componentDidMount and componentDidUpdate instead.", getComponentNameFromType(owner.type) || "A component"), owner.stateNode._warnedAboutRefsInRender = !0);
+      return null == componentOrHandle ? null : componentOrHandle.canonical && componentOrHandle.canonical.publicInstance ? componentOrHandle.canonical.publicInstance : componentOrHandle._nativeTag ? componentOrHandle : findHostInstanceWithWarning(componentOrHandle, "findHostInstance_DEPRECATED");
+    };
+    exports.findNodeHandle = findNodeHandle;
+    exports.isChildPublicInstance = function (parentInstance, childInstance) {
+      if (parentInstance._internalFiberInstanceHandleDEV && childInstance._internalFiberInstanceHandleDEV) return doesFiberContain(parentInstance._internalFiberInstanceHandleDEV, childInstance._internalFiberInstanceHandleDEV);
+      parentInstance = ReactNativePrivateInterface.getInternalInstanceHandleFromPublicInstance(parentInstance);
+      childInstance = ReactNativePrivateInterface.getInternalInstanceHandleFromPublicInstance(childInstance);
+      return null != parentInstance && null != childInstance ? doesFiberContain(parentInstance, childInstance) : !1;
+    };
+    exports.render = function (element, containerTag, callback, options) {
+      var root = roots.get(containerTag);
+      if (!root) {
+        root = nativeOnUncaughtError;
+        var onCaughtError = nativeOnCaughtError,
+          onRecoverableError = defaultOnRecoverableError;
+        options && void 0 !== options.onUncaughtError && (root = options.onUncaughtError);
+        options && void 0 !== options.onCaughtError && (onCaughtError = options.onCaughtError);
+        options && void 0 !== options.onRecoverableError && (onRecoverableError = options.onRecoverableError);
+        options = new FiberRootNode({
+          containerTag: containerTag,
+          publicInstance: null
+        }, 0, !1, "", root, onCaughtError, onRecoverableError, null);
+        root = 0;
+        isDevToolsPresent && (root |= 2);
+        root = createFiber(3, null, null, root);
+        options.current = root;
+        root.stateNode = options;
+        onCaughtError = createCache();
+        retainCache(onCaughtError);
+        options.pooledCache = onCaughtError;
+        retainCache(onCaughtError);
+        root.memoizedState = {
+          element: null,
+          isDehydrated: !1,
+          cache: onCaughtError
+        };
+        initializeUpdateQueue(root);
+        root = options;
+        roots.set(containerTag, root);
+      }
+      updateContainer(element, root, null, callback);
+      a: if (element = root.current, element.child) switch (element.child.tag) {
+        case 27:
+        case 5:
+          element = getPublicInstance(element.child.stateNode);
+          break a;
+        default:
+          element = element.child.stateNode;
+      } else element = null;
+      return element;
+    };
+    exports.sendAccessibilityEvent = function (handle, eventType) {
+      var nativeTag = null != handle._nativeTag ? handle._nativeTag : ReactNativePrivateInterface.getNativeTagFromPublicInstance(handle);
+      null == nativeTag ? console.error("sendAccessibilityEvent was called with a ref that isn't a native component. Use React.forwardRef to get access to the underlying native component") : (handle = ReactNativePrivateInterface.getNodeFromPublicInstance(handle), null != handle ? nativeFabricUIManager.sendAccessibilityEvent(handle, eventType) : ReactNativePrivateInterface.legacySendAccessibilityEvent(nativeTag, eventType));
+    };
+    exports.unmountComponentAtNode = unmountComponentAtNode;
+    exports.unmountComponentAtNodeAndRemoveContainer = function (containerTag) {
+      unmountComponentAtNode(containerTag);
+      ReactNativePrivateInterface.UIManager.removeRootView(containerTag);
+    };
+    exports.unstable_batchedUpdates = batchedUpdates$1;
+    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  }();
+},522,[110,73,322,516],"../../node_modules/react-native/Libraries/Renderer/implementations/ReactNativeRenderer-dev.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  /**
+   * 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.
+   *
+   * 
+   * @nolint
+   * @preventMunge
+   * @generated SignedSource<<43be62d6fc9b622e265e2acb066ed13c>>
+   *
+   * This file was sync'd from the facebook/react repository.
+   */
+
+  "use strict";
+
+  _$$_REQUIRE(_dependencyMap[0], "react-native/Libraries/ReactPrivate/ReactNativePrivateInitializeCore");
+  var React = _$$_REQUIRE(_dependencyMap[1], "react"),
+    isArrayImpl = Array.isArray,
+    ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,
+    assign = Object.assign,
+    prefix,
+    suffix;
+  function describeBuiltInComponentFrame(name) {
+    if (void 0 === prefix) try {
+      throw Error();
+    } catch (x) {
+      var match = x.stack.trim().match(/\n( *(at )?)/);
+      prefix = match && match[1] || "";
+      suffix = -1 < x.stack.indexOf("\n    at") ? " (<anonymous>)" : -1 < x.stack.indexOf("@") ? "@unknown:0:0" : "";
+    }
+    return "\n" + prefix + name + suffix;
+  }
+  var reentry = !1;
+  function describeNativeComponentFrame(fn, construct) {
+    if (!fn || reentry) return "";
+    reentry = !0;
+    var previousPrepareStackTrace = Error.prepareStackTrace;
+    Error.prepareStackTrace = void 0;
+    try {
+      var RunInRootFrame = {
+        DetermineComponentFrameRoot: function DetermineComponentFrameRoot() {
+          try {
+            if (construct) {
+              var Fake = function Fake() {
+                throw Error();
+              };
+              Object.defineProperty(Fake.prototype, "props", {
+                set: function set() {
+                  throw Error();
+                }
+              });
+              if ("object" === typeof Reflect && Reflect.construct) {
+                try {
+                  Reflect.construct(Fake, []);
+                } catch (x) {
+                  var control = x;
+                }
+                Reflect.construct(fn, [], Fake);
+              } else {
+                try {
+                  Fake.call();
+                } catch (x$0) {
+                  control = x$0;
+                }
+                fn.call(Fake.prototype);
+              }
+            } else {
+              try {
+                throw Error();
+              } catch (x$1) {
+                control = x$1;
+              }
+              (Fake = fn()) && "function" === typeof Fake.catch && Fake.catch(function () {});
+            }
+          } catch (sample) {
+            if (sample && control && "string" === typeof sample.stack) return [sample.stack, control.stack];
+          }
+          return [null, null];
+        }
+      };
+      RunInRootFrame.DetermineComponentFrameRoot.displayName = "DetermineComponentFrameRoot";
+      var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, "name");
+      namePropDescriptor && namePropDescriptor.configurable && Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, "name", {
+        value: "DetermineComponentFrameRoot"
+      });
+      var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(),
+        sampleStack = _RunInRootFrame$Deter[0],
+        controlStack = _RunInRootFrame$Deter[1];
+      if (sampleStack && controlStack) {
+        var sampleLines = sampleStack.split("\n"),
+          controlLines = controlStack.split("\n");
+        for (namePropDescriptor = RunInRootFrame = 0; RunInRootFrame < sampleLines.length && !sampleLines[RunInRootFrame].includes("DetermineComponentFrameRoot");) RunInRootFrame++;
+        for (; namePropDescriptor < controlLines.length && !controlLines[namePropDescriptor].includes("DetermineComponentFrameRoot");) namePropDescriptor++;
+        if (RunInRootFrame === sampleLines.length || namePropDescriptor === controlLines.length) for (RunInRootFrame = sampleLines.length - 1, namePropDescriptor = controlLines.length - 1; 1 <= RunInRootFrame && 0 <= namePropDescriptor && sampleLines[RunInRootFrame] !== controlLines[namePropDescriptor];) namePropDescriptor--;
+        for (; 1 <= RunInRootFrame && 0 <= namePropDescriptor; RunInRootFrame--, namePropDescriptor--) if (sampleLines[RunInRootFrame] !== controlLines[namePropDescriptor]) {
+          if (1 !== RunInRootFrame || 1 !== namePropDescriptor) {
+            do if (RunInRootFrame--, namePropDescriptor--, 0 > namePropDescriptor || sampleLines[RunInRootFrame] !== controlLines[namePropDescriptor]) {
+              var frame = "\n" + sampleLines[RunInRootFrame].replace(" at new ", " at ");
+              fn.displayName && frame.includes("<anonymous>") && (frame = frame.replace("<anonymous>", fn.displayName));
+              return frame;
+            } while (1 <= RunInRootFrame && 0 <= namePropDescriptor);
+          }
+          break;
+        }
+      }
+    } finally {
+      reentry = !1, Error.prepareStackTrace = previousPrepareStackTrace;
+    }
+    return (previousPrepareStackTrace = fn ? fn.displayName || fn.name : "") ? describeBuiltInComponentFrame(previousPrepareStackTrace) : "";
+  }
+  function describeFiber(fiber) {
+    switch (fiber.tag) {
+      case 26:
+      case 27:
+      case 5:
+        return describeBuiltInComponentFrame(fiber.type);
+      case 16:
+        return describeBuiltInComponentFrame("Lazy");
+      case 13:
+        return describeBuiltInComponentFrame("Suspense");
+      case 19:
+        return describeBuiltInComponentFrame("SuspenseList");
+      case 0:
+      case 15:
+        return describeNativeComponentFrame(fiber.type, !1);
+      case 11:
+        return describeNativeComponentFrame(fiber.type.render, !1);
+      case 1:
+        return describeNativeComponentFrame(fiber.type, !0);
+      case 31:
+        return describeBuiltInComponentFrame("Activity");
+      default:
+        return "";
+    }
+  }
+  function getStackByFiberInDevAndProd(workInProgress) {
+    try {
+      var info = "";
+      do info += describeFiber(workInProgress), workInProgress = workInProgress.return; while (workInProgress);
+      return info;
+    } catch (x) {
+      return "\nError generating stack: " + x.message + "\n" + x.stack;
+    }
+  }
+  var REACT_LEGACY_ELEMENT_TYPE = Symbol.for("react.element"),
+    REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
+    REACT_PORTAL_TYPE = Symbol.for("react.portal"),
+    REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
+    REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
+    REACT_PROFILER_TYPE = Symbol.for("react.profiler"),
+    REACT_PROVIDER_TYPE = Symbol.for("react.provider"),
+    REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
+    REACT_CONTEXT_TYPE = Symbol.for("react.context"),
+    REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
+    REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
+    REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
+    REACT_MEMO_TYPE = Symbol.for("react.memo"),
+    REACT_LAZY_TYPE = Symbol.for("react.lazy");
+  Symbol.for("react.scope");
+  var REACT_ACTIVITY_TYPE = Symbol.for("react.activity");
+  Symbol.for("react.legacy_hidden");
+  Symbol.for("react.tracing_marker");
+  var REACT_MEMO_CACHE_SENTINEL = Symbol.for("react.memo_cache_sentinel");
+  Symbol.for("react.view_transition");
+  var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+  function getIteratorFn(maybeIterable) {
+    if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
+    maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
+    return "function" === typeof maybeIterable ? maybeIterable : null;
+  }
+  var REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
+  function getComponentNameFromType(type) {
+    if (null == type) return null;
+    if ("function" === typeof type) return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+    if ("string" === typeof type) return type;
+    switch (type) {
+      case REACT_FRAGMENT_TYPE:
+        return "Fragment";
+      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_ACTIVITY_TYPE:
+        return "Activity";
+    }
+    if ("object" === typeof type) switch (type.$$typeof) {
+      case REACT_PORTAL_TYPE:
+        return "Portal";
+      case REACT_CONTEXT_TYPE:
+        return (type.displayName || "Context") + ".Provider";
+      case REACT_CONSUMER_TYPE:
+        return (type._context.displayName || "Context") + ".Consumer";
+      case REACT_FORWARD_REF_TYPE:
+        var innerType = type.render;
+        type = type.displayName;
+        type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
+        return type;
+      case REACT_MEMO_TYPE:
+        return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
+      case REACT_LAZY_TYPE:
+        innerType = type._payload;
+        type = type._init;
+        try {
+          return getComponentNameFromType(type(innerType));
+        } catch (x) {}
+    }
+    return null;
+  }
+  var hasError = !1,
+    caughtError = null,
+    getFiberCurrentPropsFromNode$1 = null,
+    getInstanceFromNode = null,
+    getNodeFromInstance = null;
+  function executeDispatch(event, listener, inst) {
+    event.currentTarget = getNodeFromInstance(inst);
+    try {
+      listener(event);
+    } catch (error) {
+      hasError || (hasError = !0, caughtError = error);
+    }
+    event.currentTarget = null;
+  }
+  function executeDirectDispatch(event) {
+    var dispatchListener = event._dispatchListeners,
+      dispatchInstance = event._dispatchInstances;
+    if (isArrayImpl(dispatchListener)) throw Error("Invalid `event`.");
+    event.currentTarget = dispatchListener ? getNodeFromInstance(dispatchInstance) : null;
+    dispatchListener = dispatchListener ? dispatchListener(event) : null;
+    event.currentTarget = null;
+    event._dispatchListeners = null;
+    event._dispatchInstances = null;
+    return dispatchListener;
+  }
+  function functionThatReturnsTrue() {
+    return !0;
+  }
+  function functionThatReturnsFalse() {
+    return !1;
+  }
+  function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
+    this.dispatchConfig = dispatchConfig;
+    this._targetInst = targetInst;
+    this.nativeEvent = nativeEvent;
+    this._dispatchInstances = this._dispatchListeners = null;
+    dispatchConfig = this.constructor.Interface;
+    for (var propName in dispatchConfig) dispatchConfig.hasOwnProperty(propName) && ((targetInst = dispatchConfig[propName]) ? this[propName] = targetInst(nativeEvent) : "target" === propName ? this.target = nativeEventTarget : this[propName] = nativeEvent[propName]);
+    this.isDefaultPrevented = (null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : !1 === nativeEvent.returnValue) ? functionThatReturnsTrue : functionThatReturnsFalse;
+    this.isPropagationStopped = functionThatReturnsFalse;
+    return this;
+  }
+  assign(SyntheticEvent.prototype, {
+    preventDefault: function preventDefault() {
+      this.defaultPrevented = !0;
+      var event = this.nativeEvent;
+      event && (event.preventDefault ? event.preventDefault() : "unknown" !== typeof event.returnValue && (event.returnValue = !1), this.isDefaultPrevented = functionThatReturnsTrue);
+    },
+    stopPropagation: function stopPropagation() {
+      var event = this.nativeEvent;
+      event && (event.stopPropagation ? event.stopPropagation() : "unknown" !== typeof event.cancelBubble && (event.cancelBubble = !0), this.isPropagationStopped = functionThatReturnsTrue);
+    },
+    persist: function persist() {
+      this.isPersistent = functionThatReturnsTrue;
+    },
+    isPersistent: functionThatReturnsFalse,
+    destructor: function destructor() {
+      var Interface = this.constructor.Interface,
+        propName;
+      for (propName in Interface) this[propName] = null;
+      this.nativeEvent = this._targetInst = this.dispatchConfig = null;
+      this.isPropagationStopped = this.isDefaultPrevented = functionThatReturnsFalse;
+      this._dispatchInstances = this._dispatchListeners = null;
+    }
+  });
+  SyntheticEvent.Interface = {
+    type: null,
+    target: null,
+    currentTarget: function currentTarget() {
+      return null;
+    },
+    eventPhase: null,
+    bubbles: null,
+    cancelable: null,
+    timeStamp: function timeStamp(event) {
+      return event.timeStamp || Date.now();
+    },
+    defaultPrevented: null,
+    isTrusted: null
+  };
+  SyntheticEvent.extend = function (Interface) {
+    function E() {}
+    function Class() {
+      return Super.apply(this, arguments);
+    }
+    var Super = this;
+    E.prototype = Super.prototype;
+    var prototype = new E();
+    assign(prototype, Class.prototype);
+    Class.prototype = prototype;
+    Class.prototype.constructor = Class;
+    Class.Interface = assign({}, Super.Interface, Interface);
+    Class.extend = Super.extend;
+    addEventPoolingTo(Class);
+    return Class;
+  };
+  addEventPoolingTo(SyntheticEvent);
+  function createOrGetPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
+    if (this.eventPool.length) {
+      var instance = this.eventPool.pop();
+      this.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst);
+      return instance;
+    }
+    return new this(dispatchConfig, targetInst, nativeEvent, nativeInst);
+  }
+  function releasePooledEvent(event) {
+    if (!(event instanceof this)) throw Error("Trying to release an event instance into a pool of a different type.");
+    event.destructor();
+    10 > this.eventPool.length && this.eventPool.push(event);
+  }
+  function addEventPoolingTo(EventConstructor) {
+    EventConstructor.getPooled = createOrGetPooledEvent;
+    EventConstructor.eventPool = [];
+    EventConstructor.release = releasePooledEvent;
+  }
+  var ResponderSyntheticEvent = SyntheticEvent.extend({
+    touchHistory: function touchHistory() {
+      return null;
+    }
+  });
+  function isStartish(topLevelType) {
+    return "topTouchStart" === topLevelType;
+  }
+  function isMoveish(topLevelType) {
+    return "topTouchMove" === topLevelType;
+  }
+  var startDependencies = ["topTouchStart"],
+    moveDependencies = ["topTouchMove"],
+    endDependencies = ["topTouchCancel", "topTouchEnd"],
+    touchBank = [],
+    touchHistory = {
+      touchBank: touchBank,
+      numberActiveTouches: 0,
+      indexOfSingleActiveTouch: -1,
+      mostRecentTimeStamp: 0
+    };
+  function timestampForTouch(touch) {
+    return touch.timeStamp || touch.timestamp;
+  }
+  function getTouchIdentifier(_ref) {
+    _ref = _ref.identifier;
+    if (null == _ref) throw Error("Touch object is missing identifier.");
+    return _ref;
+  }
+  function recordTouchStart(touch) {
+    var identifier = getTouchIdentifier(touch),
+      touchRecord = touchBank[identifier];
+    touchRecord ? (touchRecord.touchActive = !0, touchRecord.startPageX = touch.pageX, touchRecord.startPageY = touch.pageY, touchRecord.startTimeStamp = timestampForTouch(touch), touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), touchRecord.previousPageX = touch.pageX, touchRecord.previousPageY = touch.pageY, touchRecord.previousTimeStamp = timestampForTouch(touch)) : (touchRecord = {
+      touchActive: !0,
+      startPageX: touch.pageX,
+      startPageY: touch.pageY,
+      startTimeStamp: timestampForTouch(touch),
+      currentPageX: touch.pageX,
+      currentPageY: touch.pageY,
+      currentTimeStamp: timestampForTouch(touch),
+      previousPageX: touch.pageX,
+      previousPageY: touch.pageY,
+      previousTimeStamp: timestampForTouch(touch)
+    }, touchBank[identifier] = touchRecord);
+    touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+  }
+  function recordTouchMove(touch) {
+    var touchRecord = touchBank[getTouchIdentifier(touch)];
+    touchRecord && (touchRecord.touchActive = !0, touchRecord.previousPageX = touchRecord.currentPageX, touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch));
+  }
+  function recordTouchEnd(touch) {
+    var touchRecord = touchBank[getTouchIdentifier(touch)];
+    touchRecord && (touchRecord.touchActive = !1, touchRecord.previousPageX = touchRecord.currentPageX, touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch));
+  }
+  var instrumentationCallback,
+    ResponderTouchHistoryStore = {
+      instrument: function instrument(callback) {
+        instrumentationCallback = callback;
+      },
+      recordTouchTrack: function recordTouchTrack(topLevelType, nativeEvent) {
+        null != instrumentationCallback && instrumentationCallback(topLevelType, nativeEvent);
+        if (isMoveish(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchMove);else if (isStartish(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchStart), touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches && (touchHistory.indexOfSingleActiveTouch = nativeEvent.touches[0].identifier);else if ("topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType) if (nativeEvent.changedTouches.forEach(recordTouchEnd), touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches) for (topLevelType = 0; topLevelType < touchBank.length; topLevelType++) if (nativeEvent = touchBank[topLevelType], null != nativeEvent && nativeEvent.touchActive) {
+          touchHistory.indexOfSingleActiveTouch = topLevelType;
+          break;
+        }
+      },
+      touchHistory: touchHistory
+    };
+  function accumulate(current, next) {
+    if (null == next) throw Error("Accumulated items must not be null or undefined.");
+    return null == current ? next : isArrayImpl(current) ? current.concat(next) : isArrayImpl(next) ? [current].concat(next) : [current, next];
+  }
+  function accumulateInto(current, next) {
+    if (null == next) throw Error("Accumulated items must not be null or undefined.");
+    if (null == current) return next;
+    if (isArrayImpl(current)) {
+      if (isArrayImpl(next)) return current.push.apply(current, next), current;
+      current.push(next);
+      return current;
+    }
+    return isArrayImpl(next) ? [current].concat(next) : [current, next];
+  }
+  function forEachAccumulated(arr, cb, scope) {
+    Array.isArray(arr) ? arr.forEach(cb, scope) : arr && cb.call(scope, arr);
+  }
+  var responderInst = null,
+    trackedTouchCount = 0;
+  function changeResponder(nextResponderInst, blockHostResponder) {
+    var oldResponderInst = responderInst;
+    responderInst = nextResponderInst;
+    if (null !== ResponderEventPlugin.GlobalResponderHandler) ResponderEventPlugin.GlobalResponderHandler.onChange(oldResponderInst, nextResponderInst, blockHostResponder);
+  }
+  var eventTypes = {
+    startShouldSetResponder: {
+      phasedRegistrationNames: {
+        bubbled: "onStartShouldSetResponder",
+        captured: "onStartShouldSetResponderCapture"
+      },
+      dependencies: startDependencies
+    },
+    scrollShouldSetResponder: {
+      phasedRegistrationNames: {
+        bubbled: "onScrollShouldSetResponder",
+        captured: "onScrollShouldSetResponderCapture"
+      },
+      dependencies: ["topScroll"]
+    },
+    selectionChangeShouldSetResponder: {
+      phasedRegistrationNames: {
+        bubbled: "onSelectionChangeShouldSetResponder",
+        captured: "onSelectionChangeShouldSetResponderCapture"
+      },
+      dependencies: ["topSelectionChange"]
+    },
+    moveShouldSetResponder: {
+      phasedRegistrationNames: {
+        bubbled: "onMoveShouldSetResponder",
+        captured: "onMoveShouldSetResponderCapture"
+      },
+      dependencies: moveDependencies
+    },
+    responderStart: {
+      registrationName: "onResponderStart",
+      dependencies: startDependencies
+    },
+    responderMove: {
+      registrationName: "onResponderMove",
+      dependencies: moveDependencies
+    },
+    responderEnd: {
+      registrationName: "onResponderEnd",
+      dependencies: endDependencies
+    },
+    responderRelease: {
+      registrationName: "onResponderRelease",
+      dependencies: endDependencies
+    },
+    responderTerminationRequest: {
+      registrationName: "onResponderTerminationRequest",
+      dependencies: []
+    },
+    responderGrant: {
+      registrationName: "onResponderGrant",
+      dependencies: []
+    },
+    responderReject: {
+      registrationName: "onResponderReject",
+      dependencies: []
+    },
+    responderTerminate: {
+      registrationName: "onResponderTerminate",
+      dependencies: []
+    }
+  };
+  function getParent$1(inst) {
+    do inst = inst.return; while (inst && 5 !== inst.tag);
+    return inst ? inst : null;
+  }
+  function traverseTwoPhase$1(inst, fn, arg) {
+    for (var path = []; inst;) path.push(inst), inst = getParent$1(inst);
+    for (inst = path.length; 0 < inst--;) fn(path[inst], "captured", arg);
+    for (inst = 0; inst < path.length; inst++) fn(path[inst], "bubbled", arg);
+  }
+  function getListener$1(inst, registrationName) {
+    inst = inst.stateNode;
+    if (null === inst) return null;
+    inst = getFiberCurrentPropsFromNode$1(inst);
+    if (null === inst) return null;
+    if ((inst = inst[registrationName]) && "function" !== typeof inst) throw Error("Expected `" + registrationName + "` listener to be a function, instead got a value of `" + typeof inst + "` type.");
+    return inst;
+  }
+  function accumulateDirectionalDispatches$1(inst, phase, event) {
+    if (phase = getListener$1(inst, event.dispatchConfig.phasedRegistrationNames[phase])) event._dispatchListeners = accumulateInto(event._dispatchListeners, phase), event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
+  }
+  function accumulateDirectDispatchesSingle$1(event) {
+    if (event && event.dispatchConfig.registrationName) {
+      var inst = event._targetInst;
+      if (inst && event && event.dispatchConfig.registrationName) {
+        var listener = getListener$1(inst, event.dispatchConfig.registrationName);
+        listener && (event._dispatchListeners = accumulateInto(event._dispatchListeners, listener), event._dispatchInstances = accumulateInto(event._dispatchInstances, inst));
+      }
+    }
+  }
+  function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
+    if (event && event.dispatchConfig.phasedRegistrationNames) {
+      var targetInst = event._targetInst;
+      targetInst = targetInst ? getParent$1(targetInst) : null;
+      traverseTwoPhase$1(targetInst, accumulateDirectionalDispatches$1, event);
+    }
+  }
+  function accumulateTwoPhaseDispatchesSingle$1(event) {
+    event && event.dispatchConfig.phasedRegistrationNames && traverseTwoPhase$1(event._targetInst, accumulateDirectionalDispatches$1, event);
+  }
+  var ResponderEventPlugin = {
+      _getResponder: function _getResponder() {
+        return responderInst;
+      },
+      eventTypes: eventTypes,
+      extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+        if (isStartish(topLevelType)) trackedTouchCount += 1;else if ("topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType) if (0 <= trackedTouchCount) --trackedTouchCount;else return null;
+        ResponderTouchHistoryStore.recordTouchTrack(topLevelType, nativeEvent);
+        if (targetInst && ("topScroll" === topLevelType && !nativeEvent.responderIgnoreScroll || 0 < trackedTouchCount && "topSelectionChange" === topLevelType || isStartish(topLevelType) || isMoveish(topLevelType))) {
+          var shouldSetEventType = isStartish(topLevelType) ? eventTypes.startShouldSetResponder : isMoveish(topLevelType) ? eventTypes.moveShouldSetResponder : "topSelectionChange" === topLevelType ? eventTypes.selectionChangeShouldSetResponder : eventTypes.scrollShouldSetResponder;
+          if (responderInst) b: {
+            var JSCompiler_temp = responderInst;
+            for (var depthA = 0, tempA = JSCompiler_temp; tempA; tempA = getParent$1(tempA)) depthA++;
+            tempA = 0;
+            for (var tempB = targetInst; tempB; tempB = getParent$1(tempB)) tempA++;
+            for (; 0 < depthA - tempA;) JSCompiler_temp = getParent$1(JSCompiler_temp), depthA--;
+            for (; 0 < tempA - depthA;) targetInst = getParent$1(targetInst), tempA--;
+            for (; depthA--;) {
+              if (JSCompiler_temp === targetInst || JSCompiler_temp === targetInst.alternate) break b;
+              JSCompiler_temp = getParent$1(JSCompiler_temp);
+              targetInst = getParent$1(targetInst);
+            }
+            JSCompiler_temp = null;
+          } else JSCompiler_temp = targetInst;
+          targetInst = JSCompiler_temp;
+          JSCompiler_temp = targetInst === responderInst;
+          shouldSetEventType = ResponderSyntheticEvent.getPooled(shouldSetEventType, targetInst, nativeEvent, nativeEventTarget);
+          shouldSetEventType.touchHistory = ResponderTouchHistoryStore.touchHistory;
+          JSCompiler_temp ? forEachAccumulated(shouldSetEventType, accumulateTwoPhaseDispatchesSingleSkipTarget) : forEachAccumulated(shouldSetEventType, accumulateTwoPhaseDispatchesSingle$1);
+          b: {
+            JSCompiler_temp = shouldSetEventType._dispatchListeners;
+            targetInst = shouldSetEventType._dispatchInstances;
+            if (isArrayImpl(JSCompiler_temp)) for (depthA = 0; depthA < JSCompiler_temp.length && !shouldSetEventType.isPropagationStopped(); depthA++) {
+              if (JSCompiler_temp[depthA](shouldSetEventType, targetInst[depthA])) {
+                JSCompiler_temp = targetInst[depthA];
+                break b;
+              }
+            } else if (JSCompiler_temp && JSCompiler_temp(shouldSetEventType, targetInst)) {
+              JSCompiler_temp = targetInst;
+              break b;
+            }
+            JSCompiler_temp = null;
+          }
+          shouldSetEventType._dispatchInstances = null;
+          shouldSetEventType._dispatchListeners = null;
+          shouldSetEventType.isPersistent() || shouldSetEventType.constructor.release(shouldSetEventType);
+          if (JSCompiler_temp && JSCompiler_temp !== responderInst) {
+            if (shouldSetEventType = ResponderSyntheticEvent.getPooled(eventTypes.responderGrant, JSCompiler_temp, nativeEvent, nativeEventTarget), shouldSetEventType.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(shouldSetEventType, accumulateDirectDispatchesSingle$1), targetInst = !0 === executeDirectDispatch(shouldSetEventType), responderInst) {
+              if (depthA = ResponderSyntheticEvent.getPooled(eventTypes.responderTerminationRequest, responderInst, nativeEvent, nativeEventTarget), depthA.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(depthA, accumulateDirectDispatchesSingle$1), tempA = !depthA._dispatchListeners || executeDirectDispatch(depthA), depthA.isPersistent() || depthA.constructor.release(depthA), tempA) {
+                depthA = ResponderSyntheticEvent.getPooled(eventTypes.responderTerminate, responderInst, nativeEvent, nativeEventTarget);
+                depthA.touchHistory = ResponderTouchHistoryStore.touchHistory;
+                forEachAccumulated(depthA, accumulateDirectDispatchesSingle$1);
+                var JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, [shouldSetEventType, depthA]);
+                changeResponder(JSCompiler_temp, targetInst);
+              } else shouldSetEventType = ResponderSyntheticEvent.getPooled(eventTypes.responderReject, JSCompiler_temp, nativeEvent, nativeEventTarget), shouldSetEventType.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(shouldSetEventType, accumulateDirectDispatchesSingle$1), JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, shouldSetEventType);
+            } else JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, shouldSetEventType), changeResponder(JSCompiler_temp, targetInst);
+          } else JSCompiler_temp$jscomp$0 = null;
+        } else JSCompiler_temp$jscomp$0 = null;
+        shouldSetEventType = responderInst && isStartish(topLevelType);
+        JSCompiler_temp = responderInst && isMoveish(topLevelType);
+        targetInst = responderInst && ("topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType);
+        if (shouldSetEventType = shouldSetEventType ? eventTypes.responderStart : JSCompiler_temp ? eventTypes.responderMove : targetInst ? eventTypes.responderEnd : null) shouldSetEventType = ResponderSyntheticEvent.getPooled(shouldSetEventType, responderInst, nativeEvent, nativeEventTarget), shouldSetEventType.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(shouldSetEventType, accumulateDirectDispatchesSingle$1), JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, shouldSetEventType);
+        shouldSetEventType = responderInst && "topTouchCancel" === topLevelType;
+        if (topLevelType = responderInst && !shouldSetEventType && ("topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType)) a: {
+          if ((topLevelType = nativeEvent.touches) && 0 !== topLevelType.length) for (JSCompiler_temp = 0; JSCompiler_temp < topLevelType.length; JSCompiler_temp++) if (targetInst = topLevelType[JSCompiler_temp].target, null !== targetInst && void 0 !== targetInst && 0 !== targetInst) {
+            depthA = getInstanceFromNode(targetInst);
+            b: {
+              for (targetInst = responderInst; depthA;) {
+                if (targetInst === depthA || targetInst === depthA.alternate) {
+                  targetInst = !0;
+                  break b;
+                }
+                depthA = getParent$1(depthA);
+              }
+              targetInst = !1;
+            }
+            if (targetInst) {
+              topLevelType = !1;
+              break a;
+            }
+          }
+          topLevelType = !0;
+        }
+        if (topLevelType = shouldSetEventType ? eventTypes.responderTerminate : topLevelType ? eventTypes.responderRelease : null) nativeEvent = ResponderSyntheticEvent.getPooled(topLevelType, responderInst, nativeEvent, nativeEventTarget), nativeEvent.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(nativeEvent, accumulateDirectDispatchesSingle$1), JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, nativeEvent), changeResponder(null);
+        return JSCompiler_temp$jscomp$0;
+      },
+      GlobalResponderHandler: null,
+      injection: {
+        injectGlobalResponderHandler: function injectGlobalResponderHandler(GlobalResponderHandler) {
+          ResponderEventPlugin.GlobalResponderHandler = GlobalResponderHandler;
+        }
+      }
+    },
+    eventPluginOrder = null,
+    namesToPlugins = {};
+  function recomputePluginOrdering() {
+    if (eventPluginOrder) for (var pluginName in namesToPlugins) {
+      var pluginModule = namesToPlugins[pluginName],
+        pluginIndex = eventPluginOrder.indexOf(pluginName);
+      if (-1 >= pluginIndex) throw Error("EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `" + (pluginName + "`."));
+      if (!plugins[pluginIndex]) {
+        if (!pluginModule.extractEvents) throw Error("EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `" + (pluginName + "` does not."));
+        plugins[pluginIndex] = pluginModule;
+        pluginIndex = pluginModule.eventTypes;
+        for (var eventName in pluginIndex) {
+          var JSCompiler_inline_result = void 0;
+          var dispatchConfig = pluginIndex[eventName];
+          if (eventNameDispatchConfigs.hasOwnProperty(eventName)) throw Error("EventPluginRegistry: More than one plugin attempted to publish the same event name, `" + (eventName + "`."));
+          eventNameDispatchConfigs[eventName] = dispatchConfig;
+          var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;
+          if (phasedRegistrationNames) {
+            for (JSCompiler_inline_result in phasedRegistrationNames) phasedRegistrationNames.hasOwnProperty(JSCompiler_inline_result) && publishRegistrationName(phasedRegistrationNames[JSCompiler_inline_result], pluginModule);
+            JSCompiler_inline_result = !0;
+          } else dispatchConfig.registrationName ? (publishRegistrationName(dispatchConfig.registrationName, pluginModule), JSCompiler_inline_result = !0) : JSCompiler_inline_result = !1;
+          if (!JSCompiler_inline_result) throw Error("EventPluginRegistry: Failed to publish event `" + eventName + "` for plugin `" + pluginName + "`.");
+        }
+      }
+    }
+  }
+  function publishRegistrationName(registrationName, pluginModule) {
+    if (registrationNameModules[registrationName]) throw Error("EventPluginRegistry: More than one plugin attempted to publish the same registration name, `" + (registrationName + "`."));
+    registrationNameModules[registrationName] = pluginModule;
+  }
+  var plugins = [],
+    eventNameDispatchConfigs = {},
+    registrationNameModules = {};
+  function getListener(inst, registrationName) {
+    inst = inst.stateNode;
+    if (null === inst) return null;
+    inst = getFiberCurrentPropsFromNode$1(inst);
+    if (null === inst) return null;
+    if ((inst = inst[registrationName]) && "function" !== typeof inst) throw Error("Expected `" + registrationName + "` listener to be a function, instead got a value of `" + typeof inst + "` type.");
+    return inst;
+  }
+  var customBubblingEventTypes = _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").ReactNativeViewConfigRegistry.customBubblingEventTypes,
+    customDirectEventTypes = _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").ReactNativeViewConfigRegistry.customDirectEventTypes;
+  function accumulateDirectionalDispatches(inst, phase, event) {
+    if (phase = getListener(inst, event.dispatchConfig.phasedRegistrationNames[phase])) event._dispatchListeners = accumulateInto(event._dispatchListeners, phase), event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
+  }
+  function traverseTwoPhase(inst, fn, arg, skipBubbling) {
+    for (var path = []; inst;) {
+      path.push(inst);
+      do inst = inst.return; while (inst && 5 !== inst.tag);
+      inst = inst ? inst : null;
+    }
+    for (inst = path.length; 0 < inst--;) fn(path[inst], "captured", arg);
+    if (skipBubbling) fn(path[0], "bubbled", arg);else for (inst = 0; inst < path.length; inst++) fn(path[inst], "bubbled", arg);
+  }
+  function accumulateTwoPhaseDispatchesSingle(event) {
+    event && event.dispatchConfig.phasedRegistrationNames && traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event, !1);
+  }
+  function accumulateDirectDispatchesSingle(event) {
+    if (event && event.dispatchConfig.registrationName) {
+      var inst = event._targetInst;
+      if (inst && event && event.dispatchConfig.registrationName) {
+        var listener = getListener(inst, event.dispatchConfig.registrationName);
+        listener && (event._dispatchListeners = accumulateInto(event._dispatchListeners, listener), event._dispatchInstances = accumulateInto(event._dispatchInstances, inst));
+      }
+    }
+  }
+  if (eventPluginOrder) throw Error("EventPluginRegistry: Cannot inject event plugin ordering more than once. You are likely trying to load more than one copy of React.");
+  eventPluginOrder = Array.prototype.slice.call(["ResponderEventPlugin", "ReactNativeBridgeEventPlugin"]);
+  recomputePluginOrdering();
+  var injectedNamesToPlugins$jscomp$inline_283 = {
+      ResponderEventPlugin: ResponderEventPlugin,
+      ReactNativeBridgeEventPlugin: {
+        eventTypes: {},
+        extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+          if (null == targetInst) return null;
+          var bubbleDispatchConfig = customBubblingEventTypes[topLevelType],
+            directDispatchConfig = customDirectEventTypes[topLevelType];
+          if (!bubbleDispatchConfig && !directDispatchConfig) throw Error('Unsupported top level event type "' + topLevelType + '" dispatched');
+          topLevelType = SyntheticEvent.getPooled(bubbleDispatchConfig || directDispatchConfig, targetInst, nativeEvent, nativeEventTarget);
+          if (bubbleDispatchConfig) null != topLevelType && null != topLevelType.dispatchConfig.phasedRegistrationNames && topLevelType.dispatchConfig.phasedRegistrationNames.skipBubbling ? topLevelType && topLevelType.dispatchConfig.phasedRegistrationNames && traverseTwoPhase(topLevelType._targetInst, accumulateDirectionalDispatches, topLevelType, !0) : forEachAccumulated(topLevelType, accumulateTwoPhaseDispatchesSingle);else if (directDispatchConfig) forEachAccumulated(topLevelType, accumulateDirectDispatchesSingle);else return null;
+          return topLevelType;
+        }
+      }
+    },
+    isOrderingDirty$jscomp$inline_284 = !1,
+    pluginName$jscomp$inline_285;
+  for (pluginName$jscomp$inline_285 in injectedNamesToPlugins$jscomp$inline_283) if (injectedNamesToPlugins$jscomp$inline_283.hasOwnProperty(pluginName$jscomp$inline_285)) {
+    var pluginModule$jscomp$inline_286 = injectedNamesToPlugins$jscomp$inline_283[pluginName$jscomp$inline_285];
+    if (!namesToPlugins.hasOwnProperty(pluginName$jscomp$inline_285) || namesToPlugins[pluginName$jscomp$inline_285] !== pluginModule$jscomp$inline_286) {
+      if (namesToPlugins[pluginName$jscomp$inline_285]) throw Error("EventPluginRegistry: Cannot inject two different event plugins using the same name, `" + (pluginName$jscomp$inline_285 + "`."));
+      namesToPlugins[pluginName$jscomp$inline_285] = pluginModule$jscomp$inline_286;
+      isOrderingDirty$jscomp$inline_284 = !0;
+    }
+  }
+  isOrderingDirty$jscomp$inline_284 && recomputePluginOrdering();
+  var instanceCache = new Map(),
+    instanceProps = new Map();
+  function getInstanceFromTag(tag) {
+    return instanceCache.get(tag) || null;
+  }
+  function batchedUpdatesImpl(fn, bookkeeping) {
+    return fn(bookkeeping);
+  }
+  var isInsideEventHandler = !1;
+  function batchedUpdates$1(fn, bookkeeping) {
+    if (isInsideEventHandler) return fn(bookkeeping);
+    isInsideEventHandler = !0;
+    try {
+      return batchedUpdatesImpl(fn, bookkeeping);
+    } finally {
+      isInsideEventHandler = !1;
+    }
+  }
+  var eventQueue = null;
+  function executeDispatchesAndReleaseTopLevel(e) {
+    if (e) {
+      var dispatchListeners = e._dispatchListeners,
+        dispatchInstances = e._dispatchInstances;
+      if (isArrayImpl(dispatchListeners)) for (var i = 0; i < dispatchListeners.length && !e.isPropagationStopped(); i++) executeDispatch(e, dispatchListeners[i], dispatchInstances[i]);else dispatchListeners && executeDispatch(e, dispatchListeners, dispatchInstances);
+      e._dispatchListeners = null;
+      e._dispatchInstances = null;
+      e.isPersistent() || e.constructor.release(e);
+    }
+  }
+  var EMPTY_NATIVE_EVENT = {};
+  function _receiveRootNodeIDEvent(rootNodeID, topLevelType, nativeEventParam) {
+    var nativeEvent = nativeEventParam || EMPTY_NATIVE_EVENT,
+      inst = getInstanceFromTag(rootNodeID),
+      target = null;
+    null != inst && (target = inst.stateNode);
+    batchedUpdates$1(function () {
+      var JSCompiler_inline_result = target;
+      for (var events = null, legacyPlugins = plugins, i = 0; i < legacyPlugins.length; i++) {
+        var possiblePlugin = legacyPlugins[i];
+        possiblePlugin && (possiblePlugin = possiblePlugin.extractEvents(topLevelType, inst, nativeEvent, JSCompiler_inline_result)) && (events = accumulateInto(events, possiblePlugin));
+      }
+      JSCompiler_inline_result = events;
+      null !== JSCompiler_inline_result && (eventQueue = accumulateInto(eventQueue, JSCompiler_inline_result));
+      JSCompiler_inline_result = eventQueue;
+      eventQueue = null;
+      if (JSCompiler_inline_result) {
+        forEachAccumulated(JSCompiler_inline_result, executeDispatchesAndReleaseTopLevel);
+        if (eventQueue) throw Error("processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented.");
+        if (hasError) throw JSCompiler_inline_result = caughtError, hasError = !1, caughtError = null, JSCompiler_inline_result;
+      }
+    });
+  }
+  _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").RCTEventEmitter.register({
+    receiveEvent: function receiveEvent(rootNodeID, topLevelType, nativeEventParam) {
+      _receiveRootNodeIDEvent(rootNodeID, topLevelType, nativeEventParam);
+    },
+    receiveTouches: function receiveTouches(eventTopLevelType, touches, changedIndices) {
+      if ("topTouchEnd" === eventTopLevelType || "topTouchCancel" === eventTopLevelType) {
+        var JSCompiler_temp = [];
+        for (var i = 0; i < changedIndices.length; i++) {
+          var index$4 = changedIndices[i];
+          JSCompiler_temp.push(touches[index$4]);
+          touches[index$4] = null;
+        }
+        for (i = changedIndices = 0; i < touches.length; i++) index$4 = touches[i], null !== index$4 && (touches[changedIndices++] = index$4);
+        touches.length = changedIndices;
+      } else for (JSCompiler_temp = [], i = 0; i < changedIndices.length; i++) JSCompiler_temp.push(touches[changedIndices[i]]);
+      for (changedIndices = 0; changedIndices < JSCompiler_temp.length; changedIndices++) {
+        i = JSCompiler_temp[changedIndices];
+        i.changedTouches = JSCompiler_temp;
+        i.touches = touches;
+        index$4 = null;
+        var target = i.target;
+        null === target || void 0 === target || 1 > target || (index$4 = target);
+        _receiveRootNodeIDEvent(index$4, eventTopLevelType, i);
+      }
+    }
+  });
+  getFiberCurrentPropsFromNode$1 = function getFiberCurrentPropsFromNode$1(stateNode) {
+    return instanceProps.get(stateNode._nativeTag) || null;
+  };
+  getInstanceFromNode = getInstanceFromTag;
+  getNodeFromInstance = function getNodeFromInstance(inst) {
+    inst = inst.stateNode;
+    var tag = inst._nativeTag;
+    void 0 === tag && null != inst.canonical && (tag = inst.canonical.nativeTag, inst = inst.canonical.publicInstance);
+    if (!tag) throw Error("All native instances should have a tag.");
+    return inst;
+  };
+  ResponderEventPlugin.injection.injectGlobalResponderHandler({
+    onChange: function onChange(from, to, blockNativeResponder) {
+      null !== to ? _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").UIManager.setJSResponder(to.stateNode._nativeTag, blockNativeResponder) : _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").UIManager.clearJSResponder();
+    }
+  });
+  function getNearestMountedFiber(fiber) {
+    var node = fiber,
+      nearestMounted = fiber;
+    if (fiber.alternate) for (; node.return;) node = node.return;else {
+      fiber = node;
+      do node = fiber, 0 !== (node.flags & 4098) && (nearestMounted = node.return), fiber = node.return; while (fiber);
+    }
+    return 3 === node.tag ? nearestMounted : null;
+  }
+  function assertIsMounted(fiber) {
+    if (getNearestMountedFiber(fiber) !== fiber) throw Error("Unable to find node on an unmounted component.");
+  }
+  function findCurrentFiberUsingSlowPath(fiber) {
+    var alternate = fiber.alternate;
+    if (!alternate) {
+      alternate = getNearestMountedFiber(fiber);
+      if (null === alternate) throw Error("Unable to find node on an unmounted component.");
+      return alternate !== fiber ? null : fiber;
+    }
+    for (var a = fiber, b = alternate;;) {
+      var parentA = a.return;
+      if (null === parentA) break;
+      var parentB = parentA.alternate;
+      if (null === parentB) {
+        b = parentA.return;
+        if (null !== b) {
+          a = b;
+          continue;
+        }
+        break;
+      }
+      if (parentA.child === parentB.child) {
+        for (parentB = parentA.child; parentB;) {
+          if (parentB === a) return assertIsMounted(parentA), fiber;
+          if (parentB === b) return assertIsMounted(parentA), alternate;
+          parentB = parentB.sibling;
+        }
+        throw Error("Unable to find node on an unmounted component.");
+      }
+      if (a.return !== b.return) a = parentA, b = parentB;else {
+        for (var didFindChild = !1, child$5 = parentA.child; child$5;) {
+          if (child$5 === a) {
+            didFindChild = !0;
+            a = parentA;
+            b = parentB;
+            break;
+          }
+          if (child$5 === b) {
+            didFindChild = !0;
+            b = parentA;
+            a = parentB;
+            break;
+          }
+          child$5 = child$5.sibling;
+        }
+        if (!didFindChild) {
+          for (child$5 = parentB.child; child$5;) {
+            if (child$5 === a) {
+              didFindChild = !0;
+              a = parentB;
+              b = parentA;
+              break;
+            }
+            if (child$5 === b) {
+              didFindChild = !0;
+              b = parentB;
+              a = parentA;
+              break;
+            }
+            child$5 = child$5.sibling;
+          }
+          if (!didFindChild) throw 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 Error("Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue.");
+    }
+    if (3 !== a.tag) throw Error("Unable to find node on an unmounted component.");
+    return a.stateNode.current === a ? fiber : alternate;
+  }
+  function findCurrentHostFiberImpl(node) {
+    var tag = node.tag;
+    if (5 === tag || 26 === tag || 27 === tag || 6 === tag) return node;
+    for (node = node.child; null !== node;) {
+      tag = findCurrentHostFiberImpl(node);
+      if (null !== tag) return tag;
+      node = node.sibling;
+    }
+    return null;
+  }
+  var emptyObject = {},
+    removedKeys = null,
+    removedKeyCount = 0,
+    deepDifferOptions = {
+      unsafelyIgnoreFunctions: !0
+    };
+  function defaultDiffer(prevProp, nextProp) {
+    return "object" !== typeof nextProp || null === nextProp ? !0 : _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").deepDiffer(prevProp, nextProp, deepDifferOptions);
+  }
+  function restoreDeletedValuesInNestedArray(updatePayload, node, validAttributes) {
+    if (isArrayImpl(node)) for (var i = node.length; i-- && 0 < removedKeyCount;) restoreDeletedValuesInNestedArray(updatePayload, node[i], validAttributes);else if (node && 0 < removedKeyCount) for (i in removedKeys) if (removedKeys[i]) {
+      var nextProp = node[i];
+      if (void 0 !== nextProp) {
+        var attributeConfig = validAttributes[i];
+        if (attributeConfig) {
+          "function" === typeof nextProp && (nextProp = !0);
+          "undefined" === typeof nextProp && (nextProp = null);
+          if ("object" !== typeof attributeConfig) updatePayload[i] = nextProp;else if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) nextProp = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, updatePayload[i] = nextProp;
+          removedKeys[i] = !1;
+          removedKeyCount--;
+        }
+      }
+    }
+  }
+  function diffNestedProperty(updatePayload, prevProp, nextProp, validAttributes) {
+    if (!updatePayload && prevProp === nextProp) return updatePayload;
+    if (!prevProp || !nextProp) return nextProp ? addNestedProperty(updatePayload, nextProp, validAttributes) : prevProp ? clearNestedProperty(updatePayload, prevProp, validAttributes) : updatePayload;
+    if (!isArrayImpl(prevProp) && !isArrayImpl(nextProp)) return diffProperties(updatePayload, prevProp, nextProp, validAttributes);
+    if (isArrayImpl(prevProp) && isArrayImpl(nextProp)) {
+      var minLength = prevProp.length < nextProp.length ? prevProp.length : nextProp.length,
+        i;
+      for (i = 0; i < minLength; i++) updatePayload = diffNestedProperty(updatePayload, prevProp[i], nextProp[i], validAttributes);
+      for (; i < prevProp.length; i++) updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
+      for (; i < nextProp.length; i++) updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
+      return updatePayload;
+    }
+    return isArrayImpl(prevProp) ? diffProperties(updatePayload, _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").flattenStyle(prevProp), nextProp, validAttributes) : diffProperties(updatePayload, prevProp, _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").flattenStyle(nextProp), validAttributes);
+  }
+  function addNestedProperty(updatePayload, nextProp, validAttributes) {
+    if (!nextProp) return updatePayload;
+    if (!isArrayImpl(nextProp)) return diffProperties(updatePayload, emptyObject, nextProp, validAttributes);
+    for (var i = 0; i < nextProp.length; i++) updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
+    return updatePayload;
+  }
+  function clearNestedProperty(updatePayload, prevProp, validAttributes) {
+    if (!prevProp) return updatePayload;
+    if (!isArrayImpl(prevProp)) return diffProperties(updatePayload, prevProp, emptyObject, validAttributes);
+    for (var i = 0; i < prevProp.length; i++) updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
+    return updatePayload;
+  }
+  function diffProperties(updatePayload, prevProps, nextProps, validAttributes) {
+    var attributeConfig, propKey;
+    for (propKey in nextProps) if (attributeConfig = validAttributes[propKey]) {
+      var prevProp = prevProps[propKey];
+      var nextProp = nextProps[propKey];
+      "function" === typeof nextProp && (nextProp = !0, "function" === typeof prevProp && (prevProp = !0));
+      "undefined" === typeof nextProp && (nextProp = null, "undefined" === typeof prevProp && (prevProp = null));
+      removedKeys && (removedKeys[propKey] = !1);
+      if (updatePayload && void 0 !== updatePayload[propKey]) {
+        if ("object" !== typeof attributeConfig) updatePayload[propKey] = nextProp;else {
+          if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) attributeConfig = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, updatePayload[propKey] = attributeConfig;
+        }
+      } else if (prevProp !== nextProp) if ("object" !== typeof attributeConfig) defaultDiffer(prevProp, nextProp) && ((updatePayload || (updatePayload = {}))[propKey] = nextProp);else if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) {
+        if (void 0 === prevProp || ("function" === typeof attributeConfig.diff ? attributeConfig.diff(prevProp, nextProp) : defaultDiffer(prevProp, nextProp))) attributeConfig = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, (updatePayload || (updatePayload = {}))[propKey] = attributeConfig;
+      } else removedKeys = null, removedKeyCount = 0, updatePayload = diffNestedProperty(updatePayload, prevProp, nextProp, attributeConfig), 0 < removedKeyCount && updatePayload && (restoreDeletedValuesInNestedArray(updatePayload, nextProp, attributeConfig), removedKeys = null);
+    }
+    for (var propKey$7 in prevProps) void 0 === nextProps[propKey$7] && (!(attributeConfig = validAttributes[propKey$7]) || updatePayload && void 0 !== updatePayload[propKey$7] || (prevProp = prevProps[propKey$7], void 0 !== prevProp && ("object" !== typeof attributeConfig || "function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process ? ((updatePayload || (updatePayload = {}))[propKey$7] = null, removedKeys || (removedKeys = {}), removedKeys[propKey$7] || (removedKeys[propKey$7] = !0, removedKeyCount++)) : updatePayload = clearNestedProperty(updatePayload, prevProp, attributeConfig))));
+    return updatePayload;
+  }
+  function mountSafeCallback_NOT_REALLY_SAFE(context, callback) {
+    return function () {
+      if (callback && ("boolean" !== typeof context.__isMounted || context.__isMounted)) return callback.apply(context, arguments);
+    };
+  }
+  var ReactNativeFiberHostComponent = function () {
+      function ReactNativeFiberHostComponent(tag, viewConfig) {
+        this.viewConfig = this._internalFiberInstanceHandleDEV = void 0;
+        this._nativeTag = tag;
+        this._children = [];
+        this.viewConfig = viewConfig;
+      }
+      var _proto = ReactNativeFiberHostComponent.prototype;
+      _proto.blur = function () {
+        _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").TextInputState.blurTextInput(this);
+      };
+      _proto.focus = function () {
+        _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").TextInputState.focusTextInput(this);
+      };
+      _proto.measure = function (callback) {
+        _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").UIManager.measure(this._nativeTag, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+      };
+      _proto.measureInWindow = function (callback) {
+        _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").UIManager.measureInWindow(this._nativeTag, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+      };
+      _proto.measureLayout = function (relativeToNativeNode, onSuccess, onFail) {
+        if ("number" === typeof relativeToNativeNode) var relativeNode = relativeToNativeNode;else relativeToNativeNode._nativeTag && (relativeNode = relativeToNativeNode._nativeTag);
+        null != relativeNode && _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").UIManager.measureLayout(this._nativeTag, relativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+      };
+      _proto.setNativeProps = function (nativeProps) {
+        nativeProps = diffProperties(null, emptyObject, nativeProps, this.viewConfig.validAttributes);
+        null != nativeProps && _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").UIManager.updateView(this._nativeTag, this.viewConfig.uiViewClassName, nativeProps);
+      };
+      return ReactNativeFiberHostComponent;
+    }(),
+    rendererID = null,
+    injectedHook = null;
+  function setIsStrictModeForDevtools(newIsStrictMode) {
+    "function" === typeof _$$_REQUIRE(_dependencyMap[3], "scheduler").log && _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_setDisableYieldValue(newIsStrictMode);
+    if (injectedHook && "function" === typeof injectedHook.setStrictMode) try {
+      injectedHook.setStrictMode(rendererID, newIsStrictMode);
+    } catch (err) {}
+  }
+  var clz32 = Math.clz32 ? Math.clz32 : clz32Fallback,
+    log = Math.log,
+    LN2 = Math.LN2;
+  function clz32Fallback(x) {
+    x >>>= 0;
+    return 0 === x ? 32 : 31 - (log(x) / LN2 | 0) | 0;
+  }
+  var nextTransitionLane = 256,
+    nextRetryLane = 4194304;
+  function getHighestPriorityLanes(lanes) {
+    var pendingSyncLanes = lanes & 42;
+    if (0 !== pendingSyncLanes) return pendingSyncLanes;
+    switch (lanes & -lanes) {
+      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:
+        return 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 lanes & 4194048;
+      case 4194304:
+      case 8388608:
+      case 16777216:
+      case 33554432:
+        return lanes & 62914560;
+      case 67108864:
+        return 67108864;
+      case 134217728:
+        return 134217728;
+      case 268435456:
+        return 268435456;
+      case 536870912:
+        return 536870912;
+      case 1073741824:
+        return 0;
+      default:
+        return lanes;
+    }
+  }
+  function getNextLanes(root, wipLanes, rootHasPendingCommit) {
+    var pendingLanes = root.pendingLanes;
+    if (0 === pendingLanes) return 0;
+    var nextLanes = 0,
+      suspendedLanes = root.suspendedLanes,
+      pingedLanes = root.pingedLanes;
+    root = root.warmLanes;
+    var nonIdlePendingLanes = pendingLanes & 134217727;
+    0 !== nonIdlePendingLanes ? (pendingLanes = nonIdlePendingLanes & ~suspendedLanes, 0 !== pendingLanes ? nextLanes = getHighestPriorityLanes(pendingLanes) : (pingedLanes &= nonIdlePendingLanes, 0 !== pingedLanes ? nextLanes = getHighestPriorityLanes(pingedLanes) : rootHasPendingCommit || (rootHasPendingCommit = nonIdlePendingLanes & ~root, 0 !== rootHasPendingCommit && (nextLanes = getHighestPriorityLanes(rootHasPendingCommit))))) : (nonIdlePendingLanes = pendingLanes & ~suspendedLanes, 0 !== nonIdlePendingLanes ? nextLanes = getHighestPriorityLanes(nonIdlePendingLanes) : 0 !== pingedLanes ? nextLanes = getHighestPriorityLanes(pingedLanes) : rootHasPendingCommit || (rootHasPendingCommit = pendingLanes & ~root, 0 !== rootHasPendingCommit && (nextLanes = getHighestPriorityLanes(rootHasPendingCommit))));
+    return 0 === nextLanes ? 0 : 0 !== wipLanes && wipLanes !== nextLanes && 0 === (wipLanes & suspendedLanes) && (suspendedLanes = nextLanes & -nextLanes, rootHasPendingCommit = wipLanes & -wipLanes, suspendedLanes >= rootHasPendingCommit || 32 === suspendedLanes && 0 !== (rootHasPendingCommit & 4194048)) ? wipLanes : nextLanes;
+  }
+  function checkIfRootIsPrerendering(root, renderLanes) {
+    return 0 === (root.pendingLanes & ~(root.suspendedLanes & ~root.pingedLanes) & renderLanes);
+  }
+  function computeExpirationTime(lane, currentTime) {
+    switch (lane) {
+      case 1:
+      case 2:
+      case 4:
+      case 8:
+      case 64:
+        return currentTime + 250;
+      case 16:
+      case 32:
+      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 currentTime + 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 claimNextTransitionLane() {
+    var lane = nextTransitionLane;
+    nextTransitionLane <<= 1;
+    0 === (nextTransitionLane & 4194048) && (nextTransitionLane = 256);
+    return lane;
+  }
+  function claimNextRetryLane() {
+    var lane = nextRetryLane;
+    nextRetryLane <<= 1;
+    0 === (nextRetryLane & 62914560) && (nextRetryLane = 4194304);
+    return lane;
+  }
+  function createLaneMap(initial) {
+    for (var laneMap = [], i = 0; 31 > i; i++) laneMap.push(initial);
+    return laneMap;
+  }
+  function markRootUpdated$1(root, updateLane) {
+    root.pendingLanes |= updateLane;
+    268435456 !== updateLane && (root.suspendedLanes = 0, root.pingedLanes = 0, root.warmLanes = 0);
+  }
+  function markRootFinished(root, finishedLanes, remainingLanes, spawnedLane, updatedLanes, suspendedRetryLanes) {
+    var previouslyPendingLanes = root.pendingLanes;
+    root.pendingLanes = remainingLanes;
+    root.suspendedLanes = 0;
+    root.pingedLanes = 0;
+    root.warmLanes = 0;
+    root.expiredLanes &= remainingLanes;
+    root.entangledLanes &= remainingLanes;
+    root.errorRecoveryDisabledLanes &= remainingLanes;
+    root.shellSuspendCounter = 0;
+    var entanglements = root.entanglements,
+      expirationTimes = root.expirationTimes,
+      hiddenUpdates = root.hiddenUpdates;
+    for (remainingLanes = previouslyPendingLanes & ~remainingLanes; 0 < remainingLanes;) {
+      var index$12 = 31 - clz32(remainingLanes),
+        lane = 1 << index$12;
+      entanglements[index$12] = 0;
+      expirationTimes[index$12] = -1;
+      var hiddenUpdatesForLane = hiddenUpdates[index$12];
+      if (null !== hiddenUpdatesForLane) for (hiddenUpdates[index$12] = null, index$12 = 0; index$12 < hiddenUpdatesForLane.length; index$12++) {
+        var update = hiddenUpdatesForLane[index$12];
+        null !== update && (update.lane &= -536870913);
+      }
+      remainingLanes &= ~lane;
+    }
+    0 !== spawnedLane && markSpawnedDeferredLane(root, spawnedLane, 0);
+    0 !== suspendedRetryLanes && 0 === updatedLanes && (root.suspendedLanes |= suspendedRetryLanes & ~(previouslyPendingLanes & ~finishedLanes));
+  }
+  function markSpawnedDeferredLane(root, spawnedLane, entangledLanes) {
+    root.pendingLanes |= spawnedLane;
+    root.suspendedLanes &= ~spawnedLane;
+    var spawnedLaneIndex = 31 - clz32(spawnedLane);
+    root.entangledLanes |= spawnedLane;
+    root.entanglements[spawnedLaneIndex] = root.entanglements[spawnedLaneIndex] | 1073741824 | entangledLanes & 4194090;
+  }
+  function markRootEntangled(root, entangledLanes) {
+    var rootEntangledLanes = root.entangledLanes |= entangledLanes;
+    for (root = root.entanglements; rootEntangledLanes;) {
+      var index$13 = 31 - clz32(rootEntangledLanes),
+        lane = 1 << index$13;
+      lane & entangledLanes | root[index$13] & entangledLanes && (root[index$13] |= entangledLanes);
+      rootEntangledLanes &= ~lane;
+    }
+  }
+  function lanesToEventPriority(lanes) {
+    lanes &= -lanes;
+    return 2 < lanes ? 8 < lanes ? 0 !== (lanes & 134217727) ? 32 : 268435456 : 8 : 2;
+  }
+  function shim$1() {
+    throw Error("The current renderer does not support hydration. This error is likely caused by a bug in React. Please file an issue.");
+  }
+  function shim() {
+    throw Error("The current renderer does not support Resources. This error is likely caused by a bug in React. Please file an issue.");
+  }
+  var extraDevToolsConfig = {
+      getInspectorDataForInstance: void 0,
+      getInspectorDataForViewTag: function getInspectorDataForViewTag() {
+        throw Error("getInspectorDataForViewTag() is not available in production");
+      },
+      getInspectorDataForViewAtPoint: function getInspectorDataForViewAtPoint() {
+        throw Error("getInspectorDataForViewAtPoint() is not available in production.");
+      }
+    },
+    getViewConfigForType = _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").ReactNativeViewConfigRegistry.get,
+    nextReactTag = 3;
+  function allocateTag() {
+    var tag = nextReactTag;
+    1 === tag % 10 && (tag += 2);
+    nextReactTag = tag + 2;
+    return tag;
+  }
+  function recursivelyUncacheFiberNode(node) {
+    if ("number" === typeof node) instanceCache.delete(node), instanceProps.delete(node);else {
+      var tag = node._nativeTag;
+      instanceCache.delete(tag);
+      instanceProps.delete(tag);
+      node._children.forEach(recursivelyUncacheFiberNode);
+    }
+  }
+  function finalizeInitialChildren(parentInstance) {
+    if (0 === parentInstance._children.length) return !1;
+    var nativeTags = parentInstance._children.map(function (child) {
+      return "number" === typeof child ? child : child._nativeTag;
+    });
+    _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").UIManager.setChildren(parentInstance._nativeTag, nativeTags);
+    return !1;
+  }
+  function getPublicInstance(instance) {
+    return null != instance.canonical && null != instance.canonical.publicInstance ? instance.canonical.publicInstance : instance;
+  }
+  var scheduleTimeout = setTimeout,
+    cancelTimeout = clearTimeout,
+    currentUpdatePriority = 0,
+    HostTransitionContext = {
+      $$typeof: REACT_CONTEXT_TYPE,
+      Provider: null,
+      Consumer: null,
+      _currentValue: null,
+      _currentValue2: null,
+      _threadCount: 0
+    },
+    valueStack = [],
+    index = -1;
+  function createCursor(defaultValue) {
+    return {
+      current: defaultValue
+    };
+  }
+  function pop(cursor) {
+    0 > index || (cursor.current = valueStack[index], valueStack[index] = null, index--);
+  }
+  function push(cursor, value) {
+    index++;
+    valueStack[index] = cursor.current;
+    cursor.current = value;
+  }
+  var emptyContextObject = {},
+    CapturedStacks = new WeakMap();
+  function createCapturedValueAtFiber(value, source) {
+    if ("object" === typeof value && null !== value) {
+      var existing = CapturedStacks.get(value);
+      if (void 0 !== existing) return existing;
+      source = {
+        value: value,
+        source: source,
+        stack: getStackByFiberInDevAndProd(source)
+      };
+      CapturedStacks.set(value, source);
+      return source;
+    }
+    return {
+      value: value,
+      source: source,
+      stack: getStackByFiberInDevAndProd(source)
+    };
+  }
+  var contextStackCursor = createCursor(null),
+    contextFiberStackCursor = createCursor(null),
+    rootInstanceStackCursor = createCursor(null),
+    hostTransitionProviderCursor = createCursor(null);
+  function pushHostContainer(fiber, nextRootInstance) {
+    push(rootInstanceStackCursor, nextRootInstance);
+    push(contextFiberStackCursor, fiber);
+    push(contextStackCursor, null);
+    pop(contextStackCursor);
+    push(contextStackCursor, {
+      isInAParentText: !1
+    });
+  }
+  function popHostContainer() {
+    pop(contextStackCursor);
+    pop(contextFiberStackCursor);
+    pop(rootInstanceStackCursor);
+  }
+  function pushHostContext(fiber) {
+    null !== fiber.memoizedState && push(hostTransitionProviderCursor, fiber);
+    var context = contextStackCursor.current;
+    var JSCompiler_inline_result = fiber.type;
+    JSCompiler_inline_result = "AndroidTextInput" === JSCompiler_inline_result || "RCTMultilineTextInputView" === JSCompiler_inline_result || "RCTSinglelineTextInputView" === JSCompiler_inline_result || "RCTText" === JSCompiler_inline_result || "RCTVirtualText" === JSCompiler_inline_result;
+    JSCompiler_inline_result = context.isInAParentText !== JSCompiler_inline_result ? {
+      isInAParentText: JSCompiler_inline_result
+    } : context;
+    context !== JSCompiler_inline_result && (push(contextFiberStackCursor, fiber), push(contextStackCursor, JSCompiler_inline_result));
+  }
+  function popHostContext(fiber) {
+    contextFiberStackCursor.current === fiber && (pop(contextStackCursor), pop(contextFiberStackCursor));
+    hostTransitionProviderCursor.current === fiber && (pop(hostTransitionProviderCursor), HostTransitionContext._currentValue = null);
+  }
+  var hydrationErrors = null;
+  function upgradeHydrationErrorsToRecoverable() {
+    var queuedErrors = hydrationErrors;
+    null !== queuedErrors && (null === workInProgressRootRecoverableErrors ? workInProgressRootRecoverableErrors = queuedErrors : workInProgressRootRecoverableErrors.push.apply(workInProgressRootRecoverableErrors, queuedErrors), hydrationErrors = null);
+    return queuedErrors;
+  }
+  function is(x, y) {
+    return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+  }
+  var objectIs = "function" === typeof Object.is ? Object.is : is,
+    valueCursor = createCursor(null),
+    currentlyRenderingFiber$1 = null,
+    lastContextDependency = null;
+  function pushProvider(providerFiber, context, nextValue) {
+    push(valueCursor, context._currentValue);
+    context._currentValue = nextValue;
+  }
+  function popProvider(context) {
+    context._currentValue = valueCursor.current;
+    pop(valueCursor);
+  }
+  function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
+    for (; null !== parent;) {
+      var alternate = parent.alternate;
+      (parent.childLanes & renderLanes) !== renderLanes ? (parent.childLanes |= renderLanes, null !== alternate && (alternate.childLanes |= renderLanes)) : null !== alternate && (alternate.childLanes & renderLanes) !== renderLanes && (alternate.childLanes |= renderLanes);
+      if (parent === propagationRoot) break;
+      parent = parent.return;
+    }
+  }
+  function propagateContextChanges(workInProgress, contexts, renderLanes, forcePropagateEntireTree) {
+    var fiber = workInProgress.child;
+    null !== fiber && (fiber.return = workInProgress);
+    for (; null !== fiber;) {
+      var list = fiber.dependencies;
+      if (null !== list) {
+        var nextFiber = fiber.child;
+        list = list.firstContext;
+        a: for (; null !== list;) {
+          var dependency = list;
+          list = fiber;
+          for (var i = 0; i < contexts.length; i++) if (dependency.context === contexts[i]) {
+            list.lanes |= renderLanes;
+            dependency = list.alternate;
+            null !== dependency && (dependency.lanes |= renderLanes);
+            scheduleContextWorkOnParentPath(list.return, renderLanes, workInProgress);
+            forcePropagateEntireTree || (nextFiber = null);
+            break a;
+          }
+          list = dependency.next;
+        }
+      } else if (18 === fiber.tag) {
+        nextFiber = fiber.return;
+        if (null === nextFiber) throw Error("We just came from a parent so we must have had a parent. This is a bug in React.");
+        nextFiber.lanes |= renderLanes;
+        list = nextFiber.alternate;
+        null !== list && (list.lanes |= renderLanes);
+        scheduleContextWorkOnParentPath(nextFiber, renderLanes, workInProgress);
+        nextFiber = null;
+      } else nextFiber = fiber.child;
+      if (null !== nextFiber) nextFiber.return = fiber;else for (nextFiber = fiber; null !== nextFiber;) {
+        if (nextFiber === workInProgress) {
+          nextFiber = null;
+          break;
+        }
+        fiber = nextFiber.sibling;
+        if (null !== fiber) {
+          fiber.return = nextFiber.return;
+          nextFiber = fiber;
+          break;
+        }
+        nextFiber = nextFiber.return;
+      }
+      fiber = nextFiber;
+    }
+  }
+  function propagateParentContextChanges(current, workInProgress, renderLanes, forcePropagateEntireTree) {
+    current = null;
+    for (var parent = workInProgress, isInsidePropagationBailout = !1; null !== parent;) {
+      if (!isInsidePropagationBailout) if (0 !== (parent.flags & 524288)) isInsidePropagationBailout = !0;else if (0 !== (parent.flags & 262144)) break;
+      if (10 === parent.tag) {
+        var currentParent = parent.alternate;
+        if (null === currentParent) throw Error("Should have a current fiber. This is a bug in React.");
+        currentParent = currentParent.memoizedProps;
+        if (null !== currentParent) {
+          var context = parent.type;
+          objectIs(parent.pendingProps.value, currentParent.value) || (null !== current ? current.push(context) : current = [context]);
+        }
+      } else if (parent === hostTransitionProviderCursor.current) {
+        currentParent = parent.alternate;
+        if (null === currentParent) throw Error("Should have a current fiber. This is a bug in React.");
+        currentParent.memoizedState.memoizedState !== parent.memoizedState.memoizedState && (null !== current ? current.push(HostTransitionContext) : current = [HostTransitionContext]);
+      }
+      parent = parent.return;
+    }
+    null !== current && propagateContextChanges(workInProgress, current, renderLanes, forcePropagateEntireTree);
+    workInProgress.flags |= 262144;
+  }
+  function checkIfContextChanged(currentDependencies) {
+    for (currentDependencies = currentDependencies.firstContext; null !== currentDependencies;) {
+      if (!objectIs(currentDependencies.context._currentValue, currentDependencies.memoizedValue)) return !0;
+      currentDependencies = currentDependencies.next;
+    }
+    return !1;
+  }
+  function prepareToReadContext(workInProgress) {
+    currentlyRenderingFiber$1 = workInProgress;
+    lastContextDependency = null;
+    workInProgress = workInProgress.dependencies;
+    null !== workInProgress && (workInProgress.firstContext = null);
+  }
+  function readContext(context) {
+    return readContextForConsumer(currentlyRenderingFiber$1, context);
+  }
+  function readContextDuringReconciliation(consumer, context) {
+    null === currentlyRenderingFiber$1 && prepareToReadContext(consumer);
+    return readContextForConsumer(consumer, context);
+  }
+  function readContextForConsumer(consumer, context) {
+    var value = context._currentValue;
+    context = {
+      context: context,
+      memoizedValue: value,
+      next: null
+    };
+    if (null === lastContextDependency) {
+      if (null === consumer) throw Error("Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo().");
+      lastContextDependency = context;
+      consumer.dependencies = {
+        lanes: 0,
+        firstContext: context
+      };
+      consumer.flags |= 524288;
+    } else lastContextDependency = lastContextDependency.next = context;
+    return value;
+  }
+  var AbortControllerLocal = "undefined" !== typeof AbortController ? AbortController : function () {
+      var listeners = [],
+        signal = this.signal = {
+          aborted: !1,
+          addEventListener: function addEventListener(type, listener) {
+            listeners.push(listener);
+          }
+        };
+      this.abort = function () {
+        signal.aborted = !0;
+        listeners.forEach(function (listener) {
+          return listener();
+        });
+      };
+    },
+    CacheContext = {
+      $$typeof: REACT_CONTEXT_TYPE,
+      Consumer: null,
+      Provider: null,
+      _currentValue: null,
+      _currentValue2: null,
+      _threadCount: 0
+    };
+  function createCache() {
+    return {
+      controller: new AbortControllerLocal(),
+      data: new Map(),
+      refCount: 0
+    };
+  }
+  function releaseCache(cache) {
+    cache.refCount--;
+    0 === cache.refCount && _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_scheduleCallback(_$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_NormalPriority, function () {
+      cache.controller.abort();
+    });
+  }
+  var firstScheduledRoot = null,
+    lastScheduledRoot = null,
+    didScheduleMicrotask = !1,
+    mightHavePendingSyncWork = !1,
+    isFlushingWork = !1,
+    currentEventTransitionLane = 0;
+  function ensureRootIsScheduled(root) {
+    root !== lastScheduledRoot && null === root.next && (null === lastScheduledRoot ? firstScheduledRoot = lastScheduledRoot = root : lastScheduledRoot = lastScheduledRoot.next = root);
+    mightHavePendingSyncWork = !0;
+    didScheduleMicrotask || (didScheduleMicrotask = !0, _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_scheduleCallback(_$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_ImmediatePriority, processRootScheduleInImmediateTask));
+  }
+  function flushSyncWorkAcrossRoots_impl(syncTransitionLanes, onlyLegacy) {
+    if (!isFlushingWork && mightHavePendingSyncWork) {
+      isFlushingWork = !0;
+      do {
+        var didPerformSomeWork = !1;
+        for (var root = firstScheduledRoot; null !== root;) {
+          if (!onlyLegacy || 0 === root.tag) if (0 !== syncTransitionLanes) {
+            var pendingLanes = root.pendingLanes;
+            if (0 === pendingLanes) var JSCompiler_inline_result = 0;else {
+              var suspendedLanes = root.suspendedLanes,
+                pingedLanes = root.pingedLanes;
+              JSCompiler_inline_result = (1 << 31 - clz32(42 | syncTransitionLanes) + 1) - 1;
+              JSCompiler_inline_result &= pendingLanes & ~(suspendedLanes & ~pingedLanes);
+              JSCompiler_inline_result = JSCompiler_inline_result & 201326741 ? JSCompiler_inline_result & 201326741 | 1 : JSCompiler_inline_result ? JSCompiler_inline_result | 2 : 0;
+            }
+            0 !== JSCompiler_inline_result && (didPerformSomeWork = !0, performSyncWorkOnRoot(root, JSCompiler_inline_result));
+          } else JSCompiler_inline_result = workInProgressRootRenderLanes, JSCompiler_inline_result = getNextLanes(root, root === workInProgressRoot ? JSCompiler_inline_result : 0, null !== root.cancelPendingCommit || -1 !== root.timeoutHandle), 0 === (JSCompiler_inline_result & 3) || checkIfRootIsPrerendering(root, JSCompiler_inline_result) || (didPerformSomeWork = !0, performSyncWorkOnRoot(root, JSCompiler_inline_result));
+          root = root.next;
+        }
+      } while (didPerformSomeWork);
+      isFlushingWork = !1;
+    }
+  }
+  function processRootScheduleInImmediateTask() {
+    mightHavePendingSyncWork = didScheduleMicrotask = !1;
+    0 !== currentEventTransitionLane && (currentEventTransitionLane = 0);
+    for (var currentTime = _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_now(), prev = null, root = firstScheduledRoot; null !== root;) {
+      var next = root.next,
+        nextLanes = scheduleTaskForRootDuringMicrotask(root, currentTime);
+      0 === nextLanes ? (root.next = null, null === prev ? firstScheduledRoot = next : prev.next = next, null === next && (lastScheduledRoot = prev)) : (prev = root, 0 !== (nextLanes & 3) && (mightHavePendingSyncWork = !0));
+      root = next;
+    }
+    flushSyncWorkAcrossRoots_impl(0, !1);
+  }
+  function scheduleTaskForRootDuringMicrotask(root, currentTime) {
+    for (var suspendedLanes = root.suspendedLanes, pingedLanes = root.pingedLanes, expirationTimes = root.expirationTimes, lanes = root.pendingLanes & -62914561; 0 < lanes;) {
+      var index$10 = 31 - clz32(lanes),
+        lane = 1 << index$10,
+        expirationTime = expirationTimes[index$10];
+      if (-1 === expirationTime) {
+        if (0 === (lane & suspendedLanes) || 0 !== (lane & pingedLanes)) expirationTimes[index$10] = computeExpirationTime(lane, currentTime);
+      } else expirationTime <= currentTime && (root.expiredLanes |= lane);
+      lanes &= ~lane;
+    }
+    currentTime = workInProgressRoot;
+    suspendedLanes = workInProgressRootRenderLanes;
+    suspendedLanes = getNextLanes(root, root === currentTime ? suspendedLanes : 0, null !== root.cancelPendingCommit || -1 !== root.timeoutHandle);
+    pingedLanes = root.callbackNode;
+    if (0 === suspendedLanes || root === currentTime && (2 === workInProgressSuspendedReason || 9 === workInProgressSuspendedReason) || null !== root.cancelPendingCommit) return null !== pingedLanes && null !== pingedLanes && _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_cancelCallback(pingedLanes), root.callbackNode = null, root.callbackPriority = 0;
+    if (0 !== (suspendedLanes & 3) && !checkIfRootIsPrerendering(root, suspendedLanes)) return null !== pingedLanes && null !== pingedLanes && _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_cancelCallback(pingedLanes), root.callbackPriority = 2, root.callbackNode = null, 2;
+    currentTime = suspendedLanes & -suspendedLanes;
+    if (currentTime === root.callbackPriority) return currentTime;
+    null !== pingedLanes && _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_cancelCallback(pingedLanes);
+    switch (lanesToEventPriority(suspendedLanes)) {
+      case 2:
+      case 8:
+        suspendedLanes = _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_UserBlockingPriority;
+        break;
+      case 32:
+        suspendedLanes = _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_NormalPriority;
+        break;
+      case 268435456:
+        suspendedLanes = _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_IdlePriority;
+        break;
+      default:
+        suspendedLanes = _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_NormalPriority;
+    }
+    pingedLanes = performWorkOnRootViaSchedulerTask.bind(null, root);
+    suspendedLanes = _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_scheduleCallback(suspendedLanes, pingedLanes);
+    root.callbackPriority = currentTime;
+    root.callbackNode = suspendedLanes;
+    return currentTime;
+  }
+  function performWorkOnRootViaSchedulerTask(root, didTimeout) {
+    if (0 !== pendingEffectsStatus && 5 !== pendingEffectsStatus) return root.callbackNode = null, root.callbackPriority = 0, null;
+    var originalCallbackNode = root.callbackNode;
+    if (flushPendingEffects(!0) && root.callbackNode !== originalCallbackNode) return null;
+    var workInProgressRootRenderLanes$jscomp$0 = workInProgressRootRenderLanes;
+    workInProgressRootRenderLanes$jscomp$0 = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes$jscomp$0 : 0, null !== root.cancelPendingCommit || -1 !== root.timeoutHandle);
+    if (0 === workInProgressRootRenderLanes$jscomp$0) return null;
+    performWorkOnRoot(root, workInProgressRootRenderLanes$jscomp$0, didTimeout);
+    scheduleTaskForRootDuringMicrotask(root, _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_now());
+    return null != root.callbackNode && root.callbackNode === originalCallbackNode ? performWorkOnRootViaSchedulerTask.bind(null, root) : null;
+  }
+  function performSyncWorkOnRoot(root, lanes) {
+    if (flushPendingEffects()) return null;
+    performWorkOnRoot(root, lanes, !0);
+  }
+  function requestTransitionLane() {
+    0 === currentEventTransitionLane && (currentEventTransitionLane = claimNextTransitionLane());
+    return currentEventTransitionLane;
+  }
+  var currentEntangledListeners = null,
+    currentEntangledPendingCount = 0,
+    currentEntangledLane = 0,
+    currentEntangledActionThenable = null;
+  function entangleAsyncAction(transition, thenable) {
+    if (null === currentEntangledListeners) {
+      var entangledListeners = currentEntangledListeners = [];
+      currentEntangledPendingCount = 0;
+      currentEntangledLane = requestTransitionLane();
+      currentEntangledActionThenable = {
+        status: "pending",
+        value: void 0,
+        then: function then(resolve) {
+          entangledListeners.push(resolve);
+        }
+      };
+    }
+    currentEntangledPendingCount++;
+    thenable.then(pingEngtangledActionScope, pingEngtangledActionScope);
+    return thenable;
+  }
+  function pingEngtangledActionScope() {
+    if (0 === --currentEntangledPendingCount && null !== currentEntangledListeners) {
+      null !== currentEntangledActionThenable && (currentEntangledActionThenable.status = "fulfilled");
+      var listeners = currentEntangledListeners;
+      currentEntangledListeners = null;
+      currentEntangledLane = 0;
+      currentEntangledActionThenable = null;
+      for (var i = 0; i < listeners.length; i++) (0, listeners[i])();
+    }
+  }
+  function chainThenableValue(thenable, result) {
+    var listeners = [],
+      thenableWithOverride = {
+        status: "pending",
+        value: null,
+        reason: null,
+        then: function then(resolve) {
+          listeners.push(resolve);
+        }
+      };
+    thenable.then(function () {
+      thenableWithOverride.status = "fulfilled";
+      thenableWithOverride.value = result;
+      for (var i = 0; i < listeners.length; i++) (0, listeners[i])(result);
+    }, function (error) {
+      thenableWithOverride.status = "rejected";
+      thenableWithOverride.reason = error;
+      for (error = 0; error < listeners.length; error++) (0, listeners[error])(void 0);
+    });
+    return thenableWithOverride;
+  }
+  var prevOnStartTransitionFinish = ReactSharedInternals.S;
+  ReactSharedInternals.S = function (transition, returnValue) {
+    "object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && entangleAsyncAction(transition, returnValue);
+    null !== prevOnStartTransitionFinish && prevOnStartTransitionFinish(transition, returnValue);
+  };
+  var resumedCache = createCursor(null);
+  function peekCacheFromPool() {
+    var cacheResumedFromPreviousRender = resumedCache.current;
+    return null !== cacheResumedFromPreviousRender ? cacheResumedFromPreviousRender : workInProgressRoot.pooledCache;
+  }
+  function pushTransition(offscreenWorkInProgress, prevCachePool) {
+    null === prevCachePool ? push(resumedCache, resumedCache.current) : push(resumedCache, prevCachePool.pool);
+  }
+  function getSuspendedCache() {
+    var cacheFromPool = peekCacheFromPool();
+    return null === cacheFromPool ? null : {
+      parent: CacheContext._currentValue,
+      pool: cacheFromPool
+    };
+  }
+  var hasOwnProperty = Object.prototype.hasOwnProperty;
+  function shallowEqual(objA, objB) {
+    if (objectIs(objA, objB)) return !0;
+    if ("object" !== typeof objA || null === objA || "object" !== typeof objB || null === objB) return !1;
+    var keysA = Object.keys(objA),
+      keysB = Object.keys(objB);
+    if (keysA.length !== keysB.length) return !1;
+    for (keysB = 0; keysB < keysA.length; keysB++) {
+      var currentKey = keysA[keysB];
+      if (!hasOwnProperty.call(objB, currentKey) || !objectIs(objA[currentKey], objB[currentKey])) return !1;
+    }
+    return !0;
+  }
+  var SuspenseException = Error("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`."),
+    SuspenseyCommitException = Error("Suspense Exception: This is not a real error, and should not leak into userspace. If you're seeing this, it's likely a bug in React."),
+    SuspenseActionException = Error("Suspense Exception: This is not a real error! It's an implementation detail of `useActionState` to interrupt the current render. You must either rethrow it immediately, or move the `useActionState` 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."),
+    noopSuspenseyCommitThenable = {
+      then: function then() {}
+    };
+  function isThenableResolved(thenable) {
+    thenable = thenable.status;
+    return "fulfilled" === thenable || "rejected" === thenable;
+  }
+  function noop() {}
+  function trackUsedThenable(thenableState, thenable, index) {
+    index = thenableState[index];
+    void 0 === index ? thenableState.push(thenable) : index !== thenable && (thenable.then(noop, noop), thenable = index);
+    switch (thenable.status) {
+      case "fulfilled":
+        return thenable.value;
+      case "rejected":
+        throw thenableState = thenable.reason, checkIfUseWrappedInAsyncCatch(thenableState), thenableState;
+      default:
+        if ("string" === typeof thenable.status) thenable.then(noop, noop);else {
+          thenableState = workInProgressRoot;
+          if (null !== thenableState && 100 < thenableState.shellSuspendCounter) throw Error("An unknown Component is an async Client Component. Only Server Components can be async at the moment. This error is often caused by accidentally adding `'use client'` to a module that was originally written for the server.");
+          thenableState = thenable;
+          thenableState.status = "pending";
+          thenableState.then(function (fulfilledValue) {
+            if ("pending" === thenable.status) {
+              var fulfilledThenable = thenable;
+              fulfilledThenable.status = "fulfilled";
+              fulfilledThenable.value = fulfilledValue;
+            }
+          }, function (error) {
+            if ("pending" === thenable.status) {
+              var rejectedThenable = thenable;
+              rejectedThenable.status = "rejected";
+              rejectedThenable.reason = error;
+            }
+          });
+        }
+        switch (thenable.status) {
+          case "fulfilled":
+            return thenable.value;
+          case "rejected":
+            throw thenableState = thenable.reason, checkIfUseWrappedInAsyncCatch(thenableState), thenableState;
+        }
+        suspendedThenable = thenable;
+        throw SuspenseException;
+    }
+  }
+  var suspendedThenable = null;
+  function getSuspendedThenable() {
+    if (null === suspendedThenable) throw Error("Expected a suspended thenable. This is a bug in React. Please file an issue.");
+    var thenable = suspendedThenable;
+    suspendedThenable = null;
+    return thenable;
+  }
+  function checkIfUseWrappedInAsyncCatch(rejectedReason) {
+    if (rejectedReason === SuspenseException || rejectedReason === SuspenseActionException) throw Error("Hooks are not supported inside an async component. This error is often caused by accidentally adding `'use client'` to a module that was originally written for the server.");
+  }
+  var concurrentQueues = [],
+    concurrentQueuesIndex = 0,
+    concurrentlyUpdatedLanes = 0;
+  function finishQueueingConcurrentUpdates() {
+    for (var endIndex = concurrentQueuesIndex, i = concurrentlyUpdatedLanes = concurrentQueuesIndex = 0; i < endIndex;) {
+      var fiber = concurrentQueues[i];
+      concurrentQueues[i++] = null;
+      var queue = concurrentQueues[i];
+      concurrentQueues[i++] = null;
+      var update = concurrentQueues[i];
+      concurrentQueues[i++] = null;
+      var lane = concurrentQueues[i];
+      concurrentQueues[i++] = null;
+      if (null !== queue && null !== update) {
+        var pending = queue.pending;
+        null === pending ? update.next = update : (update.next = pending.next, pending.next = update);
+        queue.pending = update;
+      }
+      0 !== lane && markUpdateLaneFromFiberToRoot(fiber, update, lane);
+    }
+  }
+  function enqueueUpdate$1(fiber, queue, update, lane) {
+    concurrentQueues[concurrentQueuesIndex++] = fiber;
+    concurrentQueues[concurrentQueuesIndex++] = queue;
+    concurrentQueues[concurrentQueuesIndex++] = update;
+    concurrentQueues[concurrentQueuesIndex++] = lane;
+    concurrentlyUpdatedLanes |= lane;
+    fiber.lanes |= lane;
+    fiber = fiber.alternate;
+    null !== fiber && (fiber.lanes |= lane);
+  }
+  function enqueueConcurrentHookUpdate(fiber, queue, update, lane) {
+    enqueueUpdate$1(fiber, queue, update, lane);
+    return getRootForUpdatedFiber(fiber);
+  }
+  function enqueueConcurrentRenderForLane(fiber, lane) {
+    enqueueUpdate$1(fiber, null, null, lane);
+    return getRootForUpdatedFiber(fiber);
+  }
+  function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
+    sourceFiber.lanes |= lane;
+    var alternate = sourceFiber.alternate;
+    null !== alternate && (alternate.lanes |= lane);
+    for (var isHidden = !1, parent = sourceFiber.return; null !== parent;) parent.childLanes |= lane, alternate = parent.alternate, null !== alternate && (alternate.childLanes |= lane), 22 === parent.tag && (sourceFiber = parent.stateNode, null === sourceFiber || sourceFiber._visibility & 1 || (isHidden = !0)), sourceFiber = parent, parent = parent.return;
+    return 3 === sourceFiber.tag ? (parent = sourceFiber.stateNode, isHidden && null !== update && (isHidden = 31 - clz32(lane), sourceFiber = parent.hiddenUpdates, alternate = sourceFiber[isHidden], null === alternate ? sourceFiber[isHidden] = [update] : alternate.push(update), update.lane = lane | 536870912), parent) : null;
+  }
+  function getRootForUpdatedFiber(sourceFiber) {
+    if (50 < nestedUpdateCount) throw nestedUpdateCount = 0, rootWithNestedUpdates = null, Error("Maximum update depth exceeded. This can happen when a component repeatedly calls setState inside componentWillUpdate or componentDidUpdate. React limits the number of nested updates to prevent infinite loops.");
+    for (var parent = sourceFiber.return; null !== parent;) sourceFiber = parent, parent = sourceFiber.return;
+    return 3 === sourceFiber.tag ? sourceFiber.stateNode : null;
+  }
+  var hasForceUpdate = !1;
+  function initializeUpdateQueue(fiber) {
+    fiber.updateQueue = {
+      baseState: fiber.memoizedState,
+      firstBaseUpdate: null,
+      lastBaseUpdate: null,
+      shared: {
+        pending: null,
+        lanes: 0,
+        hiddenCallbacks: null
+      },
+      callbacks: null
+    };
+  }
+  function cloneUpdateQueue(current, workInProgress) {
+    current = current.updateQueue;
+    workInProgress.updateQueue === current && (workInProgress.updateQueue = {
+      baseState: current.baseState,
+      firstBaseUpdate: current.firstBaseUpdate,
+      lastBaseUpdate: current.lastBaseUpdate,
+      shared: current.shared,
+      callbacks: null
+    });
+  }
+  function createUpdate(lane) {
+    return {
+      lane: lane,
+      tag: 0,
+      payload: null,
+      callback: null,
+      next: null
+    };
+  }
+  function enqueueUpdate(fiber, update, lane) {
+    var updateQueue = fiber.updateQueue;
+    if (null === updateQueue) return null;
+    updateQueue = updateQueue.shared;
+    if (0 !== (executionContext & 2)) {
+      var pending = updateQueue.pending;
+      null === pending ? update.next = update : (update.next = pending.next, pending.next = update);
+      updateQueue.pending = update;
+      update = getRootForUpdatedFiber(fiber);
+      markUpdateLaneFromFiberToRoot(fiber, null, lane);
+      return update;
+    }
+    enqueueUpdate$1(fiber, updateQueue, update, lane);
+    return getRootForUpdatedFiber(fiber);
+  }
+  function entangleTransitions(root, fiber, lane) {
+    fiber = fiber.updateQueue;
+    if (null !== fiber && (fiber = fiber.shared, 0 !== (lane & 4194048))) {
+      var queueLanes = fiber.lanes;
+      queueLanes &= root.pendingLanes;
+      lane |= queueLanes;
+      fiber.lanes = lane;
+      markRootEntangled(root, lane);
+    }
+  }
+  function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
+    var queue = workInProgress.updateQueue,
+      current = workInProgress.alternate;
+    if (null !== current && (current = current.updateQueue, queue === current)) {
+      var newFirst = null,
+        newLast = null;
+      queue = queue.firstBaseUpdate;
+      if (null !== queue) {
+        do {
+          var clone = {
+            lane: queue.lane,
+            tag: queue.tag,
+            payload: queue.payload,
+            callback: null,
+            next: null
+          };
+          null === newLast ? newFirst = newLast = clone : newLast = newLast.next = clone;
+          queue = queue.next;
+        } while (null !== queue);
+        null === newLast ? newFirst = newLast = capturedUpdate : newLast = newLast.next = capturedUpdate;
+      } else newFirst = newLast = capturedUpdate;
+      queue = {
+        baseState: current.baseState,
+        firstBaseUpdate: newFirst,
+        lastBaseUpdate: newLast,
+        shared: current.shared,
+        callbacks: current.callbacks
+      };
+      workInProgress.updateQueue = queue;
+      return;
+    }
+    workInProgress = queue.lastBaseUpdate;
+    null === workInProgress ? queue.firstBaseUpdate = capturedUpdate : workInProgress.next = capturedUpdate;
+    queue.lastBaseUpdate = capturedUpdate;
+  }
+  var didReadFromEntangledAsyncAction = !1;
+  function suspendIfUpdateReadFromEntangledAsyncAction() {
+    if (didReadFromEntangledAsyncAction) {
+      var entangledActionThenable = currentEntangledActionThenable;
+      if (null !== entangledActionThenable) throw entangledActionThenable;
+    }
+  }
+  function processUpdateQueue(workInProgress$jscomp$0, props, instance$jscomp$0, renderLanes) {
+    didReadFromEntangledAsyncAction = !1;
+    var queue = workInProgress$jscomp$0.updateQueue;
+    hasForceUpdate = !1;
+    var firstBaseUpdate = queue.firstBaseUpdate,
+      lastBaseUpdate = queue.lastBaseUpdate,
+      pendingQueue = queue.shared.pending;
+    if (null !== pendingQueue) {
+      queue.shared.pending = null;
+      var lastPendingUpdate = pendingQueue,
+        firstPendingUpdate = lastPendingUpdate.next;
+      lastPendingUpdate.next = null;
+      null === lastBaseUpdate ? firstBaseUpdate = firstPendingUpdate : lastBaseUpdate.next = firstPendingUpdate;
+      lastBaseUpdate = lastPendingUpdate;
+      var current = workInProgress$jscomp$0.alternate;
+      null !== current && (current = current.updateQueue, pendingQueue = current.lastBaseUpdate, pendingQueue !== lastBaseUpdate && (null === pendingQueue ? current.firstBaseUpdate = firstPendingUpdate : pendingQueue.next = firstPendingUpdate, current.lastBaseUpdate = lastPendingUpdate));
+    }
+    if (null !== firstBaseUpdate) {
+      var newState = queue.baseState;
+      lastBaseUpdate = 0;
+      current = firstPendingUpdate = lastPendingUpdate = null;
+      pendingQueue = firstBaseUpdate;
+      do {
+        var updateLane = pendingQueue.lane & -536870913,
+          isHiddenUpdate = updateLane !== pendingQueue.lane;
+        if (isHiddenUpdate ? (workInProgressRootRenderLanes & updateLane) === updateLane : (renderLanes & updateLane) === updateLane) {
+          0 !== updateLane && updateLane === currentEntangledLane && (didReadFromEntangledAsyncAction = !0);
+          null !== current && (current = current.next = {
+            lane: 0,
+            tag: pendingQueue.tag,
+            payload: pendingQueue.payload,
+            callback: null,
+            next: null
+          });
+          a: {
+            var workInProgress = workInProgress$jscomp$0,
+              update = pendingQueue;
+            updateLane = props;
+            var instance = instance$jscomp$0;
+            switch (update.tag) {
+              case 1:
+                workInProgress = update.payload;
+                if ("function" === typeof workInProgress) {
+                  newState = workInProgress.call(instance, newState, updateLane);
+                  break a;
+                }
+                newState = workInProgress;
+                break a;
+              case 3:
+                workInProgress.flags = workInProgress.flags & -65537 | 128;
+              case 0:
+                workInProgress = update.payload;
+                updateLane = "function" === typeof workInProgress ? workInProgress.call(instance, newState, updateLane) : workInProgress;
+                if (null === updateLane || void 0 === updateLane) break a;
+                newState = assign({}, newState, updateLane);
+                break a;
+              case 2:
+                hasForceUpdate = !0;
+            }
+          }
+          updateLane = pendingQueue.callback;
+          null !== updateLane && (workInProgress$jscomp$0.flags |= 64, isHiddenUpdate && (workInProgress$jscomp$0.flags |= 8192), isHiddenUpdate = queue.callbacks, null === isHiddenUpdate ? queue.callbacks = [updateLane] : isHiddenUpdate.push(updateLane));
+        } else isHiddenUpdate = {
+          lane: updateLane,
+          tag: pendingQueue.tag,
+          payload: pendingQueue.payload,
+          callback: pendingQueue.callback,
+          next: null
+        }, null === current ? (firstPendingUpdate = current = isHiddenUpdate, lastPendingUpdate = newState) : current = current.next = isHiddenUpdate, lastBaseUpdate |= updateLane;
+        pendingQueue = pendingQueue.next;
+        if (null === pendingQueue) if (pendingQueue = queue.shared.pending, null === pendingQueue) break;else isHiddenUpdate = pendingQueue, pendingQueue = isHiddenUpdate.next, isHiddenUpdate.next = null, queue.lastBaseUpdate = isHiddenUpdate, queue.shared.pending = null;
+      } while (1);
+      null === current && (lastPendingUpdate = newState);
+      queue.baseState = lastPendingUpdate;
+      queue.firstBaseUpdate = firstPendingUpdate;
+      queue.lastBaseUpdate = current;
+      null === firstBaseUpdate && (queue.shared.lanes = 0);
+      workInProgressRootSkippedLanes |= lastBaseUpdate;
+      workInProgress$jscomp$0.lanes = lastBaseUpdate;
+      workInProgress$jscomp$0.memoizedState = newState;
+    }
+  }
+  function callCallback(callback, context) {
+    if ("function" !== typeof callback) throw Error("Invalid argument passed as callback. Expected a function. Instead received: " + callback);
+    callback.call(context);
+  }
+  function commitCallbacks(updateQueue, context) {
+    var callbacks = updateQueue.callbacks;
+    if (null !== callbacks) for (updateQueue.callbacks = null, updateQueue = 0; updateQueue < callbacks.length; updateQueue++) callCallback(callbacks[updateQueue], context);
+  }
+  var currentTreeHiddenStackCursor = createCursor(null),
+    prevEntangledRenderLanesCursor = createCursor(0);
+  function pushHiddenContext(fiber, context) {
+    fiber = entangledRenderLanes;
+    push(prevEntangledRenderLanesCursor, fiber);
+    push(currentTreeHiddenStackCursor, context);
+    entangledRenderLanes = fiber | context.baseLanes;
+  }
+  function reuseHiddenContextOnStack() {
+    push(prevEntangledRenderLanesCursor, entangledRenderLanes);
+    push(currentTreeHiddenStackCursor, currentTreeHiddenStackCursor.current);
+  }
+  function popHiddenContext() {
+    entangledRenderLanes = prevEntangledRenderLanesCursor.current;
+    pop(currentTreeHiddenStackCursor);
+    pop(prevEntangledRenderLanesCursor);
+  }
+  var renderLanes = 0,
+    currentlyRenderingFiber = null,
+    currentHook = null,
+    workInProgressHook = null,
+    didScheduleRenderPhaseUpdate = !1,
+    didScheduleRenderPhaseUpdateDuringThisPass = !1,
+    shouldDoubleInvokeUserFnsInHooksDEV = !1,
+    thenableIndexCounter$1 = 0,
+    thenableState$1 = null,
+    globalClientIdCounter = 0;
+  function throwInvalidHookError() {
+    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://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.");
+  }
+  function areHookInputsEqual(nextDeps, prevDeps) {
+    if (null === prevDeps) return !1;
+    for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) if (!objectIs(nextDeps[i], prevDeps[i])) return !1;
+    return !0;
+  }
+  function renderWithHooks(current, workInProgress, Component, props, secondArg, nextRenderLanes) {
+    renderLanes = nextRenderLanes;
+    currentlyRenderingFiber = workInProgress;
+    workInProgress.memoizedState = null;
+    workInProgress.updateQueue = null;
+    workInProgress.lanes = 0;
+    ReactSharedInternals.H = null === current || null === current.memoizedState ? HooksDispatcherOnMount : HooksDispatcherOnUpdate;
+    shouldDoubleInvokeUserFnsInHooksDEV = !1;
+    nextRenderLanes = Component(props, secondArg);
+    shouldDoubleInvokeUserFnsInHooksDEV = !1;
+    didScheduleRenderPhaseUpdateDuringThisPass && (nextRenderLanes = renderWithHooksAgain(workInProgress, Component, props, secondArg));
+    finishRenderingHooks(current);
+    return nextRenderLanes;
+  }
+  function finishRenderingHooks(current) {
+    ReactSharedInternals.H = ContextOnlyDispatcher;
+    var didRenderTooFewHooks = null !== currentHook && null !== currentHook.next;
+    renderLanes = 0;
+    workInProgressHook = currentHook = currentlyRenderingFiber = null;
+    didScheduleRenderPhaseUpdate = !1;
+    thenableIndexCounter$1 = 0;
+    thenableState$1 = null;
+    if (didRenderTooFewHooks) throw Error("Rendered fewer hooks than expected. This may be caused by an accidental early return statement.");
+    null === current || didReceiveUpdate || (current = current.dependencies, null !== current && checkIfContextChanged(current) && (didReceiveUpdate = !0));
+  }
+  function renderWithHooksAgain(workInProgress, Component, props, secondArg) {
+    currentlyRenderingFiber = workInProgress;
+    var numberOfReRenders = 0;
+    do {
+      didScheduleRenderPhaseUpdateDuringThisPass && (thenableState$1 = null);
+      thenableIndexCounter$1 = 0;
+      didScheduleRenderPhaseUpdateDuringThisPass = !1;
+      if (25 <= numberOfReRenders) throw Error("Too many re-renders. React limits the number of renders to prevent an infinite loop.");
+      numberOfReRenders += 1;
+      workInProgressHook = currentHook = null;
+      if (null != workInProgress.updateQueue) {
+        var children = workInProgress.updateQueue;
+        children.lastEffect = null;
+        children.events = null;
+        children.stores = null;
+        null != children.memoCache && (children.memoCache.index = 0);
+      }
+      ReactSharedInternals.H = HooksDispatcherOnRerender;
+      children = Component(props, secondArg);
+    } while (didScheduleRenderPhaseUpdateDuringThisPass);
+    return children;
+  }
+  function TransitionAwareHostComponent() {
+    var dispatcher = ReactSharedInternals.H,
+      maybeThenable = dispatcher.useState()[0];
+    maybeThenable = "function" === typeof maybeThenable.then ? useThenable(maybeThenable) : maybeThenable;
+    dispatcher = dispatcher.useState()[0];
+    (null !== currentHook ? currentHook.memoizedState : null) !== dispatcher && (currentlyRenderingFiber.flags |= 1024);
+    return maybeThenable;
+  }
+  function bailoutHooks(current, workInProgress, lanes) {
+    workInProgress.updateQueue = current.updateQueue;
+    workInProgress.flags &= -2053;
+    current.lanes &= ~lanes;
+  }
+  function resetHooksOnUnwind(workInProgress) {
+    if (didScheduleRenderPhaseUpdate) {
+      for (workInProgress = workInProgress.memoizedState; null !== workInProgress;) {
+        var queue = workInProgress.queue;
+        null !== queue && (queue.pending = null);
+        workInProgress = workInProgress.next;
+      }
+      didScheduleRenderPhaseUpdate = !1;
+    }
+    renderLanes = 0;
+    workInProgressHook = currentHook = currentlyRenderingFiber = null;
+    didScheduleRenderPhaseUpdateDuringThisPass = !1;
+    thenableIndexCounter$1 = 0;
+    thenableState$1 = null;
+  }
+  function mountWorkInProgressHook() {
+    var hook = {
+      memoizedState: null,
+      baseState: null,
+      baseQueue: null,
+      queue: null,
+      next: null
+    };
+    null === workInProgressHook ? currentlyRenderingFiber.memoizedState = workInProgressHook = hook : workInProgressHook = workInProgressHook.next = hook;
+    return workInProgressHook;
+  }
+  function updateWorkInProgressHook() {
+    if (null === currentHook) {
+      var nextCurrentHook = currentlyRenderingFiber.alternate;
+      nextCurrentHook = null !== nextCurrentHook ? nextCurrentHook.memoizedState : null;
+    } else nextCurrentHook = currentHook.next;
+    var nextWorkInProgressHook = null === workInProgressHook ? currentlyRenderingFiber.memoizedState : workInProgressHook.next;
+    if (null !== nextWorkInProgressHook) workInProgressHook = nextWorkInProgressHook, currentHook = nextCurrentHook;else {
+      if (null === nextCurrentHook) {
+        if (null === currentlyRenderingFiber.alternate) throw Error("Update hook called on initial render. This is likely a bug in React. Please file an issue.");
+        throw Error("Rendered more hooks than during the previous render.");
+      }
+      currentHook = nextCurrentHook;
+      nextCurrentHook = {
+        memoizedState: currentHook.memoizedState,
+        baseState: currentHook.baseState,
+        baseQueue: currentHook.baseQueue,
+        queue: currentHook.queue,
+        next: null
+      };
+      null === workInProgressHook ? currentlyRenderingFiber.memoizedState = workInProgressHook = nextCurrentHook : workInProgressHook = workInProgressHook.next = nextCurrentHook;
+    }
+    return workInProgressHook;
+  }
+  function createFunctionComponentUpdateQueue() {
+    return {
+      lastEffect: null,
+      events: null,
+      stores: null,
+      memoCache: null
+    };
+  }
+  function useThenable(thenable) {
+    var index = thenableIndexCounter$1;
+    thenableIndexCounter$1 += 1;
+    null === thenableState$1 && (thenableState$1 = []);
+    thenable = trackUsedThenable(thenableState$1, thenable, index);
+    index = currentlyRenderingFiber;
+    null === (null === workInProgressHook ? index.memoizedState : workInProgressHook.next) && (index = index.alternate, ReactSharedInternals.H = null === index || null === index.memoizedState ? HooksDispatcherOnMount : HooksDispatcherOnUpdate);
+    return thenable;
+  }
+  function use(usable) {
+    if (null !== usable && "object" === typeof usable) {
+      if ("function" === typeof usable.then) return useThenable(usable);
+      if (usable.$$typeof === REACT_CONTEXT_TYPE) return readContext(usable);
+    }
+    throw Error("An unsupported type was passed to use(): " + String(usable));
+  }
+  function useMemoCache(size) {
+    var memoCache = null,
+      updateQueue = currentlyRenderingFiber.updateQueue;
+    null !== updateQueue && (memoCache = updateQueue.memoCache);
+    if (null == memoCache) {
+      var current = currentlyRenderingFiber.alternate;
+      null !== current && (current = current.updateQueue, null !== current && (current = current.memoCache, null != current && (memoCache = {
+        data: current.data.map(function (array) {
+          return array.slice();
+        }),
+        index: 0
+      })));
+    }
+    null == memoCache && (memoCache = {
+      data: [],
+      index: 0
+    });
+    null === updateQueue && (updateQueue = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = updateQueue);
+    updateQueue.memoCache = memoCache;
+    updateQueue = memoCache.data[memoCache.index];
+    if (void 0 === updateQueue) for (updateQueue = memoCache.data[memoCache.index] = Array(size), current = 0; current < size; current++) updateQueue[current] = REACT_MEMO_CACHE_SENTINEL;
+    memoCache.index++;
+    return updateQueue;
+  }
+  function basicStateReducer(state, action) {
+    return "function" === typeof action ? action(state) : action;
+  }
+  function updateReducer(reducer) {
+    var hook = updateWorkInProgressHook();
+    return updateReducerImpl(hook, currentHook, reducer);
+  }
+  function updateReducerImpl(hook, current, reducer) {
+    var queue = hook.queue;
+    if (null === queue) throw Error("Should have a queue. You are likely calling Hooks conditionally, which is not allowed. (https://react.dev/link/invalid-hook-call)");
+    queue.lastRenderedReducer = reducer;
+    var baseQueue = hook.baseQueue,
+      pendingQueue = queue.pending;
+    if (null !== pendingQueue) {
+      if (null !== baseQueue) {
+        var baseFirst = baseQueue.next;
+        baseQueue.next = pendingQueue.next;
+        pendingQueue.next = baseFirst;
+      }
+      current.baseQueue = baseQueue = pendingQueue;
+      queue.pending = null;
+    }
+    pendingQueue = hook.baseState;
+    if (null === baseQueue) hook.memoizedState = pendingQueue;else {
+      current = baseQueue.next;
+      var newBaseQueueFirst = baseFirst = null,
+        newBaseQueueLast = null,
+        update = current,
+        didReadFromEntangledAsyncAction$25 = !1;
+      do {
+        var updateLane = update.lane & -536870913;
+        if (updateLane !== update.lane ? (workInProgressRootRenderLanes & updateLane) === updateLane : (renderLanes & updateLane) === updateLane) {
+          var revertLane = update.revertLane;
+          if (0 === revertLane) null !== newBaseQueueLast && (newBaseQueueLast = newBaseQueueLast.next = {
+            lane: 0,
+            revertLane: 0,
+            action: update.action,
+            hasEagerState: update.hasEagerState,
+            eagerState: update.eagerState,
+            next: null
+          }), updateLane === currentEntangledLane && (didReadFromEntangledAsyncAction$25 = !0);else if ((renderLanes & revertLane) === revertLane) {
+            update = update.next;
+            revertLane === currentEntangledLane && (didReadFromEntangledAsyncAction$25 = !0);
+            continue;
+          } else updateLane = {
+            lane: 0,
+            revertLane: update.revertLane,
+            action: update.action,
+            hasEagerState: update.hasEagerState,
+            eagerState: update.eagerState,
+            next: null
+          }, null === newBaseQueueLast ? (newBaseQueueFirst = newBaseQueueLast = updateLane, baseFirst = pendingQueue) : newBaseQueueLast = newBaseQueueLast.next = updateLane, currentlyRenderingFiber.lanes |= revertLane, workInProgressRootSkippedLanes |= revertLane;
+          updateLane = update.action;
+          shouldDoubleInvokeUserFnsInHooksDEV && reducer(pendingQueue, updateLane);
+          pendingQueue = update.hasEagerState ? update.eagerState : reducer(pendingQueue, updateLane);
+        } else revertLane = {
+          lane: updateLane,
+          revertLane: update.revertLane,
+          action: update.action,
+          hasEagerState: update.hasEagerState,
+          eagerState: update.eagerState,
+          next: null
+        }, null === newBaseQueueLast ? (newBaseQueueFirst = newBaseQueueLast = revertLane, baseFirst = pendingQueue) : newBaseQueueLast = newBaseQueueLast.next = revertLane, currentlyRenderingFiber.lanes |= updateLane, workInProgressRootSkippedLanes |= updateLane;
+        update = update.next;
+      } while (null !== update && update !== current);
+      null === newBaseQueueLast ? baseFirst = pendingQueue : newBaseQueueLast.next = newBaseQueueFirst;
+      if (!objectIs(pendingQueue, hook.memoizedState) && (didReceiveUpdate = !0, didReadFromEntangledAsyncAction$25 && (reducer = currentEntangledActionThenable, null !== reducer))) throw reducer;
+      hook.memoizedState = pendingQueue;
+      hook.baseState = baseFirst;
+      hook.baseQueue = newBaseQueueLast;
+      queue.lastRenderedState = pendingQueue;
+    }
+    null === baseQueue && (queue.lanes = 0);
+    return [hook.memoizedState, queue.dispatch];
+  }
+  function rerenderReducer(reducer) {
+    var hook = updateWorkInProgressHook(),
+      queue = hook.queue;
+    if (null === queue) throw Error("Should have a queue. You are likely calling Hooks conditionally, which is not allowed. (https://react.dev/link/invalid-hook-call)");
+    queue.lastRenderedReducer = reducer;
+    var dispatch = queue.dispatch,
+      lastRenderPhaseUpdate = queue.pending,
+      newState = hook.memoizedState;
+    if (null !== lastRenderPhaseUpdate) {
+      queue.pending = null;
+      var update = lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+      do newState = reducer(newState, update.action), update = update.next; while (update !== lastRenderPhaseUpdate);
+      objectIs(newState, hook.memoizedState) || (didReceiveUpdate = !0);
+      hook.memoizedState = newState;
+      null === hook.baseQueue && (hook.baseState = newState);
+      queue.lastRenderedState = newState;
+    }
+    return [newState, dispatch];
+  }
+  function updateSyncExternalStore(subscribe, getSnapshot) {
+    var fiber = currentlyRenderingFiber,
+      hook = updateWorkInProgressHook();
+    var nextSnapshot = getSnapshot();
+    var snapshotChanged = !objectIs((currentHook || hook).memoizedState, nextSnapshot);
+    snapshotChanged && (hook.memoizedState = nextSnapshot, didReceiveUpdate = !0);
+    hook = hook.queue;
+    var create = subscribeToStore.bind(null, fiber, hook, subscribe);
+    updateEffectImpl(2048, 8, create, [subscribe]);
+    if (hook.getSnapshot !== getSnapshot || snapshotChanged || null !== workInProgressHook && workInProgressHook.memoizedState.tag & 1) {
+      fiber.flags |= 2048;
+      pushSimpleEffect(9, createEffectInstance(), updateStoreInstance.bind(null, fiber, hook, nextSnapshot, getSnapshot), null);
+      if (null === workInProgressRoot) throw Error("Expected a work-in-progress root. This is a bug in React. Please file an issue.");
+      0 !== (renderLanes & 124) || pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+    }
+    return nextSnapshot;
+  }
+  function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
+    fiber.flags |= 16384;
+    fiber = {
+      getSnapshot: getSnapshot,
+      value: renderedSnapshot
+    };
+    getSnapshot = currentlyRenderingFiber.updateQueue;
+    null === getSnapshot ? (getSnapshot = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = getSnapshot, getSnapshot.stores = [fiber]) : (renderedSnapshot = getSnapshot.stores, null === renderedSnapshot ? getSnapshot.stores = [fiber] : renderedSnapshot.push(fiber));
+  }
+  function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
+    inst.value = nextSnapshot;
+    inst.getSnapshot = getSnapshot;
+    checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
+  }
+  function subscribeToStore(fiber, inst, subscribe) {
+    return subscribe(function () {
+      checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
+    });
+  }
+  function checkIfSnapshotChanged(inst) {
+    var latestGetSnapshot = inst.getSnapshot;
+    inst = inst.value;
+    try {
+      var nextValue = latestGetSnapshot();
+      return !objectIs(inst, nextValue);
+    } catch (error) {
+      return !0;
+    }
+  }
+  function forceStoreRerender(fiber) {
+    var root = enqueueConcurrentRenderForLane(fiber, 2);
+    null !== root && scheduleUpdateOnFiber(root, fiber, 2);
+  }
+  function mountStateImpl(initialState) {
+    var hook = mountWorkInProgressHook();
+    if ("function" === typeof initialState) {
+      var initialStateInitializer = initialState;
+      initialState = initialStateInitializer();
+      if (shouldDoubleInvokeUserFnsInHooksDEV) {
+        setIsStrictModeForDevtools(!0);
+        try {
+          initialStateInitializer();
+        } finally {
+          setIsStrictModeForDevtools(!1);
+        }
+      }
+    }
+    hook.memoizedState = hook.baseState = initialState;
+    hook.queue = {
+      pending: null,
+      lanes: 0,
+      dispatch: null,
+      lastRenderedReducer: basicStateReducer,
+      lastRenderedState: initialState
+    };
+    return hook;
+  }
+  function updateOptimisticImpl(hook, current, passthrough, reducer) {
+    hook.baseState = passthrough;
+    return updateReducerImpl(hook, currentHook, "function" === typeof reducer ? reducer : basicStateReducer);
+  }
+  function dispatchActionState(fiber, actionQueue, setPendingState, setState, payload) {
+    if (isRenderPhaseUpdate(fiber)) throw Error("Cannot update form state while rendering.");
+    fiber = actionQueue.action;
+    if (null !== fiber) {
+      var actionNode = {
+        payload: payload,
+        action: fiber,
+        next: null,
+        isTransition: !0,
+        status: "pending",
+        value: null,
+        reason: null,
+        listeners: [],
+        then: function then(listener) {
+          actionNode.listeners.push(listener);
+        }
+      };
+      null !== ReactSharedInternals.T ? setPendingState(!0) : actionNode.isTransition = !1;
+      setState(actionNode);
+      setPendingState = actionQueue.pending;
+      null === setPendingState ? (actionNode.next = actionQueue.pending = actionNode, runActionStateAction(actionQueue, actionNode)) : (actionNode.next = setPendingState.next, actionQueue.pending = setPendingState.next = actionNode);
+    }
+  }
+  function runActionStateAction(actionQueue, node) {
+    var action = node.action,
+      payload = node.payload,
+      prevState = actionQueue.state;
+    if (node.isTransition) {
+      var prevTransition = ReactSharedInternals.T,
+        currentTransition = {};
+      ReactSharedInternals.T = currentTransition;
+      try {
+        var returnValue = action(prevState, payload),
+          onStartTransitionFinish = ReactSharedInternals.S;
+        null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
+        handleActionReturnValue(actionQueue, node, returnValue);
+      } catch (error) {
+        onActionError(actionQueue, node, error);
+      } finally {
+        ReactSharedInternals.T = prevTransition;
+      }
+    } else try {
+      prevTransition = action(prevState, payload), handleActionReturnValue(actionQueue, node, prevTransition);
+    } catch (error$29) {
+      onActionError(actionQueue, node, error$29);
+    }
+  }
+  function handleActionReturnValue(actionQueue, node, returnValue) {
+    null !== returnValue && "object" === typeof returnValue && "function" === typeof returnValue.then ? returnValue.then(function (nextState) {
+      onActionSuccess(actionQueue, node, nextState);
+    }, function (error) {
+      return onActionError(actionQueue, node, error);
+    }) : onActionSuccess(actionQueue, node, returnValue);
+  }
+  function onActionSuccess(actionQueue, actionNode, nextState) {
+    actionNode.status = "fulfilled";
+    actionNode.value = nextState;
+    notifyActionListeners(actionNode);
+    actionQueue.state = nextState;
+    actionNode = actionQueue.pending;
+    null !== actionNode && (nextState = actionNode.next, nextState === actionNode ? actionQueue.pending = null : (nextState = nextState.next, actionNode.next = nextState, runActionStateAction(actionQueue, nextState)));
+  }
+  function onActionError(actionQueue, actionNode, error) {
+    var last = actionQueue.pending;
+    actionQueue.pending = null;
+    if (null !== last) {
+      last = last.next;
+      do actionNode.status = "rejected", actionNode.reason = error, notifyActionListeners(actionNode), actionNode = actionNode.next; while (actionNode !== last);
+    }
+    actionQueue.action = null;
+  }
+  function notifyActionListeners(actionNode) {
+    actionNode = actionNode.listeners;
+    for (var i = 0; i < actionNode.length; i++) (0, actionNode[i])();
+  }
+  function actionStateReducer(oldState, newState) {
+    return newState;
+  }
+  function mountActionState(action, initialStateProp) {
+    var stateHook = mountWorkInProgressHook();
+    stateHook.memoizedState = stateHook.baseState = initialStateProp;
+    var stateQueue = {
+      pending: null,
+      lanes: 0,
+      dispatch: null,
+      lastRenderedReducer: actionStateReducer,
+      lastRenderedState: initialStateProp
+    };
+    stateHook.queue = stateQueue;
+    stateHook = dispatchSetState.bind(null, currentlyRenderingFiber, stateQueue);
+    stateQueue.dispatch = stateHook;
+    stateQueue = mountStateImpl(!1);
+    var setPendingState = dispatchOptimisticSetState.bind(null, currentlyRenderingFiber, !1, stateQueue.queue);
+    stateQueue = mountWorkInProgressHook();
+    var actionQueue = {
+      state: initialStateProp,
+      dispatch: null,
+      action: action,
+      pending: null
+    };
+    stateQueue.queue = actionQueue;
+    stateHook = dispatchActionState.bind(null, currentlyRenderingFiber, actionQueue, setPendingState, stateHook);
+    actionQueue.dispatch = stateHook;
+    stateQueue.memoizedState = action;
+    return [initialStateProp, stateHook, !1];
+  }
+  function updateActionState(action) {
+    var stateHook = updateWorkInProgressHook();
+    return updateActionStateImpl(stateHook, currentHook, action);
+  }
+  function updateActionStateImpl(stateHook, currentStateHook, action) {
+    currentStateHook = updateReducerImpl(stateHook, currentStateHook, actionStateReducer)[0];
+    stateHook = updateReducer(basicStateReducer)[0];
+    if ("object" === typeof currentStateHook && null !== currentStateHook && "function" === typeof currentStateHook.then) try {
+      var state = useThenable(currentStateHook);
+    } catch (x) {
+      if (x === SuspenseException) throw SuspenseActionException;
+      throw x;
+    } else state = currentStateHook;
+    currentStateHook = updateWorkInProgressHook();
+    var actionQueue = currentStateHook.queue,
+      dispatch = actionQueue.dispatch;
+    action !== currentStateHook.memoizedState && (currentlyRenderingFiber.flags |= 2048, pushSimpleEffect(9, createEffectInstance(), actionStateActionEffect.bind(null, actionQueue, action), null));
+    return [state, dispatch, stateHook];
+  }
+  function actionStateActionEffect(actionQueue, action) {
+    actionQueue.action = action;
+  }
+  function rerenderActionState(action) {
+    var stateHook = updateWorkInProgressHook(),
+      currentStateHook = currentHook;
+    if (null !== currentStateHook) return updateActionStateImpl(stateHook, currentStateHook, action);
+    updateWorkInProgressHook();
+    stateHook = stateHook.memoizedState;
+    currentStateHook = updateWorkInProgressHook();
+    var dispatch = currentStateHook.queue.dispatch;
+    currentStateHook.memoizedState = action;
+    return [stateHook, dispatch, !1];
+  }
+  function pushSimpleEffect(tag, inst, create, createDeps) {
+    tag = {
+      tag: tag,
+      create: create,
+      deps: createDeps,
+      inst: inst,
+      next: null
+    };
+    inst = currentlyRenderingFiber.updateQueue;
+    null === inst && (inst = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = inst);
+    create = inst.lastEffect;
+    null === create ? inst.lastEffect = tag.next = tag : (createDeps = create.next, create.next = tag, tag.next = createDeps, inst.lastEffect = tag);
+    return tag;
+  }
+  function createEffectInstance() {
+    return {
+      destroy: void 0,
+      resource: void 0
+    };
+  }
+  function updateRef() {
+    return updateWorkInProgressHook().memoizedState;
+  }
+  function mountEffectImpl(fiberFlags, hookFlags, create, createDeps) {
+    var hook = mountWorkInProgressHook();
+    createDeps = void 0 === createDeps ? null : createDeps;
+    currentlyRenderingFiber.flags |= fiberFlags;
+    hook.memoizedState = pushSimpleEffect(1 | hookFlags, createEffectInstance(), create, createDeps);
+  }
+  function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
+    var hook = updateWorkInProgressHook();
+    deps = void 0 === deps ? null : deps;
+    var inst = hook.memoizedState.inst;
+    null !== currentHook && null !== deps && areHookInputsEqual(deps, currentHook.memoizedState.deps) ? hook.memoizedState = pushSimpleEffect(hookFlags, inst, create, deps) : (currentlyRenderingFiber.flags |= fiberFlags, hook.memoizedState = pushSimpleEffect(1 | hookFlags, inst, create, deps));
+  }
+  function mountEffect(create, createDeps) {
+    mountEffectImpl(8390656, 8, create, createDeps);
+  }
+  function updateEffect(create, createDeps) {
+    updateEffectImpl(2048, 8, create, createDeps);
+  }
+  function updateInsertionEffect(create, deps) {
+    return updateEffectImpl(4, 2, create, deps);
+  }
+  function updateLayoutEffect(create, deps) {
+    return updateEffectImpl(4, 4, create, deps);
+  }
+  function imperativeHandleEffect(create, ref) {
+    if ("function" === typeof ref) {
+      create = create();
+      var refCleanup = ref(create);
+      return function () {
+        "function" === typeof refCleanup ? refCleanup() : ref(null);
+      };
+    }
+    if (null !== ref && void 0 !== ref) return create = create(), ref.current = create, function () {
+      ref.current = null;
+    };
+  }
+  function updateImperativeHandle(ref, create, deps) {
+    deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+    updateEffectImpl(4, 4, imperativeHandleEffect.bind(null, create, ref), deps);
+  }
+  function mountDebugValue() {}
+  function updateCallback(callback, deps) {
+    var hook = updateWorkInProgressHook();
+    deps = void 0 === deps ? null : deps;
+    var prevState = hook.memoizedState;
+    if (null !== deps && areHookInputsEqual(deps, prevState[1])) return prevState[0];
+    hook.memoizedState = [callback, deps];
+    return callback;
+  }
+  function updateMemo(nextCreate, deps) {
+    var hook = updateWorkInProgressHook();
+    deps = void 0 === deps ? null : deps;
+    var prevState = hook.memoizedState;
+    if (null !== deps && areHookInputsEqual(deps, prevState[1])) return prevState[0];
+    prevState = nextCreate();
+    if (shouldDoubleInvokeUserFnsInHooksDEV) {
+      setIsStrictModeForDevtools(!0);
+      try {
+        nextCreate();
+      } finally {
+        setIsStrictModeForDevtools(!1);
+      }
+    }
+    hook.memoizedState = [prevState, deps];
+    return prevState;
+  }
+  function mountDeferredValueImpl(hook, value, initialValue) {
+    if (void 0 === initialValue || 0 !== (renderLanes & 1073741824)) return hook.memoizedState = value;
+    hook.memoizedState = initialValue;
+    hook = requestDeferredLane();
+    currentlyRenderingFiber.lanes |= hook;
+    workInProgressRootSkippedLanes |= hook;
+    return initialValue;
+  }
+  function updateDeferredValueImpl(hook, prevValue, value, initialValue) {
+    if (objectIs(value, prevValue)) return value;
+    if (null !== currentTreeHiddenStackCursor.current) return hook = mountDeferredValueImpl(hook, value, initialValue), objectIs(hook, prevValue) || (didReceiveUpdate = !0), hook;
+    if (0 === (renderLanes & 42)) return didReceiveUpdate = !0, hook.memoizedState = value;
+    hook = requestDeferredLane();
+    currentlyRenderingFiber.lanes |= hook;
+    workInProgressRootSkippedLanes |= hook;
+    return prevValue;
+  }
+  function startTransition(fiber, queue, pendingState, finishedState, callback) {
+    var previousPriority = currentUpdatePriority;
+    currentUpdatePriority = 0 !== previousPriority && 8 > previousPriority ? previousPriority : 8;
+    var prevTransition = ReactSharedInternals.T,
+      currentTransition = {};
+    ReactSharedInternals.T = currentTransition;
+    dispatchOptimisticSetState(fiber, !1, queue, pendingState);
+    try {
+      var returnValue = callback(),
+        onStartTransitionFinish = ReactSharedInternals.S;
+      null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
+      if (null !== returnValue && "object" === typeof returnValue && "function" === typeof returnValue.then) {
+        var thenableForFinishedState = chainThenableValue(returnValue, finishedState);
+        dispatchSetStateInternal(fiber, queue, thenableForFinishedState, requestUpdateLane(fiber));
+      } else dispatchSetStateInternal(fiber, queue, finishedState, requestUpdateLane(fiber));
+    } catch (error) {
+      dispatchSetStateInternal(fiber, queue, {
+        then: function then() {},
+        status: "rejected",
+        reason: error
+      }, requestUpdateLane(fiber));
+    } finally {
+      currentUpdatePriority = previousPriority, ReactSharedInternals.T = prevTransition;
+    }
+  }
+  function useHostTransitionStatus() {
+    return readContext(HostTransitionContext);
+  }
+  function updateId() {
+    return updateWorkInProgressHook().memoizedState;
+  }
+  function updateRefresh() {
+    return updateWorkInProgressHook().memoizedState;
+  }
+  function refreshCache(fiber) {
+    for (var provider = fiber.return; null !== provider;) {
+      switch (provider.tag) {
+        case 24:
+        case 3:
+          var lane = requestUpdateLane(provider);
+          fiber = createUpdate(lane);
+          var root = enqueueUpdate(provider, fiber, lane);
+          null !== root && (scheduleUpdateOnFiber(root, provider, lane), entangleTransitions(root, provider, lane));
+          provider = {
+            cache: createCache()
+          };
+          fiber.payload = provider;
+          return;
+      }
+      provider = provider.return;
+    }
+  }
+  function dispatchReducerAction(fiber, queue, action) {
+    var lane = requestUpdateLane(fiber);
+    action = {
+      lane: lane,
+      revertLane: 0,
+      action: action,
+      hasEagerState: !1,
+      eagerState: null,
+      next: null
+    };
+    isRenderPhaseUpdate(fiber) ? enqueueRenderPhaseUpdate(queue, action) : (action = enqueueConcurrentHookUpdate(fiber, queue, action, lane), null !== action && (scheduleUpdateOnFiber(action, fiber, lane), entangleTransitionUpdate(action, queue, lane)));
+  }
+  function dispatchSetState(fiber, queue, action) {
+    var lane = requestUpdateLane(fiber);
+    dispatchSetStateInternal(fiber, queue, action, lane);
+  }
+  function dispatchSetStateInternal(fiber, queue, action, lane) {
+    var update = {
+      lane: lane,
+      revertLane: 0,
+      action: action,
+      hasEagerState: !1,
+      eagerState: null,
+      next: null
+    };
+    if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, update);else {
+      var alternate = fiber.alternate;
+      if (0 === fiber.lanes && (null === alternate || 0 === alternate.lanes) && (alternate = queue.lastRenderedReducer, null !== alternate)) try {
+        var currentState = queue.lastRenderedState,
+          eagerState = alternate(currentState, action);
+        update.hasEagerState = !0;
+        update.eagerState = eagerState;
+        if (objectIs(eagerState, currentState)) return enqueueUpdate$1(fiber, queue, update, 0), null === workInProgressRoot && finishQueueingConcurrentUpdates(), !1;
+      } catch (error) {} finally {}
+      action = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
+      if (null !== action) return scheduleUpdateOnFiber(action, fiber, lane), entangleTransitionUpdate(action, queue, lane), !0;
+    }
+    return !1;
+  }
+  function dispatchOptimisticSetState(fiber, throwIfDuringRender, queue, action) {
+    action = {
+      lane: 2,
+      revertLane: requestTransitionLane(),
+      action: action,
+      hasEagerState: !1,
+      eagerState: null,
+      next: null
+    };
+    if (isRenderPhaseUpdate(fiber)) {
+      if (throwIfDuringRender) throw Error("Cannot update optimistic state while rendering.");
+    } else throwIfDuringRender = enqueueConcurrentHookUpdate(fiber, queue, action, 2), null !== throwIfDuringRender && scheduleUpdateOnFiber(throwIfDuringRender, fiber, 2);
+  }
+  function isRenderPhaseUpdate(fiber) {
+    var alternate = fiber.alternate;
+    return fiber === currentlyRenderingFiber || null !== alternate && alternate === currentlyRenderingFiber;
+  }
+  function enqueueRenderPhaseUpdate(queue, update) {
+    didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate = !0;
+    var pending = queue.pending;
+    null === pending ? update.next = update : (update.next = pending.next, pending.next = update);
+    queue.pending = update;
+  }
+  function entangleTransitionUpdate(root, queue, lane) {
+    if (0 !== (lane & 4194048)) {
+      var queueLanes = queue.lanes;
+      queueLanes &= root.pendingLanes;
+      lane |= queueLanes;
+      queue.lanes = lane;
+      markRootEntangled(root, lane);
+    }
+  }
+  var ContextOnlyDispatcher = {
+      readContext: readContext,
+      use: use,
+      useCallback: throwInvalidHookError,
+      useContext: throwInvalidHookError,
+      useEffect: throwInvalidHookError,
+      useImperativeHandle: throwInvalidHookError,
+      useLayoutEffect: throwInvalidHookError,
+      useInsertionEffect: throwInvalidHookError,
+      useMemo: throwInvalidHookError,
+      useReducer: throwInvalidHookError,
+      useRef: throwInvalidHookError,
+      useState: throwInvalidHookError,
+      useDebugValue: throwInvalidHookError,
+      useDeferredValue: throwInvalidHookError,
+      useTransition: throwInvalidHookError,
+      useSyncExternalStore: throwInvalidHookError,
+      useId: throwInvalidHookError,
+      useHostTransitionStatus: throwInvalidHookError,
+      useFormState: throwInvalidHookError,
+      useActionState: throwInvalidHookError,
+      useOptimistic: throwInvalidHookError,
+      useMemoCache: throwInvalidHookError,
+      useCacheRefresh: throwInvalidHookError
+    },
+    HooksDispatcherOnMount = {
+      readContext: readContext,
+      use: use,
+      useCallback: function useCallback(callback, deps) {
+        mountWorkInProgressHook().memoizedState = [callback, void 0 === deps ? null : deps];
+        return callback;
+      },
+      useContext: readContext,
+      useEffect: mountEffect,
+      useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+        deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+        mountEffectImpl(4194308, 4, imperativeHandleEffect.bind(null, create, ref), deps);
+      },
+      useLayoutEffect: function useLayoutEffect(create, deps) {
+        return mountEffectImpl(4194308, 4, create, deps);
+      },
+      useInsertionEffect: function useInsertionEffect(create, deps) {
+        mountEffectImpl(4, 2, create, deps);
+      },
+      useMemo: function useMemo(nextCreate, deps) {
+        var hook = mountWorkInProgressHook();
+        deps = void 0 === deps ? null : deps;
+        var nextValue = nextCreate();
+        if (shouldDoubleInvokeUserFnsInHooksDEV) {
+          setIsStrictModeForDevtools(!0);
+          try {
+            nextCreate();
+          } finally {
+            setIsStrictModeForDevtools(!1);
+          }
+        }
+        hook.memoizedState = [nextValue, deps];
+        return nextValue;
+      },
+      useReducer: function useReducer(reducer, initialArg, init) {
+        var hook = mountWorkInProgressHook();
+        if (void 0 !== init) {
+          var initialState = init(initialArg);
+          if (shouldDoubleInvokeUserFnsInHooksDEV) {
+            setIsStrictModeForDevtools(!0);
+            try {
+              init(initialArg);
+            } finally {
+              setIsStrictModeForDevtools(!1);
+            }
+          }
+        } else initialState = initialArg;
+        hook.memoizedState = hook.baseState = initialState;
+        reducer = {
+          pending: null,
+          lanes: 0,
+          dispatch: null,
+          lastRenderedReducer: reducer,
+          lastRenderedState: initialState
+        };
+        hook.queue = reducer;
+        reducer = reducer.dispatch = dispatchReducerAction.bind(null, currentlyRenderingFiber, reducer);
+        return [hook.memoizedState, reducer];
+      },
+      useRef: function useRef(initialValue) {
+        var hook = mountWorkInProgressHook();
+        initialValue = {
+          current: initialValue
+        };
+        return hook.memoizedState = initialValue;
+      },
+      useState: function useState(initialState) {
+        initialState = mountStateImpl(initialState);
+        var queue = initialState.queue,
+          dispatch = dispatchSetState.bind(null, currentlyRenderingFiber, queue);
+        queue.dispatch = dispatch;
+        return [initialState.memoizedState, dispatch];
+      },
+      useDebugValue: mountDebugValue,
+      useDeferredValue: function useDeferredValue(value, initialValue) {
+        var hook = mountWorkInProgressHook();
+        return mountDeferredValueImpl(hook, value, initialValue);
+      },
+      useTransition: function useTransition() {
+        var stateHook = mountStateImpl(!1);
+        stateHook = startTransition.bind(null, currentlyRenderingFiber, stateHook.queue, !0, !1);
+        mountWorkInProgressHook().memoizedState = stateHook;
+        return [!1, stateHook];
+      },
+      useSyncExternalStore: function useSyncExternalStore(subscribe, getSnapshot) {
+        var fiber = currentlyRenderingFiber,
+          hook = mountWorkInProgressHook();
+        var nextSnapshot = getSnapshot();
+        if (null === workInProgressRoot) throw Error("Expected a work-in-progress root. This is a bug in React. Please file an issue.");
+        0 !== (workInProgressRootRenderLanes & 124) || pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
+        hook.memoizedState = nextSnapshot;
+        var inst = {
+          value: nextSnapshot,
+          getSnapshot: getSnapshot
+        };
+        hook.queue = inst;
+        mountEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [subscribe]);
+        fiber.flags |= 2048;
+        pushSimpleEffect(9, createEffectInstance(), updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot), null);
+        return nextSnapshot;
+      },
+      useId: function useId() {
+        var hook = mountWorkInProgressHook(),
+          identifierPrefix = workInProgressRoot.identifierPrefix,
+          globalClientId = globalClientIdCounter++;
+        identifierPrefix = "\xAB" + identifierPrefix + "r" + globalClientId.toString(32) + "\xBB";
+        return hook.memoizedState = identifierPrefix;
+      },
+      useHostTransitionStatus: useHostTransitionStatus,
+      useFormState: mountActionState,
+      useActionState: mountActionState,
+      useOptimistic: function useOptimistic(passthrough) {
+        var hook = mountWorkInProgressHook();
+        hook.memoizedState = hook.baseState = passthrough;
+        var queue = {
+          pending: null,
+          lanes: 0,
+          dispatch: null,
+          lastRenderedReducer: null,
+          lastRenderedState: null
+        };
+        hook.queue = queue;
+        hook = dispatchOptimisticSetState.bind(null, currentlyRenderingFiber, !0, queue);
+        queue.dispatch = hook;
+        return [passthrough, hook];
+      },
+      useMemoCache: useMemoCache,
+      useCacheRefresh: function useCacheRefresh() {
+        return mountWorkInProgressHook().memoizedState = refreshCache.bind(null, currentlyRenderingFiber);
+      }
+    },
+    HooksDispatcherOnUpdate = {
+      readContext: readContext,
+      use: use,
+      useCallback: updateCallback,
+      useContext: readContext,
+      useEffect: updateEffect,
+      useImperativeHandle: updateImperativeHandle,
+      useInsertionEffect: updateInsertionEffect,
+      useLayoutEffect: updateLayoutEffect,
+      useMemo: updateMemo,
+      useReducer: updateReducer,
+      useRef: updateRef,
+      useState: function useState() {
+        return updateReducer(basicStateReducer);
+      },
+      useDebugValue: mountDebugValue,
+      useDeferredValue: function useDeferredValue(value, initialValue) {
+        var hook = updateWorkInProgressHook();
+        return updateDeferredValueImpl(hook, currentHook.memoizedState, value, initialValue);
+      },
+      useTransition: function useTransition() {
+        var booleanOrThenable = updateReducer(basicStateReducer)[0],
+          start = updateWorkInProgressHook().memoizedState;
+        return ["boolean" === typeof booleanOrThenable ? booleanOrThenable : useThenable(booleanOrThenable), start];
+      },
+      useSyncExternalStore: updateSyncExternalStore,
+      useId: updateId,
+      useHostTransitionStatus: useHostTransitionStatus,
+      useFormState: updateActionState,
+      useActionState: updateActionState,
+      useOptimistic: function useOptimistic(passthrough, reducer) {
+        var hook = updateWorkInProgressHook();
+        return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
+      },
+      useMemoCache: useMemoCache,
+      useCacheRefresh: updateRefresh
+    },
+    HooksDispatcherOnRerender = {
+      readContext: readContext,
+      use: use,
+      useCallback: updateCallback,
+      useContext: readContext,
+      useEffect: updateEffect,
+      useImperativeHandle: updateImperativeHandle,
+      useInsertionEffect: updateInsertionEffect,
+      useLayoutEffect: updateLayoutEffect,
+      useMemo: updateMemo,
+      useReducer: rerenderReducer,
+      useRef: updateRef,
+      useState: function useState() {
+        return rerenderReducer(basicStateReducer);
+      },
+      useDebugValue: mountDebugValue,
+      useDeferredValue: function useDeferredValue(value, initialValue) {
+        var hook = updateWorkInProgressHook();
+        return null === currentHook ? mountDeferredValueImpl(hook, value, initialValue) : updateDeferredValueImpl(hook, currentHook.memoizedState, value, initialValue);
+      },
+      useTransition: function useTransition() {
+        var booleanOrThenable = rerenderReducer(basicStateReducer)[0],
+          start = updateWorkInProgressHook().memoizedState;
+        return ["boolean" === typeof booleanOrThenable ? booleanOrThenable : useThenable(booleanOrThenable), start];
+      },
+      useSyncExternalStore: updateSyncExternalStore,
+      useId: updateId,
+      useHostTransitionStatus: useHostTransitionStatus,
+      useFormState: rerenderActionState,
+      useActionState: rerenderActionState,
+      useOptimistic: function useOptimistic(passthrough, reducer) {
+        var hook = updateWorkInProgressHook();
+        if (null !== currentHook) return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
+        hook.baseState = passthrough;
+        return [passthrough, hook.queue.dispatch];
+      },
+      useMemoCache: useMemoCache,
+      useCacheRefresh: updateRefresh
+    },
+    thenableState = null,
+    thenableIndexCounter = 0;
+  function unwrapThenable(thenable) {
+    var index = thenableIndexCounter;
+    thenableIndexCounter += 1;
+    null === thenableState && (thenableState = []);
+    return trackUsedThenable(thenableState, thenable, index);
+  }
+  function coerceRef(workInProgress, element) {
+    element = element.props.ref;
+    workInProgress.ref = void 0 !== element ? element : null;
+  }
+  function throwOnInvalidObjectType(returnFiber, newChild) {
+    if (newChild.$$typeof === REACT_LEGACY_ELEMENT_TYPE) throw Error('A React Element from an older version of React was rendered. This is not supported. It can happen if:\n- Multiple copies of the "react" package is used.\n- A library pre-bundled an old copy of "react" or "react/jsx-runtime".\n- A compiler tries to "inline" JSX instead of using the runtime.');
+    returnFiber = Object.prototype.toString.call(newChild);
+    throw Error("Objects are not valid as a React child (found: " + ("[object Object]" === returnFiber ? "object with keys {" + Object.keys(newChild).join(", ") + "}" : returnFiber) + "). If you meant to render a collection of children, use an array instead.");
+  }
+  function resolveLazy(lazyType) {
+    var init = lazyType._init;
+    return init(lazyType._payload);
+  }
+  function createChildReconciler(shouldTrackSideEffects) {
+    function deleteChild(returnFiber, childToDelete) {
+      if (shouldTrackSideEffects) {
+        var deletions = returnFiber.deletions;
+        null === deletions ? (returnFiber.deletions = [childToDelete], returnFiber.flags |= 16) : deletions.push(childToDelete);
+      }
+    }
+    function deleteRemainingChildren(returnFiber, currentFirstChild) {
+      if (!shouldTrackSideEffects) return null;
+      for (; null !== currentFirstChild;) deleteChild(returnFiber, currentFirstChild), currentFirstChild = currentFirstChild.sibling;
+      return null;
+    }
+    function mapRemainingChildren(currentFirstChild) {
+      for (var existingChildren = new Map(); null !== currentFirstChild;) null !== currentFirstChild.key ? existingChildren.set(currentFirstChild.key, currentFirstChild) : existingChildren.set(currentFirstChild.index, currentFirstChild), currentFirstChild = currentFirstChild.sibling;
+      return existingChildren;
+    }
+    function useFiber(fiber, pendingProps) {
+      fiber = createWorkInProgress(fiber, pendingProps);
+      fiber.index = 0;
+      fiber.sibling = null;
+      return fiber;
+    }
+    function placeChild(newFiber, lastPlacedIndex, newIndex) {
+      newFiber.index = newIndex;
+      if (!shouldTrackSideEffects) return newFiber.flags |= 1048576, lastPlacedIndex;
+      newIndex = newFiber.alternate;
+      if (null !== newIndex) return newIndex = newIndex.index, newIndex < lastPlacedIndex ? (newFiber.flags |= 67108866, lastPlacedIndex) : newIndex;
+      newFiber.flags |= 67108866;
+      return lastPlacedIndex;
+    }
+    function placeSingleChild(newFiber) {
+      shouldTrackSideEffects && null === newFiber.alternate && (newFiber.flags |= 67108866);
+      return newFiber;
+    }
+    function updateTextNode(returnFiber, current, textContent, lanes) {
+      if (null === current || 6 !== current.tag) return current = createFiberFromText(textContent, returnFiber.mode, lanes), current.return = returnFiber, current;
+      current = useFiber(current, textContent);
+      current.return = returnFiber;
+      return current;
+    }
+    function updateElement(returnFiber, current, element, lanes) {
+      var elementType = element.type;
+      if (elementType === REACT_FRAGMENT_TYPE) return updateFragment(returnFiber, current, element.props.children, lanes, element.key);
+      if (null !== current && (current.elementType === elementType || "object" === typeof elementType && null !== elementType && elementType.$$typeof === REACT_LAZY_TYPE && resolveLazy(elementType) === current.type)) return current = useFiber(current, element.props), coerceRef(current, element), current.return = returnFiber, current;
+      current = createFiberFromTypeAndProps(element.type, element.key, element.props, null, returnFiber.mode, lanes);
+      coerceRef(current, element);
+      current.return = returnFiber;
+      return current;
+    }
+    function updatePortal(returnFiber, current, portal, lanes) {
+      if (null === current || 4 !== current.tag || current.stateNode.containerInfo !== portal.containerInfo || current.stateNode.implementation !== portal.implementation) return current = createFiberFromPortal(portal, returnFiber.mode, lanes), current.return = returnFiber, current;
+      current = useFiber(current, portal.children || []);
+      current.return = returnFiber;
+      return current;
+    }
+    function updateFragment(returnFiber, current, fragment, lanes, key) {
+      if (null === current || 7 !== current.tag) return current = createFiberFromFragment(fragment, returnFiber.mode, lanes, key), current.return = returnFiber, current;
+      current = useFiber(current, fragment);
+      current.return = returnFiber;
+      return current;
+    }
+    function createChild(returnFiber, newChild, lanes) {
+      if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild) return newChild = createFiberFromText("" + newChild, returnFiber.mode, lanes), newChild.return = returnFiber, newChild;
+      if ("object" === typeof newChild && null !== newChild) {
+        switch (newChild.$$typeof) {
+          case REACT_ELEMENT_TYPE:
+            return lanes = createFiberFromTypeAndProps(newChild.type, newChild.key, newChild.props, null, returnFiber.mode, lanes), coerceRef(lanes, newChild), lanes.return = returnFiber, lanes;
+          case REACT_PORTAL_TYPE:
+            return newChild = createFiberFromPortal(newChild, returnFiber.mode, lanes), newChild.return = returnFiber, newChild;
+          case REACT_LAZY_TYPE:
+            var init = newChild._init;
+            newChild = init(newChild._payload);
+            return createChild(returnFiber, newChild, lanes);
+        }
+        if (isArrayImpl(newChild) || getIteratorFn(newChild)) return newChild = createFiberFromFragment(newChild, returnFiber.mode, lanes, null), newChild.return = returnFiber, newChild;
+        if ("function" === typeof newChild.then) return createChild(returnFiber, unwrapThenable(newChild), lanes);
+        if (newChild.$$typeof === REACT_CONTEXT_TYPE) return createChild(returnFiber, readContextDuringReconciliation(returnFiber, newChild), lanes);
+        throwOnInvalidObjectType(returnFiber, newChild);
+      }
+      return null;
+    }
+    function updateSlot(returnFiber, oldFiber, newChild, lanes) {
+      var key = null !== oldFiber ? oldFiber.key : null;
+      if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild) return null !== key ? null : updateTextNode(returnFiber, oldFiber, "" + newChild, lanes);
+      if ("object" === typeof newChild && null !== newChild) {
+        switch (newChild.$$typeof) {
+          case REACT_ELEMENT_TYPE:
+            return newChild.key === key ? updateElement(returnFiber, oldFiber, newChild, lanes) : null;
+          case REACT_PORTAL_TYPE:
+            return newChild.key === key ? updatePortal(returnFiber, oldFiber, newChild, lanes) : null;
+          case REACT_LAZY_TYPE:
+            return key = newChild._init, newChild = key(newChild._payload), updateSlot(returnFiber, oldFiber, newChild, lanes);
+        }
+        if (isArrayImpl(newChild) || getIteratorFn(newChild)) return null !== key ? null : updateFragment(returnFiber, oldFiber, newChild, lanes, null);
+        if ("function" === typeof newChild.then) return updateSlot(returnFiber, oldFiber, unwrapThenable(newChild), lanes);
+        if (newChild.$$typeof === REACT_CONTEXT_TYPE) return updateSlot(returnFiber, oldFiber, readContextDuringReconciliation(returnFiber, newChild), lanes);
+        throwOnInvalidObjectType(returnFiber, newChild);
+      }
+      return null;
+    }
+    function updateFromMap(existingChildren, returnFiber, newIdx, newChild, lanes) {
+      if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild) return existingChildren = existingChildren.get(newIdx) || null, updateTextNode(returnFiber, existingChildren, "" + newChild, lanes);
+      if ("object" === typeof newChild && null !== newChild) {
+        switch (newChild.$$typeof) {
+          case REACT_ELEMENT_TYPE:
+            return existingChildren = existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, updateElement(returnFiber, existingChildren, newChild, lanes);
+          case REACT_PORTAL_TYPE:
+            return existingChildren = existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, updatePortal(returnFiber, existingChildren, newChild, lanes);
+          case REACT_LAZY_TYPE:
+            var init = newChild._init;
+            newChild = init(newChild._payload);
+            return updateFromMap(existingChildren, returnFiber, newIdx, newChild, lanes);
+        }
+        if (isArrayImpl(newChild) || getIteratorFn(newChild)) return existingChildren = existingChildren.get(newIdx) || null, updateFragment(returnFiber, existingChildren, newChild, lanes, null);
+        if ("function" === typeof newChild.then) return updateFromMap(existingChildren, returnFiber, newIdx, unwrapThenable(newChild), lanes);
+        if (newChild.$$typeof === REACT_CONTEXT_TYPE) return updateFromMap(existingChildren, returnFiber, newIdx, readContextDuringReconciliation(returnFiber, newChild), lanes);
+        throwOnInvalidObjectType(returnFiber, newChild);
+      }
+      return null;
+    }
+    function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, lanes) {
+      for (var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null; null !== oldFiber && newIdx < newChildren.length; newIdx++) {
+        oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
+        var newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], lanes);
+        if (null === newFiber) {
+          null === oldFiber && (oldFiber = nextOldFiber);
+          break;
+        }
+        shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
+        currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
+        null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber;
+        previousNewFiber = newFiber;
+        oldFiber = nextOldFiber;
+      }
+      if (newIdx === newChildren.length) return deleteRemainingChildren(returnFiber, oldFiber), resultingFirstChild;
+      if (null === oldFiber) {
+        for (; newIdx < newChildren.length; newIdx++) oldFiber = createChild(returnFiber, newChildren[newIdx], lanes), null !== oldFiber && (currentFirstChild = placeChild(oldFiber, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = oldFiber : previousNewFiber.sibling = oldFiber, previousNewFiber = oldFiber);
+        return resultingFirstChild;
+      }
+      for (oldFiber = mapRemainingChildren(oldFiber); newIdx < newChildren.length; newIdx++) nextOldFiber = updateFromMap(oldFiber, returnFiber, newIdx, newChildren[newIdx], lanes), null !== nextOldFiber && (shouldTrackSideEffects && null !== nextOldFiber.alternate && oldFiber.delete(null === nextOldFiber.key ? newIdx : nextOldFiber.key), currentFirstChild = placeChild(nextOldFiber, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = nextOldFiber : previousNewFiber.sibling = nextOldFiber, previousNewFiber = nextOldFiber);
+      shouldTrackSideEffects && oldFiber.forEach(function (child) {
+        return deleteChild(returnFiber, child);
+      });
+      return resultingFirstChild;
+    }
+    function reconcileChildrenIterator(returnFiber, currentFirstChild, newChildren, lanes) {
+      if (null == newChildren) throw Error("An iterable object provided no iterator.");
+      for (var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null, step = newChildren.next(); null !== oldFiber && !step.done; newIdx++, step = newChildren.next()) {
+        oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
+        var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
+        if (null === newFiber) {
+          null === oldFiber && (oldFiber = nextOldFiber);
+          break;
+        }
+        shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
+        currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
+        null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber;
+        previousNewFiber = newFiber;
+        oldFiber = nextOldFiber;
+      }
+      if (step.done) return deleteRemainingChildren(returnFiber, oldFiber), resultingFirstChild;
+      if (null === oldFiber) {
+        for (; !step.done; newIdx++, step = newChildren.next()) step = createChild(returnFiber, step.value, lanes), null !== step && (currentFirstChild = placeChild(step, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = step : previousNewFiber.sibling = step, previousNewFiber = step);
+        return resultingFirstChild;
+      }
+      for (oldFiber = mapRemainingChildren(oldFiber); !step.done; newIdx++, step = newChildren.next()) step = updateFromMap(oldFiber, returnFiber, newIdx, step.value, lanes), null !== step && (shouldTrackSideEffects && null !== step.alternate && oldFiber.delete(null === step.key ? newIdx : step.key), currentFirstChild = placeChild(step, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = step : previousNewFiber.sibling = step, previousNewFiber = step);
+      shouldTrackSideEffects && oldFiber.forEach(function (child) {
+        return deleteChild(returnFiber, child);
+      });
+      return resultingFirstChild;
+    }
+    function reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes) {
+      "object" === typeof newChild && null !== newChild && newChild.type === REACT_FRAGMENT_TYPE && null === newChild.key && (newChild = newChild.props.children);
+      if ("object" === typeof newChild && null !== newChild) {
+        switch (newChild.$$typeof) {
+          case REACT_ELEMENT_TYPE:
+            a: {
+              for (var key = newChild.key; null !== currentFirstChild;) {
+                if (currentFirstChild.key === key) {
+                  key = newChild.type;
+                  if (key === REACT_FRAGMENT_TYPE) {
+                    if (7 === currentFirstChild.tag) {
+                      deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+                      lanes = useFiber(currentFirstChild, newChild.props.children);
+                      lanes.return = returnFiber;
+                      returnFiber = lanes;
+                      break a;
+                    }
+                  } else if (currentFirstChild.elementType === key || "object" === typeof key && null !== key && key.$$typeof === REACT_LAZY_TYPE && resolveLazy(key) === currentFirstChild.type) {
+                    deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+                    lanes = useFiber(currentFirstChild, newChild.props);
+                    coerceRef(lanes, newChild);
+                    lanes.return = returnFiber;
+                    returnFiber = lanes;
+                    break a;
+                  }
+                  deleteRemainingChildren(returnFiber, currentFirstChild);
+                  break;
+                } else deleteChild(returnFiber, currentFirstChild);
+                currentFirstChild = currentFirstChild.sibling;
+              }
+              newChild.type === REACT_FRAGMENT_TYPE ? (lanes = createFiberFromFragment(newChild.props.children, returnFiber.mode, lanes, newChild.key), lanes.return = returnFiber, returnFiber = lanes) : (lanes = createFiberFromTypeAndProps(newChild.type, newChild.key, newChild.props, null, returnFiber.mode, lanes), coerceRef(lanes, newChild), lanes.return = returnFiber, returnFiber = lanes);
+            }
+            return placeSingleChild(returnFiber);
+          case REACT_PORTAL_TYPE:
+            a: {
+              for (key = newChild.key; null !== currentFirstChild;) {
+                if (currentFirstChild.key === key) {
+                  if (4 === currentFirstChild.tag && currentFirstChild.stateNode.containerInfo === newChild.containerInfo && currentFirstChild.stateNode.implementation === newChild.implementation) {
+                    deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+                    lanes = useFiber(currentFirstChild, newChild.children || []);
+                    lanes.return = returnFiber;
+                    returnFiber = lanes;
+                    break a;
+                  } else {
+                    deleteRemainingChildren(returnFiber, currentFirstChild);
+                    break;
+                  }
+                } else deleteChild(returnFiber, currentFirstChild);
+                currentFirstChild = currentFirstChild.sibling;
+              }
+              lanes = createFiberFromPortal(newChild, returnFiber.mode, lanes);
+              lanes.return = returnFiber;
+              returnFiber = lanes;
+            }
+            return placeSingleChild(returnFiber);
+          case REACT_LAZY_TYPE:
+            return key = newChild._init, newChild = key(newChild._payload), reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes);
+        }
+        if (isArrayImpl(newChild)) return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, lanes);
+        if (getIteratorFn(newChild)) {
+          key = getIteratorFn(newChild);
+          if ("function" !== typeof key) throw Error("An object is not an iterable. This error is likely caused by a bug in React. Please file an issue.");
+          newChild = key.call(newChild);
+          return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, lanes);
+        }
+        if ("function" === typeof newChild.then) return reconcileChildFibersImpl(returnFiber, currentFirstChild, unwrapThenable(newChild), lanes);
+        if (newChild.$$typeof === REACT_CONTEXT_TYPE) return reconcileChildFibersImpl(returnFiber, currentFirstChild, readContextDuringReconciliation(returnFiber, newChild), lanes);
+        throwOnInvalidObjectType(returnFiber, newChild);
+      }
+      return "string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild ? (newChild = "" + newChild, null !== currentFirstChild && 6 === currentFirstChild.tag ? (deleteRemainingChildren(returnFiber, currentFirstChild.sibling), lanes = useFiber(currentFirstChild, newChild), lanes.return = returnFiber, returnFiber = lanes) : (deleteRemainingChildren(returnFiber, currentFirstChild), lanes = createFiberFromText(newChild, returnFiber.mode, lanes), lanes.return = returnFiber, returnFiber = lanes), placeSingleChild(returnFiber)) : deleteRemainingChildren(returnFiber, currentFirstChild);
+    }
+    return function (returnFiber, currentFirstChild, newChild, lanes) {
+      try {
+        thenableIndexCounter = 0;
+        var firstChildFiber = reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes);
+        thenableState = null;
+        return firstChildFiber;
+      } catch (x) {
+        if (x === SuspenseException || x === SuspenseActionException || 0 === (returnFiber.mode & 1) && "object" === typeof x && null !== x && "function" === typeof x.then) throw x;
+        var fiber = createFiberImplClass(29, x, null, returnFiber.mode);
+        fiber.lanes = lanes;
+        fiber.return = returnFiber;
+        return fiber;
+      } finally {}
+    };
+  }
+  var reconcileChildFibers = createChildReconciler(!0),
+    mountChildFibers = createChildReconciler(!1),
+    suspenseHandlerStackCursor = createCursor(null),
+    shellBoundary = null;
+  function pushPrimaryTreeSuspenseHandler(handler) {
+    var current = handler.alternate;
+    push(suspenseStackCursor, suspenseStackCursor.current & 1);
+    push(suspenseHandlerStackCursor, handler);
+    null === shellBoundary && (null === current || null !== currentTreeHiddenStackCursor.current ? shellBoundary = handler : null !== current.memoizedState && (shellBoundary = handler));
+  }
+  function pushOffscreenSuspenseHandler(fiber) {
+    if (22 === fiber.tag) {
+      if (push(suspenseStackCursor, suspenseStackCursor.current), push(suspenseHandlerStackCursor, fiber), null === shellBoundary) {
+        var current = fiber.alternate;
+        null !== current && null !== current.memoizedState && (shellBoundary = fiber);
+      }
+    } else reuseSuspenseHandlerOnStack(fiber);
+  }
+  function reuseSuspenseHandlerOnStack() {
+    push(suspenseStackCursor, suspenseStackCursor.current);
+    push(suspenseHandlerStackCursor, suspenseHandlerStackCursor.current);
+  }
+  function popSuspenseHandler(fiber) {
+    pop(suspenseHandlerStackCursor);
+    shellBoundary === fiber && (shellBoundary = null);
+    pop(suspenseStackCursor);
+  }
+  var suspenseStackCursor = createCursor(0);
+  function findFirstSuspended(row) {
+    for (var node = row; null !== node;) {
+      if (13 === node.tag) {
+        var state = node.memoizedState;
+        if (null !== state && (null === state.dehydrated || shim$1() || shim$1())) return node;
+      } else if (19 === node.tag && void 0 !== node.memoizedProps.revealOrder) {
+        if (0 !== (node.flags & 128)) return node;
+      } else if (null !== node.child) {
+        node.child.return = node;
+        node = node.child;
+        continue;
+      }
+      if (node === row) break;
+      for (; null === node.sibling;) {
+        if (null === node.return || node.return === row) return null;
+        node = node.return;
+      }
+      node.sibling.return = node.return;
+      node = node.sibling;
+    }
+    return null;
+  }
+  function applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, nextProps) {
+    ctor = workInProgress.memoizedState;
+    getDerivedStateFromProps = getDerivedStateFromProps(nextProps, ctor);
+    getDerivedStateFromProps = null === getDerivedStateFromProps || void 0 === getDerivedStateFromProps ? ctor : assign({}, ctor, getDerivedStateFromProps);
+    workInProgress.memoizedState = getDerivedStateFromProps;
+    0 === workInProgress.lanes && (workInProgress.updateQueue.baseState = getDerivedStateFromProps);
+  }
+  var classComponentUpdater = {
+    enqueueSetState: function enqueueSetState(inst, payload, callback) {
+      inst = inst._reactInternals;
+      var lane = requestUpdateLane(inst),
+        update = createUpdate(lane);
+      update.payload = payload;
+      void 0 !== callback && null !== callback && (update.callback = callback);
+      payload = enqueueUpdate(inst, update, lane);
+      null !== payload && (scheduleUpdateOnFiber(payload, inst, lane), entangleTransitions(payload, inst, lane));
+    },
+    enqueueReplaceState: function enqueueReplaceState(inst, payload, callback) {
+      inst = inst._reactInternals;
+      var lane = requestUpdateLane(inst),
+        update = createUpdate(lane);
+      update.tag = 1;
+      update.payload = payload;
+      void 0 !== callback && null !== callback && (update.callback = callback);
+      payload = enqueueUpdate(inst, update, lane);
+      null !== payload && (scheduleUpdateOnFiber(payload, inst, lane), entangleTransitions(payload, inst, lane));
+    },
+    enqueueForceUpdate: function enqueueForceUpdate(inst, callback) {
+      inst = inst._reactInternals;
+      var lane = requestUpdateLane(inst),
+        update = createUpdate(lane);
+      update.tag = 2;
+      void 0 !== callback && null !== callback && (update.callback = callback);
+      callback = enqueueUpdate(inst, update, lane);
+      null !== callback && (scheduleUpdateOnFiber(callback, inst, lane), entangleTransitions(callback, inst, lane));
+    }
+  };
+  function checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) {
+    workInProgress = workInProgress.stateNode;
+    return "function" === typeof workInProgress.shouldComponentUpdate ? workInProgress.shouldComponentUpdate(newProps, newState, nextContext) : ctor.prototype && ctor.prototype.isPureReactComponent ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState) : !0;
+  }
+  function constructClassInstance(workInProgress, ctor, props) {
+    var context = emptyContextObject,
+      contextType = ctor.contextType;
+    "object" === typeof contextType && null !== contextType && (context = readContext(contextType));
+    ctor = new ctor(props, context);
+    workInProgress.memoizedState = null !== ctor.state && void 0 !== ctor.state ? ctor.state : null;
+    ctor.updater = classComponentUpdater;
+    workInProgress.stateNode = ctor;
+    ctor._reactInternals = workInProgress;
+    return ctor;
+  }
+  function callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext) {
+    workInProgress = instance.state;
+    "function" === typeof instance.componentWillReceiveProps && instance.componentWillReceiveProps(newProps, nextContext);
+    "function" === typeof instance.UNSAFE_componentWillReceiveProps && instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+    instance.state !== workInProgress && classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+  }
+  function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
+    var instance = workInProgress.stateNode;
+    instance.props = newProps;
+    instance.state = workInProgress.memoizedState;
+    instance.refs = {};
+    initializeUpdateQueue(workInProgress);
+    var contextType = ctor.contextType;
+    instance.context = "object" === typeof contextType && null !== contextType ? readContext(contextType) : emptyContextObject;
+    instance.state = workInProgress.memoizedState;
+    contextType = ctor.getDerivedStateFromProps;
+    "function" === typeof contextType && (applyDerivedStateFromProps(workInProgress, ctor, contextType, newProps), instance.state = workInProgress.memoizedState);
+    "function" === typeof ctor.getDerivedStateFromProps || "function" === typeof instance.getSnapshotBeforeUpdate || "function" !== typeof instance.UNSAFE_componentWillMount && "function" !== typeof instance.componentWillMount || (ctor = instance.state, "function" === typeof instance.componentWillMount && instance.componentWillMount(), "function" === typeof instance.UNSAFE_componentWillMount && instance.UNSAFE_componentWillMount(), ctor !== instance.state && classComponentUpdater.enqueueReplaceState(instance, instance.state, null), processUpdateQueue(workInProgress, newProps, instance, renderLanes), suspendIfUpdateReadFromEntangledAsyncAction(), instance.state = workInProgress.memoizedState);
+    "function" === typeof instance.componentDidMount && (workInProgress.flags |= 4194308);
+  }
+  function resolveClassComponentProps(Component, baseProps) {
+    var newProps = baseProps;
+    if ("ref" in baseProps) {
+      newProps = {};
+      for (var propName in baseProps) "ref" !== propName && (newProps[propName] = baseProps[propName]);
+    }
+    if (Component = Component.defaultProps) {
+      newProps === baseProps && (newProps = assign({}, newProps));
+      for (var propName$55 in Component) void 0 === newProps[propName$55] && (newProps[propName$55] = Component[propName$55]);
+    }
+    return newProps;
+  }
+  var reportGlobalError = "function" === typeof reportError ? reportError : function (error) {
+    if ("object" === typeof window && "function" === typeof window.ErrorEvent) {
+      var event = new window.ErrorEvent("error", {
+        bubbles: !0,
+        cancelable: !0,
+        message: "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error),
+        error: error
+      });
+      if (!window.dispatchEvent(event)) return;
+    } else if ("object" === typeof process && "function" === typeof process.emit) {
+      process.emit("uncaughtException", error);
+      return;
+    }
+    console.error(error);
+  };
+  function defaultOnRecoverableError(error) {
+    reportGlobalError(error);
+  }
+  function logUncaughtError(root, errorInfo) {
+    try {
+      var onUncaughtError = root.onUncaughtError;
+      onUncaughtError(errorInfo.value, {
+        componentStack: errorInfo.stack
+      });
+    } catch (e) {
+      setTimeout(function () {
+        throw e;
+      });
+    }
+  }
+  function logCaughtError(root, boundary, errorInfo) {
+    try {
+      var onCaughtError = root.onCaughtError;
+      onCaughtError(errorInfo.value, {
+        componentStack: errorInfo.stack,
+        errorBoundary: 1 === boundary.tag ? boundary.stateNode : null
+      });
+    } catch (e) {
+      setTimeout(function () {
+        throw e;
+      });
+    }
+  }
+  function createRootErrorUpdate(root, errorInfo, lane) {
+    lane = createUpdate(lane);
+    lane.tag = 3;
+    lane.payload = {
+      element: null
+    };
+    lane.callback = function () {
+      logUncaughtError(root, errorInfo);
+    };
+    return lane;
+  }
+  function createClassErrorUpdate(lane) {
+    lane = createUpdate(lane);
+    lane.tag = 3;
+    return lane;
+  }
+  function initializeClassErrorUpdate(update, root, fiber, errorInfo) {
+    var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+    if ("function" === typeof getDerivedStateFromError) {
+      var error = errorInfo.value;
+      update.payload = function () {
+        return getDerivedStateFromError(error);
+      };
+      update.callback = function () {
+        logCaughtError(root, fiber, errorInfo);
+      };
+    }
+    var inst = fiber.stateNode;
+    null !== inst && "function" === typeof inst.componentDidCatch && (update.callback = function () {
+      logCaughtError(root, fiber, errorInfo);
+      "function" !== typeof getDerivedStateFromError && (null === legacyErrorBoundariesThatAlreadyFailed ? legacyErrorBoundariesThatAlreadyFailed = new Set([this]) : legacyErrorBoundariesThatAlreadyFailed.add(this));
+      var stack = errorInfo.stack;
+      this.componentDidCatch(errorInfo.value, {
+        componentStack: null !== stack ? stack : ""
+      });
+    });
+  }
+  function throwException(root, returnFiber, sourceFiber, value, rootRenderLanes) {
+    sourceFiber.flags |= 32768;
+    if (null !== value && "object" === typeof value && "function" === typeof value.then) {
+      var currentSourceFiber = sourceFiber.alternate;
+      null !== currentSourceFiber && propagateParentContextChanges(currentSourceFiber, sourceFiber, rootRenderLanes, !0);
+      currentSourceFiber = sourceFiber.tag;
+      0 !== (sourceFiber.mode & 1) || 0 !== currentSourceFiber && 11 !== currentSourceFiber && 15 !== currentSourceFiber || ((currentSourceFiber = sourceFiber.alternate) ? (sourceFiber.updateQueue = currentSourceFiber.updateQueue, sourceFiber.memoizedState = currentSourceFiber.memoizedState, sourceFiber.lanes = currentSourceFiber.lanes) : (sourceFiber.updateQueue = null, sourceFiber.memoizedState = null));
+      currentSourceFiber = suspenseHandlerStackCursor.current;
+      if (null !== currentSourceFiber) {
+        switch (currentSourceFiber.tag) {
+          case 13:
+            return sourceFiber.mode & 1 && (null === shellBoundary ? renderDidSuspendDelayIfPossible() : null === currentSourceFiber.alternate && 0 === workInProgressRootExitStatus && (workInProgressRootExitStatus = 3)), currentSourceFiber.flags &= -257, 0 === (currentSourceFiber.mode & 1) ? currentSourceFiber === returnFiber ? currentSourceFiber.flags |= 65536 : (currentSourceFiber.flags |= 128, sourceFiber.flags |= 131072, sourceFiber.flags &= -52805, 1 === sourceFiber.tag ? null === sourceFiber.alternate ? sourceFiber.tag = 17 : (returnFiber = createUpdate(2), returnFiber.tag = 2, enqueueUpdate(sourceFiber, returnFiber, 2)) : 0 === sourceFiber.tag && null === sourceFiber.alternate && (sourceFiber.tag = 28), sourceFiber.lanes |= 2) : (currentSourceFiber.flags |= 65536, currentSourceFiber.lanes = rootRenderLanes), value === noopSuspenseyCommitThenable ? currentSourceFiber.flags |= 16384 : (returnFiber = currentSourceFiber.updateQueue, null === returnFiber ? currentSourceFiber.updateQueue = new Set([value]) : returnFiber.add(value), currentSourceFiber.mode & 1 && attachPingListener(root, value, rootRenderLanes)), !1;
+          case 22:
+            if (currentSourceFiber.mode & 1) return currentSourceFiber.flags |= 65536, value === noopSuspenseyCommitThenable ? currentSourceFiber.flags |= 16384 : (returnFiber = currentSourceFiber.updateQueue, null === returnFiber ? (returnFiber = {
+              transitions: null,
+              markerInstances: null,
+              retryQueue: new Set([value])
+            }, currentSourceFiber.updateQueue = returnFiber) : (sourceFiber = returnFiber.retryQueue, null === sourceFiber ? returnFiber.retryQueue = new Set([value]) : sourceFiber.add(value)), attachPingListener(root, value, rootRenderLanes)), !1;
+        }
+        throw Error("Unexpected Suspense handler tag (" + currentSourceFiber.tag + "). This is a bug in React.");
+      }
+      if (1 === root.tag) return attachPingListener(root, value, rootRenderLanes), renderDidSuspendDelayIfPossible(), !1;
+      value = 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.");
+    }
+    currentSourceFiber = createCapturedValueAtFiber(Error("There was an error during concurrent rendering but React was able to recover by instead synchronously rendering the entire root.", {
+      cause: value
+    }), sourceFiber);
+    null === workInProgressRootConcurrentErrors ? workInProgressRootConcurrentErrors = [currentSourceFiber] : workInProgressRootConcurrentErrors.push(currentSourceFiber);
+    4 !== workInProgressRootExitStatus && (workInProgressRootExitStatus = 2);
+    if (null === returnFiber) return !0;
+    value = createCapturedValueAtFiber(value, sourceFiber);
+    do {
+      switch (returnFiber.tag) {
+        case 3:
+          return returnFiber.flags |= 65536, root = rootRenderLanes & -rootRenderLanes, returnFiber.lanes |= root, root = createRootErrorUpdate(returnFiber.stateNode, value, root), enqueueCapturedUpdate(returnFiber, root), !1;
+        case 1:
+          if (sourceFiber = returnFiber.type, currentSourceFiber = returnFiber.stateNode, 0 === (returnFiber.flags & 128) && ("function" === typeof sourceFiber.getDerivedStateFromError || null !== currentSourceFiber && "function" === typeof currentSourceFiber.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(currentSourceFiber)))) return returnFiber.flags |= 65536, rootRenderLanes &= -rootRenderLanes, returnFiber.lanes |= rootRenderLanes, rootRenderLanes = createClassErrorUpdate(rootRenderLanes), initializeClassErrorUpdate(rootRenderLanes, root, returnFiber, value), enqueueCapturedUpdate(returnFiber, rootRenderLanes), !1;
+      }
+      returnFiber = returnFiber.return;
+    } while (null !== returnFiber);
+    return !1;
+  }
+  var SelectiveHydrationException = Error("This is not a real error. It's an implementation detail of React's selective hydration feature. If this leaks into userspace, it's a bug in React. Please file an issue."),
+    didReceiveUpdate = !1;
+  function reconcileChildren(current, workInProgress, nextChildren, renderLanes) {
+    workInProgress.child = null === current ? mountChildFibers(workInProgress, null, nextChildren, renderLanes) : reconcileChildFibers(workInProgress, current.child, nextChildren, renderLanes);
+  }
+  function updateForwardRef(current, workInProgress, Component, nextProps, renderLanes) {
+    Component = Component.render;
+    var ref = workInProgress.ref;
+    if ("ref" in nextProps) {
+      var propsWithoutRef = {};
+      for (var key in nextProps) "ref" !== key && (propsWithoutRef[key] = nextProps[key]);
+    } else propsWithoutRef = nextProps;
+    prepareToReadContext(workInProgress);
+    nextProps = renderWithHooks(current, workInProgress, Component, propsWithoutRef, ref, renderLanes);
+    if (null !== current && !didReceiveUpdate) return bailoutHooks(current, workInProgress, renderLanes), bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    workInProgress.flags |= 1;
+    reconcileChildren(current, workInProgress, nextProps, renderLanes);
+    return workInProgress.child;
+  }
+  function updateMemoComponent(current, workInProgress, Component, nextProps, renderLanes) {
+    if (null === current) {
+      var type = Component.type;
+      if ("function" === typeof type && !shouldConstruct(type) && void 0 === type.defaultProps && null === Component.compare) return workInProgress.tag = 15, workInProgress.type = type, updateSimpleMemoComponent(current, workInProgress, type, nextProps, renderLanes);
+      current = createFiberFromTypeAndProps(Component.type, null, nextProps, workInProgress, workInProgress.mode, renderLanes);
+      current.ref = workInProgress.ref;
+      current.return = workInProgress;
+      return workInProgress.child = current;
+    }
+    type = current.child;
+    if (!checkScheduledUpdateOrContext(current, renderLanes)) {
+      var prevProps = type.memoizedProps;
+      Component = Component.compare;
+      Component = null !== Component ? Component : shallowEqual;
+      if (Component(prevProps, nextProps) && current.ref === workInProgress.ref) return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    }
+    workInProgress.flags |= 1;
+    current = createWorkInProgress(type, nextProps);
+    current.ref = workInProgress.ref;
+    current.return = workInProgress;
+    return workInProgress.child = current;
+  }
+  function updateSimpleMemoComponent(current, workInProgress, Component, nextProps, renderLanes) {
+    if (null !== current) {
+      var prevProps = current.memoizedProps;
+      if (shallowEqual(prevProps, nextProps) && current.ref === workInProgress.ref) if (didReceiveUpdate = !1, workInProgress.pendingProps = nextProps = prevProps, checkScheduledUpdateOrContext(current, renderLanes)) 0 !== (current.flags & 131072) && (didReceiveUpdate = !0);else return workInProgress.lanes = current.lanes, bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    }
+    return updateFunctionComponent(current, workInProgress, Component, nextProps, renderLanes);
+  }
+  function updateOffscreenComponent(current, workInProgress, renderLanes) {
+    var nextProps = workInProgress.pendingProps,
+      nextChildren = nextProps.children,
+      prevState = null !== current ? current.memoizedState : null;
+    if ("hidden" === nextProps.mode) {
+      if (0 !== (workInProgress.flags & 128)) {
+        nextProps = null !== prevState ? prevState.baseLanes | renderLanes : renderLanes;
+        if (null !== current) {
+          nextChildren = workInProgress.child = current.child;
+          for (prevState = 0; null !== nextChildren;) prevState = prevState | nextChildren.lanes | nextChildren.childLanes, nextChildren = nextChildren.sibling;
+          workInProgress.childLanes = prevState & ~nextProps;
+        } else workInProgress.childLanes = 0, workInProgress.child = null;
+        return deferHiddenOffscreenComponent(current, workInProgress, nextProps, renderLanes);
+      }
+      if (0 === (workInProgress.mode & 1)) workInProgress.memoizedState = {
+        baseLanes: 0,
+        cachePool: null
+      }, null !== current && pushTransition(workInProgress, null), reuseHiddenContextOnStack(), pushOffscreenSuspenseHandler(workInProgress);else if (0 !== (renderLanes & 536870912)) workInProgress.memoizedState = {
+        baseLanes: 0,
+        cachePool: null
+      }, null !== current && pushTransition(workInProgress, null !== prevState ? prevState.cachePool : null), null !== prevState ? pushHiddenContext(workInProgress, prevState) : reuseHiddenContextOnStack(), pushOffscreenSuspenseHandler(workInProgress);else return workInProgress.lanes = workInProgress.childLanes = 536870912, deferHiddenOffscreenComponent(current, workInProgress, null !== prevState ? prevState.baseLanes | renderLanes : renderLanes, renderLanes);
+    } else null !== prevState ? (pushTransition(workInProgress, prevState.cachePool), pushHiddenContext(workInProgress, prevState), reuseSuspenseHandlerOnStack(workInProgress), workInProgress.memoizedState = null) : (null !== current && pushTransition(workInProgress, null), reuseHiddenContextOnStack(), reuseSuspenseHandlerOnStack(workInProgress));
+    reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+    return workInProgress.child;
+  }
+  function deferHiddenOffscreenComponent(current, workInProgress, nextBaseLanes, renderLanes) {
+    var JSCompiler_inline_result = peekCacheFromPool();
+    JSCompiler_inline_result = null === JSCompiler_inline_result ? null : {
+      parent: CacheContext._currentValue,
+      pool: JSCompiler_inline_result
+    };
+    workInProgress.memoizedState = {
+      baseLanes: nextBaseLanes,
+      cachePool: JSCompiler_inline_result
+    };
+    null !== current && pushTransition(workInProgress, null);
+    reuseHiddenContextOnStack();
+    pushOffscreenSuspenseHandler(workInProgress);
+    null !== current && propagateParentContextChanges(current, workInProgress, renderLanes, !0);
+    return null;
+  }
+  function markRef(current, workInProgress) {
+    var ref = workInProgress.ref;
+    if (null === ref) null !== current && null !== current.ref && (workInProgress.flags |= 4194816);else {
+      if ("function" !== typeof ref && "object" !== typeof ref) throw Error("Expected ref to be a function, an object returned by React.createRef(), or undefined/null.");
+      if (null === current || current.ref !== ref) workInProgress.flags |= 4194816;
+    }
+  }
+  function updateFunctionComponent(current, workInProgress, Component, nextProps, renderLanes) {
+    prepareToReadContext(workInProgress);
+    Component = renderWithHooks(current, workInProgress, Component, nextProps, void 0, renderLanes);
+    if (null !== current && !didReceiveUpdate) return bailoutHooks(current, workInProgress, renderLanes), bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    workInProgress.flags |= 1;
+    reconcileChildren(current, workInProgress, Component, renderLanes);
+    return workInProgress.child;
+  }
+  function replayFunctionComponent(current, workInProgress, nextProps, Component, secondArg, renderLanes) {
+    prepareToReadContext(workInProgress);
+    workInProgress.updateQueue = null;
+    nextProps = renderWithHooksAgain(workInProgress, Component, nextProps, secondArg);
+    finishRenderingHooks(current);
+    if (null !== current && !didReceiveUpdate) return bailoutHooks(current, workInProgress, renderLanes), bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    workInProgress.flags |= 1;
+    reconcileChildren(current, workInProgress, nextProps, renderLanes);
+    return workInProgress.child;
+  }
+  function updateClassComponent(current, workInProgress, Component, nextProps, renderLanes) {
+    prepareToReadContext(workInProgress);
+    if (null === workInProgress.stateNode) resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress), constructClassInstance(workInProgress, Component, nextProps), mountClassInstance(workInProgress, Component, nextProps, renderLanes), nextProps = !0;else if (null === current) {
+      var instance = workInProgress.stateNode,
+        unresolvedOldProps = workInProgress.memoizedProps,
+        oldProps = resolveClassComponentProps(Component, unresolvedOldProps);
+      instance.props = oldProps;
+      var oldContext = instance.context,
+        contextType = Component.contextType,
+        nextContext = emptyContextObject;
+      "object" === typeof contextType && null !== contextType && (nextContext = readContext(contextType));
+      var getDerivedStateFromProps = Component.getDerivedStateFromProps;
+      contextType = "function" === typeof getDerivedStateFromProps || "function" === typeof instance.getSnapshotBeforeUpdate;
+      unresolvedOldProps = workInProgress.pendingProps !== unresolvedOldProps;
+      contextType || "function" !== typeof instance.UNSAFE_componentWillReceiveProps && "function" !== typeof instance.componentWillReceiveProps || (unresolvedOldProps || oldContext !== nextContext) && callComponentWillReceiveProps(workInProgress, instance, nextProps, nextContext);
+      hasForceUpdate = !1;
+      var oldState = workInProgress.memoizedState;
+      instance.state = oldState;
+      processUpdateQueue(workInProgress, nextProps, instance, renderLanes);
+      suspendIfUpdateReadFromEntangledAsyncAction();
+      oldContext = workInProgress.memoizedState;
+      unresolvedOldProps || oldState !== oldContext || hasForceUpdate ? ("function" === typeof getDerivedStateFromProps && (applyDerivedStateFromProps(workInProgress, Component, getDerivedStateFromProps, nextProps), oldContext = workInProgress.memoizedState), (oldProps = hasForceUpdate || checkShouldComponentUpdate(workInProgress, Component, oldProps, nextProps, oldState, oldContext, nextContext)) ? (contextType || "function" !== typeof instance.UNSAFE_componentWillMount && "function" !== typeof instance.componentWillMount || ("function" === typeof instance.componentWillMount && instance.componentWillMount(), "function" === typeof instance.UNSAFE_componentWillMount && instance.UNSAFE_componentWillMount()), "function" === typeof instance.componentDidMount && (workInProgress.flags |= 4194308)) : ("function" === typeof instance.componentDidMount && (workInProgress.flags |= 4194308), workInProgress.memoizedProps = nextProps, workInProgress.memoizedState = oldContext), instance.props = nextProps, instance.state = oldContext, instance.context = nextContext, nextProps = oldProps) : ("function" === typeof instance.componentDidMount && (workInProgress.flags |= 4194308), nextProps = !1);
+    } else {
+      instance = workInProgress.stateNode;
+      cloneUpdateQueue(current, workInProgress);
+      nextContext = workInProgress.memoizedProps;
+      contextType = resolveClassComponentProps(Component, nextContext);
+      instance.props = contextType;
+      getDerivedStateFromProps = workInProgress.pendingProps;
+      oldState = instance.context;
+      oldContext = Component.contextType;
+      oldProps = emptyContextObject;
+      "object" === typeof oldContext && null !== oldContext && (oldProps = readContext(oldContext));
+      unresolvedOldProps = Component.getDerivedStateFromProps;
+      (oldContext = "function" === typeof unresolvedOldProps || "function" === typeof instance.getSnapshotBeforeUpdate) || "function" !== typeof instance.UNSAFE_componentWillReceiveProps && "function" !== typeof instance.componentWillReceiveProps || (nextContext !== getDerivedStateFromProps || oldState !== oldProps) && callComponentWillReceiveProps(workInProgress, instance, nextProps, oldProps);
+      hasForceUpdate = !1;
+      oldState = workInProgress.memoizedState;
+      instance.state = oldState;
+      processUpdateQueue(workInProgress, nextProps, instance, renderLanes);
+      suspendIfUpdateReadFromEntangledAsyncAction();
+      var newState = workInProgress.memoizedState;
+      nextContext !== getDerivedStateFromProps || oldState !== newState || hasForceUpdate || null !== current && null !== current.dependencies && checkIfContextChanged(current.dependencies) ? ("function" === typeof unresolvedOldProps && (applyDerivedStateFromProps(workInProgress, Component, unresolvedOldProps, nextProps), newState = workInProgress.memoizedState), (contextType = hasForceUpdate || checkShouldComponentUpdate(workInProgress, Component, contextType, nextProps, oldState, newState, oldProps) || null !== current && null !== current.dependencies && checkIfContextChanged(current.dependencies)) ? (oldContext || "function" !== typeof instance.UNSAFE_componentWillUpdate && "function" !== typeof instance.componentWillUpdate || ("function" === typeof instance.componentWillUpdate && instance.componentWillUpdate(nextProps, newState, oldProps), "function" === typeof instance.UNSAFE_componentWillUpdate && instance.UNSAFE_componentWillUpdate(nextProps, newState, oldProps)), "function" === typeof instance.componentDidUpdate && (workInProgress.flags |= 4), "function" === typeof instance.getSnapshotBeforeUpdate && (workInProgress.flags |= 1024)) : ("function" !== typeof instance.componentDidUpdate || nextContext === current.memoizedProps && oldState === current.memoizedState || (workInProgress.flags |= 4), "function" !== typeof instance.getSnapshotBeforeUpdate || nextContext === current.memoizedProps && oldState === current.memoizedState || (workInProgress.flags |= 1024), workInProgress.memoizedProps = nextProps, workInProgress.memoizedState = newState), instance.props = nextProps, instance.state = newState, instance.context = oldProps, nextProps = contextType) : ("function" !== typeof instance.componentDidUpdate || nextContext === current.memoizedProps && oldState === current.memoizedState || (workInProgress.flags |= 4), "function" !== typeof instance.getSnapshotBeforeUpdate || nextContext === current.memoizedProps && oldState === current.memoizedState || (workInProgress.flags |= 1024), nextProps = !1);
+    }
+    return finishClassComponent(current, workInProgress, Component, nextProps, !1, renderLanes);
+  }
+  function finishClassComponent(current, workInProgress, Component, shouldUpdate, hasContext, renderLanes) {
+    markRef(current, workInProgress);
+    hasContext = 0 !== (workInProgress.flags & 128);
+    if (!shouldUpdate && !hasContext) return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+    shouldUpdate = workInProgress.stateNode;
+    Component = hasContext && "function" !== typeof Component.getDerivedStateFromError ? null : shouldUpdate.render();
+    workInProgress.flags |= 1;
+    null !== current && hasContext ? (workInProgress.child = reconcileChildFibers(workInProgress, current.child, null, renderLanes), workInProgress.child = reconcileChildFibers(workInProgress, null, Component, renderLanes)) : reconcileChildren(current, workInProgress, Component, renderLanes);
+    workInProgress.memoizedState = shouldUpdate.state;
+    return workInProgress.child;
+  }
+  var SUSPENDED_MARKER = {
+    dehydrated: null,
+    treeContext: null,
+    retryLane: 0,
+    hydrationErrors: null
+  };
+  function mountSuspenseOffscreenState(renderLanes) {
+    return {
+      baseLanes: renderLanes,
+      cachePool: getSuspendedCache()
+    };
+  }
+  function getRemainingWorkInPrimaryTree(current, primaryTreeDidDefer, renderLanes) {
+    current = null !== current ? current.childLanes & ~renderLanes : 0;
+    primaryTreeDidDefer && (current |= workInProgressDeferredLane);
+    return current;
+  }
+  function updateSuspenseComponent(current, workInProgress, renderLanes) {
+    var nextProps = workInProgress.pendingProps,
+      showFallback = !1,
+      didSuspend = 0 !== (workInProgress.flags & 128),
+      JSCompiler_temp;
+    (JSCompiler_temp = didSuspend) || (JSCompiler_temp = null !== current && null === current.memoizedState ? !1 : 0 !== (suspenseStackCursor.current & 2));
+    JSCompiler_temp && (showFallback = !0, workInProgress.flags &= -129);
+    JSCompiler_temp = 0 !== (workInProgress.flags & 32);
+    workInProgress.flags &= -33;
+    if (null === current) {
+      var nextPrimaryChildren = nextProps.children;
+      nextProps = nextProps.fallback;
+      if (showFallback) return reuseSuspenseHandlerOnStack(workInProgress), showFallback = workInProgress.mode, didSuspend = workInProgress.child, nextPrimaryChildren = {
+        mode: "hidden",
+        children: nextPrimaryChildren
+      }, 0 === (showFallback & 1) && null !== didSuspend ? (didSuspend.childLanes = 0, didSuspend.pendingProps = nextPrimaryChildren) : didSuspend = mountWorkInProgressOffscreenFiber(nextPrimaryChildren, showFallback), nextProps = createFiberFromFragment(nextProps, showFallback, renderLanes, null), didSuspend.return = workInProgress, nextProps.return = workInProgress, didSuspend.sibling = nextProps, workInProgress.child = didSuspend, nextPrimaryChildren = workInProgress.child, nextPrimaryChildren.memoizedState = mountSuspenseOffscreenState(renderLanes), nextPrimaryChildren.childLanes = getRemainingWorkInPrimaryTree(current, JSCompiler_temp, renderLanes), workInProgress.memoizedState = SUSPENDED_MARKER, nextProps;
+      pushPrimaryTreeSuspenseHandler(workInProgress);
+      return mountSuspensePrimaryChildren(workInProgress, nextPrimaryChildren);
+    }
+    nextPrimaryChildren = current.memoizedState;
+    if (null !== nextPrimaryChildren && null !== nextPrimaryChildren.dehydrated) {
+      if (didSuspend) workInProgress.flags & 256 ? (pushPrimaryTreeSuspenseHandler(workInProgress), workInProgress.flags &= -257, workInProgress = retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes)) : null !== workInProgress.memoizedState ? (reuseSuspenseHandlerOnStack(workInProgress), workInProgress.child = current.child, workInProgress.flags |= 128, workInProgress = null) : (reuseSuspenseHandlerOnStack(workInProgress), nextPrimaryChildren = nextProps.fallback, showFallback = workInProgress.mode, nextProps = mountWorkInProgressOffscreenFiber({
+        mode: "visible",
+        children: nextProps.children
+      }, showFallback), nextPrimaryChildren = createFiberFromFragment(nextPrimaryChildren, showFallback, renderLanes, null), nextPrimaryChildren.flags |= 2, nextProps.return = workInProgress, nextPrimaryChildren.return = workInProgress, nextProps.sibling = nextPrimaryChildren, workInProgress.child = nextProps, 0 !== (workInProgress.mode & 1) && reconcileChildFibers(workInProgress, current.child, null, renderLanes), nextProps = workInProgress.child, nextProps.memoizedState = mountSuspenseOffscreenState(renderLanes), nextProps.childLanes = getRemainingWorkInPrimaryTree(current, JSCompiler_temp, renderLanes), workInProgress.memoizedState = SUSPENDED_MARKER, workInProgress = nextPrimaryChildren);else if (pushPrimaryTreeSuspenseHandler(workInProgress), shim$1()) JSCompiler_temp = shim$1().digest, nextProps = Error("The server could not finish this Suspense boundary, likely due to an error during server rendering. Switched to client rendering."), nextProps.stack = "", nextProps.digest = JSCompiler_temp, JSCompiler_temp = {
+        value: nextProps,
+        source: null,
+        stack: null
+      }, null === hydrationErrors ? hydrationErrors = [JSCompiler_temp] : hydrationErrors.push(JSCompiler_temp), workInProgress = retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes);else if (didReceiveUpdate || propagateParentContextChanges(current, workInProgress, renderLanes, !1), JSCompiler_temp = 0 !== (renderLanes & current.childLanes), didReceiveUpdate || JSCompiler_temp) {
+        JSCompiler_temp = workInProgressRoot;
+        if (null !== JSCompiler_temp) {
+          nextProps = renderLanes & -renderLanes;
+          if (0 !== (nextProps & 42)) nextProps = 1;else switch (nextProps) {
+            case 2:
+              nextProps = 1;
+              break;
+            case 8:
+              nextProps = 4;
+              break;
+            case 32:
+              nextProps = 16;
+              break;
+            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:
+              nextProps = 128;
+              break;
+            case 268435456:
+              nextProps = 134217728;
+              break;
+            default:
+              nextProps = 0;
+          }
+          nextProps = 0 !== (nextProps & (JSCompiler_temp.suspendedLanes | renderLanes)) ? 0 : nextProps;
+          if (0 !== nextProps && nextProps !== nextPrimaryChildren.retryLane) throw nextPrimaryChildren.retryLane = nextProps, enqueueConcurrentRenderForLane(current, nextProps), scheduleUpdateOnFiber(JSCompiler_temp, current, nextProps), SelectiveHydrationException;
+        }
+        shim$1() || renderDidSuspendDelayIfPossible();
+        workInProgress = retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes);
+      } else shim$1() ? (workInProgress.flags |= 192, workInProgress.child = current.child, workInProgress = null) : (workInProgress = mountSuspensePrimaryChildren(workInProgress, nextProps.children), workInProgress.flags |= 4096);
+      return workInProgress;
+    }
+    if (showFallback) {
+      reuseSuspenseHandlerOnStack(workInProgress);
+      nextPrimaryChildren = nextProps.fallback;
+      showFallback = workInProgress.mode;
+      didSuspend = current.child;
+      var currentFallbackChildFragment = didSuspend.sibling,
+        primaryChildProps = {
+          mode: "hidden",
+          children: nextProps.children
+        };
+      0 === (showFallback & 1) && workInProgress.child !== didSuspend ? (nextProps = workInProgress.child, nextProps.childLanes = 0, nextProps.pendingProps = primaryChildProps, workInProgress.deletions = null) : (nextProps = createWorkInProgress(didSuspend, primaryChildProps), nextProps.subtreeFlags = didSuspend.subtreeFlags & 65011712);
+      null !== currentFallbackChildFragment ? nextPrimaryChildren = createWorkInProgress(currentFallbackChildFragment, nextPrimaryChildren) : (nextPrimaryChildren = createFiberFromFragment(nextPrimaryChildren, showFallback, renderLanes, null), nextPrimaryChildren.flags |= 2);
+      nextPrimaryChildren.return = workInProgress;
+      nextProps.return = workInProgress;
+      nextProps.sibling = nextPrimaryChildren;
+      workInProgress.child = nextProps;
+      nextProps = nextPrimaryChildren;
+      nextPrimaryChildren = workInProgress.child;
+      showFallback = current.child.memoizedState;
+      null === showFallback ? showFallback = mountSuspenseOffscreenState(renderLanes) : (didSuspend = showFallback.cachePool, null !== didSuspend ? (currentFallbackChildFragment = CacheContext._currentValue, didSuspend = didSuspend.parent !== currentFallbackChildFragment ? {
+        parent: currentFallbackChildFragment,
+        pool: currentFallbackChildFragment
+      } : didSuspend) : didSuspend = getSuspendedCache(), showFallback = {
+        baseLanes: showFallback.baseLanes | renderLanes,
+        cachePool: didSuspend
+      });
+      nextPrimaryChildren.memoizedState = showFallback;
+      nextPrimaryChildren.childLanes = getRemainingWorkInPrimaryTree(current, JSCompiler_temp, renderLanes);
+      workInProgress.memoizedState = SUSPENDED_MARKER;
+      return nextProps;
+    }
+    pushPrimaryTreeSuspenseHandler(workInProgress);
+    JSCompiler_temp = current.child;
+    current = JSCompiler_temp.sibling;
+    JSCompiler_temp = createWorkInProgress(JSCompiler_temp, {
+      mode: "visible",
+      children: nextProps.children
+    });
+    0 === (workInProgress.mode & 1) && (JSCompiler_temp.lanes = renderLanes);
+    JSCompiler_temp.return = workInProgress;
+    JSCompiler_temp.sibling = null;
+    null !== current && (renderLanes = workInProgress.deletions, null === renderLanes ? (workInProgress.deletions = [current], workInProgress.flags |= 16) : renderLanes.push(current));
+    workInProgress.child = JSCompiler_temp;
+    workInProgress.memoizedState = null;
+    return JSCompiler_temp;
+  }
+  function mountSuspensePrimaryChildren(workInProgress, primaryChildren) {
+    primaryChildren = mountWorkInProgressOffscreenFiber({
+      mode: "visible",
+      children: primaryChildren
+    }, workInProgress.mode);
+    primaryChildren.return = workInProgress;
+    return workInProgress.child = primaryChildren;
+  }
+  function mountWorkInProgressOffscreenFiber(offscreenProps, mode) {
+    offscreenProps = createFiberImplClass(22, offscreenProps, null, mode);
+    offscreenProps.lanes = 0;
+    offscreenProps.stateNode = {
+      _visibility: 1,
+      _pendingMarkers: null,
+      _retryCache: null,
+      _transitions: null
+    };
+    return offscreenProps;
+  }
+  function retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes) {
+    reconcileChildFibers(workInProgress, current.child, null, renderLanes);
+    current = mountSuspensePrimaryChildren(workInProgress, workInProgress.pendingProps.children);
+    current.flags |= 2;
+    workInProgress.memoizedState = null;
+    return current;
+  }
+  function scheduleSuspenseWorkOnFiber(fiber, renderLanes, propagationRoot) {
+    fiber.lanes |= renderLanes;
+    var alternate = fiber.alternate;
+    null !== alternate && (alternate.lanes |= renderLanes);
+    scheduleContextWorkOnParentPath(fiber.return, renderLanes, propagationRoot);
+  }
+  function initSuspenseListRenderState(workInProgress, isBackwards, tail, lastContentRow, tailMode) {
+    var renderState = workInProgress.memoizedState;
+    null === renderState ? workInProgress.memoizedState = {
+      isBackwards: isBackwards,
+      rendering: null,
+      renderingStartTime: 0,
+      last: lastContentRow,
+      tail: tail,
+      tailMode: tailMode
+    } : (renderState.isBackwards = isBackwards, renderState.rendering = null, renderState.renderingStartTime = 0, renderState.last = lastContentRow, renderState.tail = tail, renderState.tailMode = tailMode);
+  }
+  function updateSuspenseListComponent(current, workInProgress, renderLanes) {
+    var nextProps = workInProgress.pendingProps,
+      revealOrder = nextProps.revealOrder,
+      tailMode = nextProps.tail;
+    reconcileChildren(current, workInProgress, nextProps.children, renderLanes);
+    nextProps = suspenseStackCursor.current;
+    if (0 !== (nextProps & 2)) nextProps = nextProps & 1 | 2, workInProgress.flags |= 128;else {
+      if (null !== current && 0 !== (current.flags & 128)) a: for (current = workInProgress.child; null !== current;) {
+        if (13 === current.tag) null !== current.memoizedState && scheduleSuspenseWorkOnFiber(current, renderLanes, workInProgress);else if (19 === current.tag) scheduleSuspenseWorkOnFiber(current, renderLanes, workInProgress);else if (null !== current.child) {
+          current.child.return = current;
+          current = current.child;
+          continue;
+        }
+        if (current === workInProgress) break a;
+        for (; null === current.sibling;) {
+          if (null === current.return || current.return === workInProgress) break a;
+          current = current.return;
+        }
+        current.sibling.return = current.return;
+        current = current.sibling;
+      }
+      nextProps &= 1;
+    }
+    push(suspenseStackCursor, nextProps);
+    if (0 === (workInProgress.mode & 1)) workInProgress.memoizedState = null;else switch (revealOrder) {
+      case "forwards":
+        renderLanes = workInProgress.child;
+        for (revealOrder = null; null !== renderLanes;) current = renderLanes.alternate, null !== current && null === findFirstSuspended(current) && (revealOrder = renderLanes), renderLanes = renderLanes.sibling;
+        renderLanes = revealOrder;
+        null === renderLanes ? (revealOrder = workInProgress.child, workInProgress.child = null) : (revealOrder = renderLanes.sibling, renderLanes.sibling = null);
+        initSuspenseListRenderState(workInProgress, !1, revealOrder, renderLanes, tailMode);
+        break;
+      case "backwards":
+        renderLanes = null;
+        revealOrder = workInProgress.child;
+        for (workInProgress.child = null; null !== revealOrder;) {
+          current = revealOrder.alternate;
+          if (null !== current && null === findFirstSuspended(current)) {
+            workInProgress.child = revealOrder;
+            break;
+          }
+          current = revealOrder.sibling;
+          revealOrder.sibling = renderLanes;
+          renderLanes = revealOrder;
+          revealOrder = current;
+        }
+        initSuspenseListRenderState(workInProgress, !0, renderLanes, null, tailMode);
+        break;
+      case "together":
+        initSuspenseListRenderState(workInProgress, !1, null, null, void 0);
+        break;
+      default:
+        workInProgress.memoizedState = null;
+    }
+    return workInProgress.child;
+  }
+  function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
+    0 === (workInProgress.mode & 1) && null !== current && (current.alternate = null, workInProgress.alternate = null, workInProgress.flags |= 2);
+  }
+  function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
+    null !== current && (workInProgress.dependencies = current.dependencies);
+    workInProgressRootSkippedLanes |= workInProgress.lanes;
+    if (0 === (renderLanes & workInProgress.childLanes)) if (null !== current) {
+      if (propagateParentContextChanges(current, workInProgress, renderLanes, !1), 0 === (renderLanes & workInProgress.childLanes)) return null;
+    } else return null;
+    if (null !== current && workInProgress.child !== current.child) throw Error("Resuming work not yet implemented.");
+    if (null !== workInProgress.child) {
+      current = workInProgress.child;
+      renderLanes = createWorkInProgress(current, current.pendingProps);
+      workInProgress.child = renderLanes;
+      for (renderLanes.return = workInProgress; null !== current.sibling;) current = current.sibling, renderLanes = renderLanes.sibling = createWorkInProgress(current, current.pendingProps), renderLanes.return = workInProgress;
+      renderLanes.sibling = null;
+    }
+    return workInProgress.child;
+  }
+  function checkScheduledUpdateOrContext(current, renderLanes) {
+    if (0 !== (current.lanes & renderLanes)) return !0;
+    current = current.dependencies;
+    return null !== current && checkIfContextChanged(current) ? !0 : !1;
+  }
+  function attemptEarlyBailoutIfNoScheduledUpdate(current, workInProgress, renderLanes) {
+    switch (workInProgress.tag) {
+      case 3:
+        pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+        pushProvider(workInProgress, CacheContext, current.memoizedState.cache);
+        break;
+      case 27:
+      case 5:
+        pushHostContext(workInProgress);
+        break;
+      case 4:
+        pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+        break;
+      case 10:
+        pushProvider(workInProgress, workInProgress.type, workInProgress.memoizedProps.value);
+        break;
+      case 13:
+        var state = workInProgress.memoizedState;
+        if (null !== state) {
+          if (null !== state.dehydrated) return pushPrimaryTreeSuspenseHandler(workInProgress), workInProgress.flags |= 128, null;
+          if (0 !== (renderLanes & workInProgress.child.childLanes)) return updateSuspenseComponent(current, workInProgress, renderLanes);
+          pushPrimaryTreeSuspenseHandler(workInProgress);
+          current = bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+          return null !== current ? current.sibling : null;
+        }
+        pushPrimaryTreeSuspenseHandler(workInProgress);
+        break;
+      case 19:
+        var didSuspendBefore = 0 !== (current.flags & 128);
+        state = 0 !== (renderLanes & workInProgress.childLanes);
+        state || (propagateParentContextChanges(current, workInProgress, renderLanes, !1), state = 0 !== (renderLanes & workInProgress.childLanes));
+        if (didSuspendBefore) {
+          if (state) return updateSuspenseListComponent(current, workInProgress, renderLanes);
+          workInProgress.flags |= 128;
+        }
+        didSuspendBefore = workInProgress.memoizedState;
+        null !== didSuspendBefore && (didSuspendBefore.rendering = null, didSuspendBefore.tail = null, didSuspendBefore.lastEffect = null);
+        push(suspenseStackCursor, suspenseStackCursor.current);
+        if (state) break;else return null;
+      case 22:
+      case 23:
+        return workInProgress.lanes = 0, updateOffscreenComponent(current, workInProgress, renderLanes);
+      case 24:
+        pushProvider(workInProgress, CacheContext, current.memoizedState.cache);
+    }
+    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
+  }
+  function beginWork(current, workInProgress, renderLanes) {
+    if (null !== current) {
+      if (current.memoizedProps !== workInProgress.pendingProps) didReceiveUpdate = !0;else {
+        if (!checkScheduledUpdateOrContext(current, renderLanes) && 0 === (workInProgress.flags & 128)) return didReceiveUpdate = !1, attemptEarlyBailoutIfNoScheduledUpdate(current, workInProgress, renderLanes);
+        didReceiveUpdate = 0 !== (current.flags & 131072) ? !0 : !1;
+      }
+    } else didReceiveUpdate = !1;
+    workInProgress.lanes = 0;
+    switch (workInProgress.tag) {
+      case 16:
+        var elementType = workInProgress.elementType;
+        a: {
+          resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress);
+          current = workInProgress.pendingProps;
+          var init = elementType._init;
+          elementType = init(elementType._payload);
+          workInProgress.type = elementType;
+          if ("function" === typeof elementType) shouldConstruct(elementType) ? (current = resolveClassComponentProps(elementType, current), workInProgress.tag = 1, workInProgress = updateClassComponent(null, workInProgress, elementType, current, renderLanes)) : (workInProgress.tag = 0, workInProgress = updateFunctionComponent(null, workInProgress, elementType, current, renderLanes));else {
+            if (void 0 !== elementType && null !== elementType) if (init = elementType.$$typeof, init === REACT_FORWARD_REF_TYPE) {
+              workInProgress.tag = 11;
+              workInProgress = updateForwardRef(null, workInProgress, elementType, current, renderLanes);
+              break a;
+            } else if (init === REACT_MEMO_TYPE) {
+              workInProgress.tag = 14;
+              workInProgress = updateMemoComponent(null, workInProgress, elementType, current, renderLanes);
+              break a;
+            }
+            workInProgress = getComponentNameFromType(elementType) || elementType;
+            throw Error("Element type is invalid. Received a promise that resolves to: " + workInProgress + ". Lazy element type must resolve to a class or function.");
+          }
+        }
+        return workInProgress;
+      case 0:
+        return updateFunctionComponent(current, workInProgress, workInProgress.type, workInProgress.pendingProps, renderLanes);
+      case 1:
+        return elementType = workInProgress.type, init = resolveClassComponentProps(elementType, workInProgress.pendingProps), updateClassComponent(current, workInProgress, elementType, init, renderLanes);
+      case 3:
+        pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+        if (null === current) throw Error("Should have a current fiber. This is a bug in React.");
+        var nextProps = workInProgress.pendingProps;
+        init = workInProgress.memoizedState;
+        elementType = init.element;
+        cloneUpdateQueue(current, workInProgress);
+        processUpdateQueue(workInProgress, nextProps, null, renderLanes);
+        nextProps = workInProgress.memoizedState;
+        var nextCache = nextProps.cache;
+        pushProvider(workInProgress, CacheContext, nextCache);
+        nextCache !== init.cache && propagateContextChanges(workInProgress, [CacheContext], renderLanes, !0);
+        suspendIfUpdateReadFromEntangledAsyncAction();
+        init = nextProps.element;
+        init === elementType ? workInProgress = bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) : (reconcileChildren(current, workInProgress, init, renderLanes), workInProgress = workInProgress.child);
+        return workInProgress;
+      case 26:
+      case 27:
+      case 5:
+        return pushHostContext(workInProgress), elementType = workInProgress.pendingProps.children, null !== workInProgress.memoizedState && (init = renderWithHooks(current, workInProgress, TransitionAwareHostComponent, null, null, renderLanes), HostTransitionContext._currentValue = init), markRef(current, workInProgress), reconcileChildren(current, workInProgress, elementType, renderLanes), workInProgress.child;
+      case 6:
+        return null;
+      case 13:
+        return updateSuspenseComponent(current, workInProgress, renderLanes);
+      case 4:
+        return pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo), elementType = workInProgress.pendingProps, null === current ? workInProgress.child = reconcileChildFibers(workInProgress, null, elementType, renderLanes) : reconcileChildren(current, workInProgress, elementType, renderLanes), workInProgress.child;
+      case 11:
+        return updateForwardRef(current, workInProgress, workInProgress.type, workInProgress.pendingProps, renderLanes);
+      case 7:
+        return reconcileChildren(current, workInProgress, workInProgress.pendingProps, renderLanes), workInProgress.child;
+      case 8:
+        return reconcileChildren(current, workInProgress, workInProgress.pendingProps.children, renderLanes), workInProgress.child;
+      case 12:
+        return reconcileChildren(current, workInProgress, workInProgress.pendingProps.children, renderLanes), workInProgress.child;
+      case 10:
+        return elementType = workInProgress.pendingProps, pushProvider(workInProgress, workInProgress.type, elementType.value), reconcileChildren(current, workInProgress, elementType.children, renderLanes), workInProgress.child;
+      case 9:
+        return init = workInProgress.type._context, elementType = workInProgress.pendingProps.children, prepareToReadContext(workInProgress), init = readContext(init), elementType = elementType(init), workInProgress.flags |= 1, reconcileChildren(current, workInProgress, elementType, renderLanes), workInProgress.child;
+      case 14:
+        return updateMemoComponent(current, workInProgress, workInProgress.type, workInProgress.pendingProps, renderLanes);
+      case 15:
+        return updateSimpleMemoComponent(current, workInProgress, workInProgress.type, workInProgress.pendingProps, renderLanes);
+      case 17:
+        return elementType = workInProgress.type, init = resolveClassComponentProps(elementType, workInProgress.pendingProps), resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress), workInProgress.tag = 1, prepareToReadContext(workInProgress), constructClassInstance(workInProgress, elementType, init), mountClassInstance(workInProgress, elementType, init, renderLanes), finishClassComponent(null, workInProgress, elementType, !0, !1, renderLanes);
+      case 28:
+        return elementType = workInProgress.type, init = resolveClassComponentProps(elementType, workInProgress.pendingProps), resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress), workInProgress.tag = 0, updateFunctionComponent(null, workInProgress, elementType, init, renderLanes);
+      case 19:
+        return updateSuspenseListComponent(current, workInProgress, renderLanes);
+      case 31:
+        return elementType = workInProgress.pendingProps, renderLanes = workInProgress.mode, elementType = {
+          mode: elementType.mode,
+          children: elementType.children
+        }, null === current ? (renderLanes = mountWorkInProgressOffscreenFiber(elementType, renderLanes), renderLanes.ref = workInProgress.ref, workInProgress.child = renderLanes, renderLanes.return = workInProgress, workInProgress = renderLanes) : (renderLanes = createWorkInProgress(current.child, elementType), renderLanes.ref = workInProgress.ref, workInProgress.child = renderLanes, renderLanes.return = workInProgress, workInProgress = renderLanes), workInProgress;
+      case 22:
+        return updateOffscreenComponent(current, workInProgress, renderLanes);
+      case 24:
+        return prepareToReadContext(workInProgress), elementType = readContext(CacheContext), null === current ? (init = peekCacheFromPool(), null === init && (init = workInProgressRoot, nextProps = createCache(), init.pooledCache = nextProps, nextProps.refCount++, null !== nextProps && (init.pooledCacheLanes |= renderLanes), init = nextProps), workInProgress.memoizedState = {
+          parent: elementType,
+          cache: init
+        }, initializeUpdateQueue(workInProgress), pushProvider(workInProgress, CacheContext, init)) : (0 !== (current.lanes & renderLanes) && (cloneUpdateQueue(current, workInProgress), processUpdateQueue(workInProgress, null, null, renderLanes), suspendIfUpdateReadFromEntangledAsyncAction()), init = current.memoizedState, nextProps = workInProgress.memoizedState, init.parent !== elementType ? (init = {
+          parent: elementType,
+          cache: elementType
+        }, workInProgress.memoizedState = init, 0 === workInProgress.lanes && (workInProgress.memoizedState = workInProgress.updateQueue.baseState = init), pushProvider(workInProgress, CacheContext, elementType)) : (elementType = nextProps.cache, pushProvider(workInProgress, CacheContext, elementType), elementType !== init.cache && propagateContextChanges(workInProgress, [CacheContext], renderLanes, !0))), reconcileChildren(current, workInProgress, workInProgress.pendingProps.children, renderLanes), workInProgress.child;
+      case 29:
+        throw workInProgress.pendingProps;
+    }
+    throw Error("Unknown unit of work tag (" + workInProgress.tag + "). This error is likely caused by a bug in React. Please file an issue.");
+  }
+  function scheduleRetryEffect(workInProgress, retryQueue) {
+    null !== retryQueue && (workInProgress.flags |= 4);
+    workInProgress.flags & 16384 && (retryQueue = 22 !== workInProgress.tag ? claimNextRetryLane() : 536870912, workInProgress.lanes |= retryQueue, workInProgressSuspendedRetryLanes |= retryQueue);
+  }
+  function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
+    switch (renderState.tailMode) {
+      case "hidden":
+        hasRenderedATailFallback = renderState.tail;
+        for (var lastTailNode = null; null !== hasRenderedATailFallback;) null !== hasRenderedATailFallback.alternate && (lastTailNode = hasRenderedATailFallback), hasRenderedATailFallback = hasRenderedATailFallback.sibling;
+        null === lastTailNode ? renderState.tail = null : lastTailNode.sibling = null;
+        break;
+      case "collapsed":
+        lastTailNode = renderState.tail;
+        for (var lastTailNode$93 = null; null !== lastTailNode;) null !== lastTailNode.alternate && (lastTailNode$93 = lastTailNode), lastTailNode = lastTailNode.sibling;
+        null === lastTailNode$93 ? hasRenderedATailFallback || null === renderState.tail ? renderState.tail = null : renderState.tail.sibling = null : lastTailNode$93.sibling = null;
+    }
+  }
+  function bubbleProperties(completedWork) {
+    var didBailout = null !== completedWork.alternate && completedWork.alternate.child === completedWork.child,
+      newChildLanes = 0,
+      subtreeFlags = 0;
+    if (didBailout) for (var child$94 = completedWork.child; null !== child$94;) newChildLanes |= child$94.lanes | child$94.childLanes, subtreeFlags |= child$94.subtreeFlags & 65011712, subtreeFlags |= child$94.flags & 65011712, child$94.return = completedWork, child$94 = child$94.sibling;else for (child$94 = completedWork.child; null !== child$94;) newChildLanes |= child$94.lanes | child$94.childLanes, subtreeFlags |= child$94.subtreeFlags, subtreeFlags |= child$94.flags, child$94.return = completedWork, child$94 = child$94.sibling;
+    completedWork.subtreeFlags |= subtreeFlags;
+    completedWork.childLanes = newChildLanes;
+    return didBailout;
+  }
+  function completeWork(current, workInProgress, renderLanes) {
+    var newProps = workInProgress.pendingProps;
+    switch (workInProgress.tag) {
+      case 28:
+      case 31:
+      case 16:
+      case 15:
+      case 0:
+      case 11:
+      case 7:
+      case 8:
+      case 12:
+      case 9:
+      case 14:
+        return bubbleProperties(workInProgress), null;
+      case 1:
+        return bubbleProperties(workInProgress), null;
+      case 3:
+        return renderLanes = workInProgress.stateNode, newProps = null, null !== current && (newProps = current.memoizedState.cache), workInProgress.memoizedState.cache !== newProps && (workInProgress.flags |= 2048), popProvider(CacheContext), popHostContainer(), renderLanes.pendingContext && (renderLanes.context = renderLanes.pendingContext, renderLanes.pendingContext = null), null !== current && null !== current.child || null === current || current.memoizedState.isDehydrated && 0 === (workInProgress.flags & 256) || (workInProgress.flags |= 1024, upgradeHydrationErrorsToRecoverable()), bubbleProperties(workInProgress), null;
+      case 26:
+      case 27:
+      case 5:
+        popHostContext(workInProgress);
+        var type = workInProgress.type;
+        if (null !== current && null != workInProgress.stateNode) current.memoizedProps !== newProps && (workInProgress.flags |= 4);else {
+          if (!newProps) {
+            if (null === workInProgress.stateNode) throw Error("We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue.");
+            bubbleProperties(workInProgress);
+            return null;
+          }
+          renderLanes = rootInstanceStackCursor.current;
+          current = allocateTag();
+          type = getViewConfigForType(type);
+          var updatePayload = diffProperties(null, emptyObject, newProps, type.validAttributes);
+          _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").UIManager.createView(current, type.uiViewClassName, renderLanes.containerTag, updatePayload);
+          renderLanes = new ReactNativeFiberHostComponent(current, type, workInProgress);
+          instanceCache.set(current, workInProgress);
+          instanceProps.set(current, newProps);
+          a: for (current = workInProgress.child; null !== current;) {
+            if (5 === current.tag || 6 === current.tag) renderLanes._children.push(current.stateNode);else if (4 !== current.tag && null !== current.child) {
+              current.child.return = current;
+              current = current.child;
+              continue;
+            }
+            if (current === workInProgress) break a;
+            for (; null === current.sibling;) {
+              if (null === current.return || current.return === workInProgress) break a;
+              current = current.return;
+            }
+            current.sibling.return = current.return;
+            current = current.sibling;
+          }
+          workInProgress.stateNode = renderLanes;
+          finalizeInitialChildren(renderLanes) && (workInProgress.flags |= 4);
+        }
+        bubbleProperties(workInProgress);
+        workInProgress.flags &= -16777217;
+        return null;
+      case 6:
+        if (current && null != workInProgress.stateNode) current.memoizedProps !== newProps && (workInProgress.flags |= 4);else {
+          if ("string" !== typeof newProps && null === workInProgress.stateNode) throw Error("We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue.");
+          current = rootInstanceStackCursor.current;
+          if (!contextStackCursor.current.isInAParentText) throw Error("Text strings must be rendered within a <Text> component.");
+          renderLanes = allocateTag();
+          _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").UIManager.createView(renderLanes, "RCTRawText", current.containerTag, {
+            text: newProps
+          });
+          instanceCache.set(renderLanes, workInProgress);
+          workInProgress.stateNode = renderLanes;
+        }
+        bubbleProperties(workInProgress);
+        return null;
+      case 13:
+        newProps = workInProgress.memoizedState;
+        if (null === current || null !== current.memoizedState && null !== current.memoizedState.dehydrated) {
+          if (null !== newProps && null !== newProps.dehydrated) {
+            if (null === current) {
+              throw Error("A dehydrated suspense component was completed without a hydrated node. This is probably a bug in React.");
+              throw Error("Expected prepareToHydrateHostSuspenseInstance() to never be called. This error is likely caused by a bug in React. Please file an issue.");
+            }
+            0 === (workInProgress.flags & 128) && (workInProgress.memoizedState = null);
+            workInProgress.flags |= 4;
+            bubbleProperties(workInProgress);
+            type = !1;
+          } else type = upgradeHydrationErrorsToRecoverable(), null !== current && null !== current.memoizedState && (current.memoizedState.hydrationErrors = type), type = !0;
+          if (!type) {
+            if (workInProgress.flags & 256) return popSuspenseHandler(workInProgress), workInProgress;
+            popSuspenseHandler(workInProgress);
+            return null;
+          }
+        }
+        popSuspenseHandler(workInProgress);
+        if (0 !== (workInProgress.flags & 128)) return workInProgress.lanes = renderLanes, workInProgress;
+        renderLanes = null !== newProps;
+        current = null !== current && null !== current.memoizedState;
+        renderLanes && (newProps = workInProgress.child, type = null, null !== newProps.alternate && null !== newProps.alternate.memoizedState && null !== newProps.alternate.memoizedState.cachePool && (type = newProps.alternate.memoizedState.cachePool.pool), updatePayload = null, null !== newProps.memoizedState && null !== newProps.memoizedState.cachePool && (updatePayload = newProps.memoizedState.cachePool.pool), updatePayload !== type && (newProps.flags |= 2048));
+        renderLanes !== current && renderLanes && (workInProgress.child.flags |= 8192);
+        scheduleRetryEffect(workInProgress, workInProgress.updateQueue);
+        bubbleProperties(workInProgress);
+        return null;
+      case 4:
+        return popHostContainer(), bubbleProperties(workInProgress), null;
+      case 10:
+        return popProvider(workInProgress.type), bubbleProperties(workInProgress), null;
+      case 17:
+        return bubbleProperties(workInProgress), null;
+      case 19:
+        pop(suspenseStackCursor);
+        type = workInProgress.memoizedState;
+        if (null === type) return bubbleProperties(workInProgress), null;
+        newProps = 0 !== (workInProgress.flags & 128);
+        updatePayload = type.rendering;
+        if (null === updatePayload) {
+          if (newProps) cutOffTailIfNeeded(type, !1);else {
+            if (0 !== workInProgressRootExitStatus || null !== current && 0 !== (current.flags & 128)) for (current = workInProgress.child; null !== current;) {
+              updatePayload = findFirstSuspended(current);
+              if (null !== updatePayload) {
+                workInProgress.flags |= 128;
+                cutOffTailIfNeeded(type, !1);
+                current = updatePayload.updateQueue;
+                workInProgress.updateQueue = current;
+                scheduleRetryEffect(workInProgress, current);
+                workInProgress.subtreeFlags = 0;
+                current = renderLanes;
+                for (renderLanes = workInProgress.child; null !== renderLanes;) resetWorkInProgress(renderLanes, current), renderLanes = renderLanes.sibling;
+                push(suspenseStackCursor, suspenseStackCursor.current & 1 | 2);
+                return workInProgress.child;
+              }
+              current = current.sibling;
+            }
+            null !== type.tail && _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_now() > workInProgressRootRenderTargetTime && (workInProgress.flags |= 128, newProps = !0, cutOffTailIfNeeded(type, !1), workInProgress.lanes = 4194304);
+          }
+        } else {
+          if (!newProps) if (current = findFirstSuspended(updatePayload), null !== current) {
+            if (workInProgress.flags |= 128, newProps = !0, current = current.updateQueue, workInProgress.updateQueue = current, scheduleRetryEffect(workInProgress, current), cutOffTailIfNeeded(type, !0), null === type.tail && "hidden" === type.tailMode && !updatePayload.alternate) return bubbleProperties(workInProgress), null;
+          } else 2 * _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_now() - type.renderingStartTime > workInProgressRootRenderTargetTime && 536870912 !== renderLanes && (workInProgress.flags |= 128, newProps = !0, cutOffTailIfNeeded(type, !1), workInProgress.lanes = 4194304);
+          type.isBackwards ? (updatePayload.sibling = workInProgress.child, workInProgress.child = updatePayload) : (current = type.last, null !== current ? current.sibling = updatePayload : workInProgress.child = updatePayload, type.last = updatePayload);
+        }
+        if (null !== type.tail) return workInProgress = type.tail, type.rendering = workInProgress, type.tail = workInProgress.sibling, type.renderingStartTime = _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_now(), workInProgress.sibling = null, current = suspenseStackCursor.current, push(suspenseStackCursor, newProps ? current & 1 | 2 : current & 1), workInProgress;
+        bubbleProperties(workInProgress);
+        return null;
+      case 22:
+      case 23:
+        return popSuspenseHandler(workInProgress), popHiddenContext(), newProps = null !== workInProgress.memoizedState, null !== current ? null !== current.memoizedState !== newProps && (workInProgress.flags |= 8192) : newProps && (workInProgress.flags |= 8192), newProps && 0 !== (workInProgress.mode & 1) ? 0 !== (renderLanes & 536870912) && 0 === (workInProgress.flags & 128) && (bubbleProperties(workInProgress), workInProgress.subtreeFlags & 6 && (workInProgress.flags |= 8192)) : bubbleProperties(workInProgress), renderLanes = workInProgress.updateQueue, null !== renderLanes && scheduleRetryEffect(workInProgress, renderLanes.retryQueue), renderLanes = null, null !== current && null !== current.memoizedState && null !== current.memoizedState.cachePool && (renderLanes = current.memoizedState.cachePool.pool), newProps = null, null !== workInProgress.memoizedState && null !== workInProgress.memoizedState.cachePool && (newProps = workInProgress.memoizedState.cachePool.pool), newProps !== renderLanes && (workInProgress.flags |= 2048), null !== current && pop(resumedCache), null;
+      case 24:
+        return renderLanes = null, null !== current && (renderLanes = current.memoizedState.cache), workInProgress.memoizedState.cache !== renderLanes && (workInProgress.flags |= 2048), popProvider(CacheContext), bubbleProperties(workInProgress), null;
+      case 25:
+        return null;
+      case 30:
+        return null;
+      case 29:
+        return null;
+    }
+    throw Error("Unknown unit of work tag (" + workInProgress.tag + "). This error is likely caused by a bug in React. Please file an issue.");
+  }
+  function unwindWork(current, workInProgress) {
+    switch (workInProgress.tag) {
+      case 1:
+        return current = workInProgress.flags, current & 65536 ? (workInProgress.flags = current & -65537 | 128, workInProgress) : null;
+      case 3:
+        return popProvider(CacheContext), popHostContainer(), current = workInProgress.flags, 0 !== (current & 65536) && 0 === (current & 128) ? (workInProgress.flags = current & -65537 | 128, workInProgress) : null;
+      case 26:
+      case 27:
+      case 5:
+        return popHostContext(workInProgress), null;
+      case 13:
+        popSuspenseHandler(workInProgress);
+        current = workInProgress.memoizedState;
+        if (null !== current && null !== current.dehydrated && null === workInProgress.alternate) throw Error("Threw in newly mounted dehydrated component. This is likely a bug in React. Please file an issue.");
+        current = workInProgress.flags;
+        return current & 65536 ? (workInProgress.flags = current & -65537 | 128, workInProgress) : null;
+      case 19:
+        return pop(suspenseStackCursor), null;
+      case 4:
+        return popHostContainer(), null;
+      case 10:
+        return popProvider(workInProgress.type), null;
+      case 22:
+      case 23:
+        return popSuspenseHandler(workInProgress), popHiddenContext(), null !== current && pop(resumedCache), current = workInProgress.flags, current & 65536 ? (workInProgress.flags = current & -65537 | 128, workInProgress) : null;
+      case 24:
+        return popProvider(CacheContext), null;
+      case 25:
+        return null;
+      default:
+        return null;
+    }
+  }
+  function unwindInterruptedWork(current, interruptedWork) {
+    switch (interruptedWork.tag) {
+      case 3:
+        popProvider(CacheContext);
+        popHostContainer();
+        break;
+      case 26:
+      case 27:
+      case 5:
+        popHostContext(interruptedWork);
+        break;
+      case 4:
+        popHostContainer();
+        break;
+      case 13:
+        popSuspenseHandler(interruptedWork);
+        break;
+      case 19:
+        pop(suspenseStackCursor);
+        break;
+      case 10:
+        popProvider(interruptedWork.type);
+        break;
+      case 22:
+      case 23:
+        popSuspenseHandler(interruptedWork);
+        popHiddenContext();
+        null !== current && pop(resumedCache);
+        break;
+      case 24:
+        popProvider(CacheContext);
+    }
+  }
+  function commitHookEffectListMount(flags, finishedWork) {
+    try {
+      var updateQueue = finishedWork.updateQueue,
+        lastEffect = null !== updateQueue ? updateQueue.lastEffect : null;
+      if (null !== lastEffect) {
+        var firstEffect = lastEffect.next;
+        updateQueue = firstEffect;
+        do {
+          if ((updateQueue.tag & flags) === flags) {
+            lastEffect = void 0;
+            var create$116 = updateQueue.create,
+              inst = updateQueue.inst;
+            lastEffect = create$116();
+            inst.destroy = lastEffect;
+          }
+          updateQueue = updateQueue.next;
+        } while (updateQueue !== firstEffect);
+      }
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+  function commitHookEffectListUnmount(flags, finishedWork, nearestMountedAncestor$jscomp$0) {
+    try {
+      var updateQueue = finishedWork.updateQueue,
+        lastEffect = null !== updateQueue ? updateQueue.lastEffect : null;
+      if (null !== lastEffect) {
+        var firstEffect = lastEffect.next;
+        updateQueue = firstEffect;
+        do {
+          if ((updateQueue.tag & flags) === flags) {
+            var inst = updateQueue.inst,
+              destroy = inst.destroy;
+            if (void 0 !== destroy) {
+              inst.destroy = void 0;
+              lastEffect = finishedWork;
+              var nearestMountedAncestor = nearestMountedAncestor$jscomp$0,
+                destroy_ = destroy;
+              try {
+                destroy_();
+              } catch (error) {
+                captureCommitPhaseError(lastEffect, nearestMountedAncestor, error);
+              }
+            }
+          }
+          updateQueue = updateQueue.next;
+        } while (updateQueue !== firstEffect);
+      }
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+  function commitClassCallbacks(finishedWork) {
+    var updateQueue = finishedWork.updateQueue;
+    if (null !== updateQueue) {
+      var instance = finishedWork.stateNode;
+      try {
+        commitCallbacks(updateQueue, instance);
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+    }
+  }
+  function safelyCallComponentWillUnmount(current, nearestMountedAncestor, instance) {
+    instance.props = resolveClassComponentProps(current.type, current.memoizedProps);
+    instance.state = current.memoizedState;
+    try {
+      instance.componentWillUnmount();
+    } catch (error) {
+      captureCommitPhaseError(current, nearestMountedAncestor, error);
+    }
+  }
+  function safelyAttachRef(current, nearestMountedAncestor) {
+    try {
+      var ref = current.ref;
+      if (null !== ref) {
+        switch (current.tag) {
+          case 26:
+          case 27:
+          case 5:
+            var instanceToUse = getPublicInstance(current.stateNode);
+            break;
+          case 30:
+            instanceToUse = current.stateNode;
+            break;
+          default:
+            instanceToUse = current.stateNode;
+        }
+        "function" === typeof ref ? current.refCleanup = ref(instanceToUse) : ref.current = instanceToUse;
+      }
+    } catch (error) {
+      captureCommitPhaseError(current, nearestMountedAncestor, error);
+    }
+  }
+  function safelyDetachRef(current, nearestMountedAncestor) {
+    var ref = current.ref,
+      refCleanup = current.refCleanup;
+    if (null !== ref) if ("function" === typeof refCleanup) try {
+      refCleanup();
+    } catch (error) {
+      captureCommitPhaseError(current, nearestMountedAncestor, error);
+    } finally {
+      current.refCleanup = null, current = current.alternate, null != current && (current.refCleanup = null);
+    } else if ("function" === typeof ref) try {
+      ref(null);
+    } catch (error$118) {
+      captureCommitPhaseError(current, nearestMountedAncestor, error$118);
+    } else ref.current = null;
+  }
+  function isHostParent(fiber) {
+    return 5 === fiber.tag || 3 === fiber.tag || 4 === fiber.tag;
+  }
+  function getHostSibling(fiber) {
+    a: for (;;) {
+      for (; null === fiber.sibling;) {
+        if (null === fiber.return || isHostParent(fiber.return)) return null;
+        fiber = fiber.return;
+      }
+      fiber.sibling.return = fiber.return;
+      for (fiber = fiber.sibling; 5 !== fiber.tag && 6 !== fiber.tag && 18 !== fiber.tag;) {
+        if (fiber.flags & 2) continue a;
+        if (null === fiber.child || 4 === fiber.tag) continue a;else fiber.child.return = fiber, fiber = fiber.child;
+      }
+      if (!(fiber.flags & 2)) return fiber.stateNode;
+    }
+  }
+  function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
+    var tag = node.tag;
+    if (5 === tag || 6 === tag) {
+      if (node = node.stateNode, before) {
+        if ("number" === typeof parent) throw Error("Container does not support insertBefore operation");
+      } else _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").UIManager.setChildren(parent.containerTag, ["number" === typeof node ? node : node._nativeTag]);
+    } else if (4 !== tag && (node = node.child, null !== node)) for (insertOrAppendPlacementNodeIntoContainer(node, before, parent), node = node.sibling; null !== node;) insertOrAppendPlacementNodeIntoContainer(node, before, parent), node = node.sibling;
+  }
+  function insertOrAppendPlacementNode(node, before, parent) {
+    var tag = node.tag;
+    if (5 === tag || 6 === tag) {
+      if (node = node.stateNode, before) {
+        tag = parent._children;
+        var index = tag.indexOf(node);
+        0 <= index ? (tag.splice(index, 1), before = tag.indexOf(before), tag.splice(before, 0, node), _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").UIManager.manageChildren(parent._nativeTag, [index], [before], [], [], [])) : (before = tag.indexOf(before), tag.splice(before, 0, node), _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").UIManager.manageChildren(parent._nativeTag, [], [], ["number" === typeof node ? node : node._nativeTag], [before], []));
+      } else before = "number" === typeof node ? node : node._nativeTag, tag = parent._children, index = tag.indexOf(node), 0 <= index ? (tag.splice(index, 1), tag.push(node), _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").UIManager.manageChildren(parent._nativeTag, [index], [tag.length - 1], [], [], [])) : (tag.push(node), _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").UIManager.manageChildren(parent._nativeTag, [], [], [before], [tag.length - 1], []));
+    } else if (4 !== tag && (node = node.child, null !== node)) for (insertOrAppendPlacementNode(node, before, parent), node = node.sibling; null !== node;) insertOrAppendPlacementNode(node, before, parent), node = node.sibling;
+  }
+  var offscreenSubtreeIsHidden = !1,
+    offscreenSubtreeWasHidden = !1,
+    PossiblyWeakSet = "function" === typeof WeakSet ? WeakSet : Set,
+    nextEffect = null;
+  function commitBeforeMutationEffects(root, firstChild) {
+    for (nextEffect = firstChild; null !== nextEffect;) if (root = nextEffect, firstChild = root.child, 0 !== (root.subtreeFlags & 1024) && null !== firstChild) firstChild.return = root, nextEffect = firstChild;else for (; null !== nextEffect;) {
+      root = nextEffect;
+      var current = root.alternate;
+      firstChild = root.flags;
+      switch (root.tag) {
+        case 0:
+          break;
+        case 11:
+        case 15:
+          break;
+        case 1:
+          if (0 !== (firstChild & 1024) && null !== current) {
+            firstChild = void 0;
+            var finishedWork = root,
+              prevProps = current.memoizedProps;
+            current = current.memoizedState;
+            var instance = finishedWork.stateNode;
+            try {
+              var resolvedPrevProps = resolveClassComponentProps(finishedWork.type, prevProps, finishedWork.elementType === finishedWork.type);
+              firstChild = instance.getSnapshotBeforeUpdate(resolvedPrevProps, current);
+              instance.__reactInternalSnapshotBeforeUpdate = firstChild;
+            } catch (error) {
+              captureCommitPhaseError(finishedWork, finishedWork.return, error);
+            }
+          }
+          break;
+        case 3:
+          break;
+        case 5:
+        case 26:
+        case 27:
+        case 6:
+        case 4:
+        case 17:
+          break;
+        default:
+          if (0 !== (firstChild & 1024)) throw Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue.");
+      }
+      firstChild = root.sibling;
+      if (null !== firstChild) {
+        firstChild.return = root.return;
+        nextEffect = firstChild;
+        break;
+      }
+      nextEffect = root.return;
+    }
+  }
+  function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork) {
+    var flags = finishedWork.flags;
+    switch (finishedWork.tag) {
+      case 0:
+      case 11:
+      case 15:
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        flags & 4 && commitHookEffectListMount(5, finishedWork);
+        break;
+      case 1:
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        if (flags & 4) if (finishedRoot = finishedWork.stateNode, null === current) try {
+          finishedRoot.componentDidMount();
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        } else {
+          var prevProps = resolveClassComponentProps(finishedWork.type, current.memoizedProps);
+          current = current.memoizedState;
+          try {
+            finishedRoot.componentDidUpdate(prevProps, current, finishedRoot.__reactInternalSnapshotBeforeUpdate);
+          } catch (error$117) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error$117);
+          }
+        }
+        flags & 64 && commitClassCallbacks(finishedWork);
+        flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      case 3:
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        if (flags & 64 && (finishedRoot = finishedWork.updateQueue, null !== finishedRoot)) {
+          current = null;
+          if (null !== finishedWork.child) switch (finishedWork.child.tag) {
+            case 27:
+            case 5:
+              current = getPublicInstance(finishedWork.child.stateNode);
+              break;
+            case 1:
+              current = finishedWork.child.stateNode;
+          }
+          try {
+            commitCallbacks(finishedRoot, current);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+        break;
+      case 27:
+      case 26:
+      case 5:
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
+        break;
+      case 12:
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        break;
+      case 13:
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        flags & 64 && (finishedRoot = finishedWork.memoizedState, null !== finishedRoot && null !== finishedRoot.dehydrated && (retryDehydratedSuspenseBoundary.bind(null, finishedWork), shim$1()));
+        break;
+      case 22:
+        if (0 !== (finishedWork.mode & 1)) {
+          if (flags = null !== finishedWork.memoizedState || offscreenSubtreeIsHidden, !flags) {
+            current = null !== current && null !== current.memoizedState || offscreenSubtreeWasHidden;
+            prevProps = offscreenSubtreeIsHidden;
+            var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+            offscreenSubtreeIsHidden = flags;
+            (offscreenSubtreeWasHidden = current) && !prevOffscreenSubtreeWasHidden ? recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, 0 !== (finishedWork.subtreeFlags & 8772)) : recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+            offscreenSubtreeIsHidden = prevProps;
+            offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+          }
+        } else recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        break;
+      case 30:
+        break;
+      default:
+        recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+    }
+  }
+  function detachFiberAfterEffects(fiber) {
+    var alternate = fiber.alternate;
+    null !== alternate && (fiber.alternate = null, detachFiberAfterEffects(alternate));
+    fiber.child = null;
+    fiber.deletions = null;
+    fiber.sibling = null;
+    fiber.stateNode = null;
+    fiber.return = null;
+    fiber.dependencies = null;
+    fiber.memoizedProps = null;
+    fiber.memoizedState = null;
+    fiber.pendingProps = null;
+    fiber.stateNode = null;
+    fiber.updateQueue = null;
+  }
+  var hostParent = null,
+    hostParentIsContainer = !1;
+  function recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, parent) {
+    for (parent = parent.child; null !== parent;) commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, parent), parent = parent.sibling;
+  }
+  function commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, deletedFiber) {
+    if (injectedHook && "function" === typeof injectedHook.onCommitFiberUnmount) try {
+      injectedHook.onCommitFiberUnmount(rendererID, deletedFiber);
+    } catch (err) {}
+    switch (deletedFiber.tag) {
+      case 26:
+      case 27:
+      case 5:
+        offscreenSubtreeWasHidden || safelyDetachRef(deletedFiber, nearestMountedAncestor);
+      case 6:
+        var prevHostParent = hostParent,
+          prevHostParentIsContainer = hostParentIsContainer;
+        hostParent = null;
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        hostParent = prevHostParent;
+        hostParentIsContainer = prevHostParentIsContainer;
+        if (null !== hostParent) if (hostParentIsContainer) try {
+          finishedRoot = hostParent, recursivelyUncacheFiberNode(deletedFiber.stateNode), _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").UIManager.manageChildren(finishedRoot.containerTag, [], [], [], [], [0]);
+        } catch (error) {
+          captureCommitPhaseError(deletedFiber, nearestMountedAncestor, error);
+        } else try {
+          finishedRoot = hostParent;
+          var child = deletedFiber.stateNode;
+          recursivelyUncacheFiberNode(child);
+          var children = finishedRoot._children,
+            index = children.indexOf(child);
+          children.splice(index, 1);
+          _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").UIManager.manageChildren(finishedRoot._nativeTag, [], [], [], [], [index]);
+        } catch (error) {
+          captureCommitPhaseError(deletedFiber, nearestMountedAncestor, error);
+        }
+        break;
+      case 18:
+        null !== hostParent && shim$1();
+        break;
+      case 4:
+        child = hostParent;
+        children = hostParentIsContainer;
+        hostParent = deletedFiber.stateNode.containerInfo;
+        hostParentIsContainer = !0;
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        hostParent = child;
+        hostParentIsContainer = children;
+        break;
+      case 0:
+      case 11:
+      case 14:
+      case 15:
+        offscreenSubtreeWasHidden || commitHookEffectListUnmount(2, deletedFiber, nearestMountedAncestor);
+        offscreenSubtreeWasHidden || commitHookEffectListUnmount(4, deletedFiber, nearestMountedAncestor);
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        break;
+      case 1:
+        offscreenSubtreeWasHidden || (safelyDetachRef(deletedFiber, nearestMountedAncestor), child = deletedFiber.stateNode, "function" === typeof child.componentWillUnmount && safelyCallComponentWillUnmount(deletedFiber, nearestMountedAncestor, child));
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        break;
+      case 21:
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        break;
+      case 22:
+        deletedFiber.mode & 1 ? (offscreenSubtreeWasHidden = (child = offscreenSubtreeWasHidden) || null !== deletedFiber.memoizedState, recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber), offscreenSubtreeWasHidden = child) : recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+        break;
+      default:
+        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+    }
+  }
+  function getRetryCache(finishedWork) {
+    switch (finishedWork.tag) {
+      case 13:
+      case 19:
+        var retryCache = finishedWork.stateNode;
+        null === retryCache && (retryCache = finishedWork.stateNode = new PossiblyWeakSet());
+        return retryCache;
+      case 22:
+        return finishedWork = finishedWork.stateNode, retryCache = finishedWork._retryCache, null === retryCache && (retryCache = finishedWork._retryCache = new PossiblyWeakSet()), retryCache;
+      default:
+        throw Error("Unexpected Suspense handler tag (" + finishedWork.tag + "). This is a bug in React.");
+    }
+  }
+  function attachSuspenseRetryListeners(finishedWork, wakeables) {
+    var retryCache = getRetryCache(finishedWork);
+    wakeables.forEach(function (wakeable) {
+      var retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
+      retryCache.has(wakeable) || (retryCache.add(wakeable), wakeable.then(retry, retry));
+    });
+  }
+  function recursivelyTraverseMutationEffects(root$jscomp$0, parentFiber) {
+    var deletions = parentFiber.deletions;
+    if (null !== deletions) for (var i = 0; i < deletions.length; i++) {
+      var childToDelete = deletions[i],
+        root = root$jscomp$0,
+        returnFiber = parentFiber,
+        parent = returnFiber;
+      a: for (; null !== parent;) {
+        switch (parent.tag) {
+          case 27:
+          case 5:
+            hostParent = parent.stateNode;
+            hostParentIsContainer = !1;
+            break a;
+          case 3:
+          case 4:
+            hostParent = parent.stateNode.containerInfo;
+            hostParentIsContainer = !0;
+            break a;
+        }
+        parent = parent.return;
+      }
+      if (null === hostParent) throw Error("Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue.");
+      commitDeletionEffectsOnFiber(root, returnFiber, childToDelete);
+      hostParent = null;
+      hostParentIsContainer = !1;
+      root = childToDelete.alternate;
+      null !== root && (root.return = null);
+      childToDelete.return = null;
+    }
+    if (parentFiber.subtreeFlags & 13878) for (parentFiber = parentFiber.child; null !== parentFiber;) commitMutationEffectsOnFiber(parentFiber, root$jscomp$0), parentFiber = parentFiber.sibling;
+  }
+  function commitMutationEffectsOnFiber(finishedWork, root) {
+    var current = finishedWork.alternate,
+      flags = finishedWork.flags;
+    switch (finishedWork.tag) {
+      case 0:
+      case 11:
+      case 14:
+      case 15:
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        flags & 4 && (commitHookEffectListUnmount(3, finishedWork, finishedWork.return), commitHookEffectListMount(3, finishedWork), commitHookEffectListUnmount(5, finishedWork, finishedWork.return));
+        break;
+      case 1:
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        flags & 512 && (offscreenSubtreeWasHidden || null === current || safelyDetachRef(current, current.return));
+        if (flags & 64 && offscreenSubtreeIsHidden && (finishedWork = finishedWork.updateQueue, null !== finishedWork && (flags = finishedWork.callbacks, null !== flags))) {
+          var existingHiddenCallbacks = finishedWork.shared.hiddenCallbacks;
+          finishedWork.shared.hiddenCallbacks = null === existingHiddenCallbacks ? flags : existingHiddenCallbacks.concat(flags);
+        }
+        break;
+      case 26:
+      case 27:
+      case 5:
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        flags & 512 && (offscreenSubtreeWasHidden || null === current || safelyDetachRef(current, current.return));
+        if (flags & 4 && null != finishedWork.stateNode) {
+          flags = finishedWork.memoizedProps;
+          existingHiddenCallbacks = null !== current ? current.memoizedProps : flags;
+          try {
+            var instance = finishedWork.stateNode,
+              viewConfig = instance.viewConfig;
+            instanceProps.set(instance._nativeTag, flags);
+            var updatePayload = diffProperties(null, existingHiddenCallbacks, flags, viewConfig.validAttributes);
+            null != updatePayload && _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").UIManager.updateView(instance._nativeTag, viewConfig.uiViewClassName, updatePayload);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+        break;
+      case 6:
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        if (flags & 4) {
+          if (null === finishedWork.stateNode) throw Error("This should have a text node initialized. This error is likely caused by a bug in React. Please file an issue.");
+          flags = finishedWork.memoizedProps;
+          existingHiddenCallbacks = finishedWork.stateNode;
+          try {
+            _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").UIManager.updateView(existingHiddenCallbacks, "RCTRawText", {
+              text: flags
+            });
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+        break;
+      case 3:
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        break;
+      case 4:
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        break;
+      case 12:
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        break;
+      case 13:
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        finishedWork.child.flags & 8192 && (existingHiddenCallbacks = null !== current && null !== current.memoizedState, null === finishedWork.memoizedState || existingHiddenCallbacks || (globalMostRecentFallbackTime = _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_now()));
+        flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (finishedWork.updateQueue = null, attachSuspenseRetryListeners(finishedWork, flags)));
+        break;
+      case 22:
+        instance = null !== finishedWork.memoizedState;
+        viewConfig = null !== current && null !== current.memoizedState;
+        if (finishedWork.mode & 1) {
+          updatePayload = offscreenSubtreeIsHidden;
+          var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+          offscreenSubtreeIsHidden = updatePayload || instance;
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || viewConfig;
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+          offscreenSubtreeIsHidden = updatePayload;
+        } else recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        if (flags & 8192) a: for (root = finishedWork.stateNode, root._visibility = instance ? root._visibility & -2 : root._visibility | 1, instance && (null === current || viewConfig || offscreenSubtreeIsHidden || offscreenSubtreeWasHidden || 0 !== (finishedWork.mode & 1) && recursivelyTraverseDisappearLayoutEffects(finishedWork)), current = null, root = finishedWork;;) {
+          if (5 === root.tag) {
+            if (null === current) {
+              viewConfig = current = root;
+              try {
+                if (existingHiddenCallbacks = viewConfig.stateNode, instance) {
+                  updatePayload = existingHiddenCallbacks;
+                  var viewConfig$jscomp$0 = updatePayload.viewConfig;
+                  var updatePayload$jscomp$0 = diffProperties(null, emptyObject, {
+                    style: {
+                      display: "none"
+                    }
+                  }, viewConfig$jscomp$0.validAttributes);
+                  _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").UIManager.updateView(updatePayload._nativeTag, viewConfig$jscomp$0.uiViewClassName, updatePayload$jscomp$0);
+                } else {
+                  var instance$jscomp$0 = viewConfig.stateNode,
+                    props = viewConfig.memoizedProps,
+                    viewConfig$jscomp$1 = instance$jscomp$0.viewConfig,
+                    prevProps = assign({}, props, {
+                      style: [props.style, {
+                        display: "none"
+                      }]
+                    });
+                  var updatePayload$jscomp$1 = diffProperties(null, prevProps, props, viewConfig$jscomp$1.validAttributes);
+                  _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").UIManager.updateView(instance$jscomp$0._nativeTag, viewConfig$jscomp$1.uiViewClassName, updatePayload$jscomp$1);
+                }
+              } catch (error) {
+                captureCommitPhaseError(viewConfig, viewConfig.return, error);
+              }
+            }
+          } else if (6 === root.tag) {
+            if (null === current) {
+              viewConfig = root;
+              try {
+                throw Error("Not yet implemented.");
+              } catch (error) {
+                captureCommitPhaseError(viewConfig, viewConfig.return, error);
+              }
+            }
+          } else if ((22 !== root.tag && 23 !== root.tag || null === root.memoizedState || root === finishedWork) && null !== root.child) {
+            root.child.return = root;
+            root = root.child;
+            continue;
+          }
+          if (root === finishedWork) break a;
+          for (; null === root.sibling;) {
+            if (null === root.return || root.return === finishedWork) break a;
+            current === root && (current = null);
+            root = root.return;
+          }
+          current === root && (current = null);
+          root.sibling.return = root.return;
+          root = root.sibling;
+        }
+        flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (existingHiddenCallbacks = flags.retryQueue, null !== existingHiddenCallbacks && (flags.retryQueue = null, attachSuspenseRetryListeners(finishedWork, existingHiddenCallbacks))));
+        break;
+      case 19:
+        recursivelyTraverseMutationEffects(root, finishedWork);
+        commitReconciliationEffects(finishedWork);
+        flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (finishedWork.updateQueue = null, attachSuspenseRetryListeners(finishedWork, flags)));
+        break;
+      case 30:
+        break;
+      case 21:
+        break;
+      default:
+        recursivelyTraverseMutationEffects(root, finishedWork), commitReconciliationEffects(finishedWork);
+    }
+  }
+  function commitReconciliationEffects(finishedWork) {
+    var flags = finishedWork.flags;
+    if (flags & 2) {
+      try {
+        for (var hostParentFiber, parentFiber = finishedWork.return; null !== parentFiber;) {
+          if (isHostParent(parentFiber)) {
+            hostParentFiber = parentFiber;
+            break;
+          }
+          parentFiber = parentFiber.return;
+        }
+        if (null == hostParentFiber) throw Error("Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue.");
+        switch (hostParentFiber.tag) {
+          case 27:
+          case 5:
+            var parent = hostParentFiber.stateNode;
+            hostParentFiber.flags & 32 && (hostParentFiber.flags &= -33);
+            var before = getHostSibling(finishedWork);
+            insertOrAppendPlacementNode(finishedWork, before, parent);
+            break;
+          case 3:
+          case 4:
+            var parent$119 = hostParentFiber.stateNode.containerInfo,
+              before$120 = getHostSibling(finishedWork);
+            insertOrAppendPlacementNodeIntoContainer(finishedWork, before$120, parent$119);
+            break;
+          default:
+            throw Error("Invalid host parent fiber. This error is likely caused by a bug in React. Please file an issue.");
+        }
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+      finishedWork.flags &= -3;
+    }
+    flags & 4096 && (finishedWork.flags &= -4097);
+  }
+  function recursivelyTraverseLayoutEffects(root, parentFiber) {
+    if (parentFiber.subtreeFlags & 8772) for (parentFiber = parentFiber.child; null !== parentFiber;) commitLayoutEffectOnFiber(root, parentFiber.alternate, parentFiber), parentFiber = parentFiber.sibling;
+  }
+  function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
+    for (parentFiber = parentFiber.child; null !== parentFiber;) {
+      var finishedWork = parentFiber;
+      switch (finishedWork.tag) {
+        case 0:
+        case 11:
+        case 14:
+        case 15:
+          commitHookEffectListUnmount(4, finishedWork, finishedWork.return);
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+          break;
+        case 1:
+          safelyDetachRef(finishedWork, finishedWork.return);
+          var instance = finishedWork.stateNode;
+          "function" === typeof instance.componentWillUnmount && safelyCallComponentWillUnmount(finishedWork, finishedWork.return, instance);
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+          break;
+        case 27:
+        case 26:
+        case 5:
+          safelyDetachRef(finishedWork, finishedWork.return);
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+          break;
+        case 22:
+          null === finishedWork.memoizedState && recursivelyTraverseDisappearLayoutEffects(finishedWork);
+          break;
+        case 30:
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+          break;
+        default:
+          recursivelyTraverseDisappearLayoutEffects(finishedWork);
+      }
+      parentFiber = parentFiber.sibling;
+    }
+  }
+  function recursivelyTraverseReappearLayoutEffects(finishedRoot$jscomp$0, parentFiber, includeWorkInProgressEffects) {
+    includeWorkInProgressEffects = includeWorkInProgressEffects && 0 !== (parentFiber.subtreeFlags & 8772);
+    for (parentFiber = parentFiber.child; null !== parentFiber;) {
+      var finishedRoot = finishedRoot$jscomp$0,
+        finishedWork = parentFiber,
+        flags = finishedWork.flags;
+      switch (finishedWork.tag) {
+        case 0:
+        case 11:
+        case 15:
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+          commitHookEffectListMount(4, finishedWork);
+          break;
+        case 1:
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+          finishedRoot = finishedWork;
+          var instance = finishedRoot.stateNode;
+          if ("function" === typeof instance.componentDidMount) try {
+            instance.componentDidMount();
+          } catch (error) {
+            captureCommitPhaseError(finishedRoot, finishedRoot.return, error);
+          }
+          finishedRoot = finishedWork;
+          instance = finishedRoot.updateQueue;
+          if (null !== instance) {
+            var instance$jscomp$0 = finishedRoot.stateNode;
+            try {
+              var hiddenCallbacks = instance.shared.hiddenCallbacks;
+              if (null !== hiddenCallbacks) for (instance.shared.hiddenCallbacks = null, instance = 0; instance < hiddenCallbacks.length; instance++) callCallback(hiddenCallbacks[instance], instance$jscomp$0);
+            } catch (error) {
+              captureCommitPhaseError(finishedRoot, finishedRoot.return, error);
+            }
+          }
+          includeWorkInProgressEffects && flags & 64 && commitClassCallbacks(finishedWork);
+          safelyAttachRef(finishedWork, finishedWork.return);
+          break;
+        case 27:
+        case 26:
+        case 5:
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+          safelyAttachRef(finishedWork, finishedWork.return);
+          break;
+        case 12:
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+          break;
+        case 13:
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+          break;
+        case 22:
+          null === finishedWork.memoizedState && recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+          safelyAttachRef(finishedWork, finishedWork.return);
+          break;
+        case 30:
+          break;
+        default:
+          recursivelyTraverseReappearLayoutEffects(finishedRoot, finishedWork, includeWorkInProgressEffects);
+      }
+      parentFiber = parentFiber.sibling;
+    }
+  }
+  function commitOffscreenPassiveMountEffects(current, finishedWork) {
+    var previousCache = null;
+    null !== current && null !== current.memoizedState && null !== current.memoizedState.cachePool && (previousCache = current.memoizedState.cachePool.pool);
+    current = null;
+    null !== finishedWork.memoizedState && null !== finishedWork.memoizedState.cachePool && (current = finishedWork.memoizedState.cachePool.pool);
+    current !== previousCache && (null != current && current.refCount++, null != previousCache && releaseCache(previousCache));
+  }
+  function commitCachePassiveMountEffect(current, finishedWork) {
+    current = null;
+    null !== finishedWork.alternate && (current = finishedWork.alternate.memoizedState.cache);
+    finishedWork = finishedWork.memoizedState.cache;
+    finishedWork !== current && (finishedWork.refCount++, null != current && releaseCache(current));
+  }
+  function recursivelyTraversePassiveMountEffects(root, parentFiber, committedLanes, committedTransitions) {
+    if (parentFiber.subtreeFlags & 10256) for (parentFiber = parentFiber.child; null !== parentFiber;) commitPassiveMountOnFiber(root, parentFiber, committedLanes, committedTransitions), parentFiber = parentFiber.sibling;
+  }
+  function commitPassiveMountOnFiber(finishedRoot, finishedWork, committedLanes, committedTransitions) {
+    var flags = finishedWork.flags;
+    switch (finishedWork.tag) {
+      case 0:
+      case 11:
+      case 15:
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+        flags & 2048 && commitHookEffectListMount(9, finishedWork);
+        break;
+      case 1:
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+        break;
+      case 3:
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+        flags & 2048 && (finishedRoot = null, null !== finishedWork.alternate && (finishedRoot = finishedWork.alternate.memoizedState.cache), finishedWork = finishedWork.memoizedState.cache, finishedWork !== finishedRoot && (finishedWork.refCount++, null != finishedRoot && releaseCache(finishedRoot)));
+        break;
+      case 12:
+        if (flags & 2048) {
+          recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+          finishedRoot = finishedWork.stateNode;
+          try {
+            var _finishedWork$memoize2 = finishedWork.memoizedProps,
+              id = _finishedWork$memoize2.id,
+              onPostCommit = _finishedWork$memoize2.onPostCommit;
+            "function" === typeof onPostCommit && onPostCommit(id, null === finishedWork.alternate ? "mount" : "update", finishedRoot.passiveEffectDuration, -0);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        } else recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+        break;
+      case 13:
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+        break;
+      case 23:
+        break;
+      case 22:
+        _finishedWork$memoize2 = finishedWork.stateNode;
+        id = finishedWork.alternate;
+        null !== finishedWork.memoizedState ? _finishedWork$memoize2._visibility & 2 ? recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions) : finishedWork.mode & 1 ? recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork) : (_finishedWork$memoize2._visibility |= 2, recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions)) : _finishedWork$memoize2._visibility & 2 ? recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions) : (_finishedWork$memoize2._visibility |= 2, recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, 0 !== (finishedWork.subtreeFlags & 10256)));
+        flags & 2048 && commitOffscreenPassiveMountEffects(id, finishedWork);
+        break;
+      case 24:
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+        flags & 2048 && commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
+        break;
+      default:
+        recursivelyTraversePassiveMountEffects(finishedRoot, finishedWork, committedLanes, committedTransitions);
+    }
+  }
+  function recursivelyTraverseReconnectPassiveEffects(finishedRoot$jscomp$0, parentFiber, committedLanes$jscomp$0, committedTransitions$jscomp$0, includeWorkInProgressEffects) {
+    includeWorkInProgressEffects = includeWorkInProgressEffects && 0 !== (parentFiber.subtreeFlags & 10256);
+    for (parentFiber = parentFiber.child; null !== parentFiber;) {
+      var finishedRoot = finishedRoot$jscomp$0,
+        finishedWork = parentFiber,
+        committedLanes = committedLanes$jscomp$0,
+        committedTransitions = committedTransitions$jscomp$0,
+        flags = finishedWork.flags;
+      switch (finishedWork.tag) {
+        case 0:
+        case 11:
+        case 15:
+          recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+          commitHookEffectListMount(8, finishedWork);
+          break;
+        case 23:
+          break;
+        case 22:
+          var instance = finishedWork.stateNode;
+          null !== finishedWork.memoizedState ? instance._visibility & 2 ? recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects) : finishedWork.mode & 1 ? recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork) : (instance._visibility |= 2, recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects)) : (instance._visibility |= 2, recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects));
+          includeWorkInProgressEffects && flags & 2048 && commitOffscreenPassiveMountEffects(finishedWork.alternate, finishedWork);
+          break;
+        case 24:
+          recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+          includeWorkInProgressEffects && flags & 2048 && commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
+          break;
+        default:
+          recursivelyTraverseReconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects);
+      }
+      parentFiber = parentFiber.sibling;
+    }
+  }
+  function recursivelyTraverseAtomicPassiveEffects(finishedRoot$jscomp$0, parentFiber) {
+    if (parentFiber.subtreeFlags & 10256) for (parentFiber = parentFiber.child; null !== parentFiber;) {
+      var finishedRoot = finishedRoot$jscomp$0,
+        finishedWork = parentFiber,
+        flags = finishedWork.flags;
+      switch (finishedWork.tag) {
+        case 22:
+          recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+          flags & 2048 && commitOffscreenPassiveMountEffects(finishedWork.alternate, finishedWork);
+          break;
+        case 24:
+          recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+          flags & 2048 && commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
+          break;
+        default:
+          recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+      }
+      parentFiber = parentFiber.sibling;
+    }
+  }
+  var suspenseyCommitFlag = 8192;
+  function recursivelyAccumulateSuspenseyCommit(parentFiber) {
+    if (parentFiber.subtreeFlags & suspenseyCommitFlag) for (parentFiber = parentFiber.child; null !== parentFiber;) accumulateSuspenseyCommitOnFiber(parentFiber), parentFiber = parentFiber.sibling;
+  }
+  function accumulateSuspenseyCommitOnFiber(fiber) {
+    switch (fiber.tag) {
+      case 26:
+        recursivelyAccumulateSuspenseyCommit(fiber);
+        fiber.flags & suspenseyCommitFlag && null !== fiber.memoizedState && shim();
+        break;
+      case 5:
+        recursivelyAccumulateSuspenseyCommit(fiber);
+        break;
+      case 3:
+      case 4:
+        recursivelyAccumulateSuspenseyCommit(fiber);
+        break;
+      case 22:
+        if (null === fiber.memoizedState) {
+          var current = fiber.alternate;
+          null !== current && null !== current.memoizedState ? (current = suspenseyCommitFlag, suspenseyCommitFlag = 16777216, recursivelyAccumulateSuspenseyCommit(fiber), suspenseyCommitFlag = current) : recursivelyAccumulateSuspenseyCommit(fiber);
+        }
+        break;
+      default:
+        recursivelyAccumulateSuspenseyCommit(fiber);
+    }
+  }
+  function detachAlternateSiblings(parentFiber) {
+    var previousFiber = parentFiber.alternate;
+    if (null !== previousFiber && (parentFiber = previousFiber.child, null !== parentFiber)) {
+      previousFiber.child = null;
+      do previousFiber = parentFiber.sibling, parentFiber.sibling = null, parentFiber = previousFiber; while (null !== parentFiber);
+    }
+  }
+  function recursivelyTraversePassiveUnmountEffects(parentFiber) {
+    var deletions = parentFiber.deletions;
+    if (0 !== (parentFiber.flags & 16)) {
+      if (null !== deletions) for (var i = 0; i < deletions.length; i++) {
+        var childToDelete = deletions[i];
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(childToDelete, parentFiber);
+      }
+      detachAlternateSiblings(parentFiber);
+    }
+    if (parentFiber.subtreeFlags & 10256) for (parentFiber = parentFiber.child; null !== parentFiber;) commitPassiveUnmountOnFiber(parentFiber), parentFiber = parentFiber.sibling;
+  }
+  function commitPassiveUnmountOnFiber(finishedWork) {
+    switch (finishedWork.tag) {
+      case 0:
+      case 11:
+      case 15:
+        recursivelyTraversePassiveUnmountEffects(finishedWork);
+        finishedWork.flags & 2048 && commitHookEffectListUnmount(9, finishedWork, finishedWork.return);
+        break;
+      case 3:
+        recursivelyTraversePassiveUnmountEffects(finishedWork);
+        break;
+      case 12:
+        recursivelyTraversePassiveUnmountEffects(finishedWork);
+        break;
+      case 22:
+        var instance = finishedWork.stateNode;
+        null !== finishedWork.memoizedState && instance._visibility & 2 && (null === finishedWork.return || 13 !== finishedWork.return.tag) ? (instance._visibility &= -3, recursivelyTraverseDisconnectPassiveEffects(finishedWork)) : recursivelyTraversePassiveUnmountEffects(finishedWork);
+        break;
+      default:
+        recursivelyTraversePassiveUnmountEffects(finishedWork);
+    }
+  }
+  function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
+    var deletions = parentFiber.deletions;
+    if (0 !== (parentFiber.flags & 16)) {
+      if (null !== deletions) for (var i = 0; i < deletions.length; i++) {
+        var childToDelete = deletions[i];
+        nextEffect = childToDelete;
+        commitPassiveUnmountEffectsInsideOfDeletedTree_begin(childToDelete, parentFiber);
+      }
+      detachAlternateSiblings(parentFiber);
+    }
+    for (parentFiber = parentFiber.child; null !== parentFiber;) {
+      deletions = parentFiber;
+      switch (deletions.tag) {
+        case 0:
+        case 11:
+        case 15:
+          commitHookEffectListUnmount(8, deletions, deletions.return);
+          recursivelyTraverseDisconnectPassiveEffects(deletions);
+          break;
+        case 22:
+          i = deletions.stateNode;
+          i._visibility & 2 && (i._visibility &= -3, recursivelyTraverseDisconnectPassiveEffects(deletions));
+          break;
+        default:
+          recursivelyTraverseDisconnectPassiveEffects(deletions);
+      }
+      parentFiber = parentFiber.sibling;
+    }
+  }
+  function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(deletedSubtreeRoot, nearestMountedAncestor) {
+    for (; null !== nextEffect;) {
+      var fiber = nextEffect;
+      switch (fiber.tag) {
+        case 0:
+        case 11:
+        case 15:
+          commitHookEffectListUnmount(8, fiber, nearestMountedAncestor);
+          break;
+        case 23:
+        case 22:
+          if (null !== fiber.memoizedState && null !== fiber.memoizedState.cachePool) {
+            var cache = fiber.memoizedState.cachePool.pool;
+            null != cache && cache.refCount++;
+          }
+          break;
+        case 24:
+          releaseCache(fiber.memoizedState.cache);
+      }
+      cache = fiber.child;
+      if (null !== cache) cache.return = fiber, nextEffect = cache;else a: for (fiber = deletedSubtreeRoot; null !== nextEffect;) {
+        cache = nextEffect;
+        var sibling = cache.sibling,
+          returnFiber = cache.return;
+        detachFiberAfterEffects(cache);
+        if (cache === fiber) {
+          nextEffect = null;
+          break a;
+        }
+        if (null !== sibling) {
+          sibling.return = returnFiber;
+          nextEffect = sibling;
+          break a;
+        }
+        nextEffect = returnFiber;
+      }
+    }
+  }
+  var DefaultAsyncDispatcher = {
+      getCacheForType: function getCacheForType(resourceType) {
+        var cache = readContext(CacheContext),
+          cacheForType = cache.data.get(resourceType);
+        void 0 === cacheForType && (cacheForType = resourceType(), cache.data.set(resourceType, cacheForType));
+        return cacheForType;
+      }
+    },
+    PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map,
+    executionContext = 0,
+    workInProgressRoot = null,
+    workInProgress = null,
+    workInProgressRootRenderLanes = 0,
+    workInProgressSuspendedReason = 0,
+    workInProgressThrownValue = null,
+    workInProgressRootDidSkipSuspendedSiblings = !1,
+    workInProgressRootIsPrerendering = !1,
+    workInProgressRootDidAttachPingListener = !1,
+    entangledRenderLanes = 0,
+    workInProgressRootExitStatus = 0,
+    workInProgressRootSkippedLanes = 0,
+    workInProgressRootInterleavedUpdatedLanes = 0,
+    workInProgressRootPingedLanes = 0,
+    workInProgressDeferredLane = 0,
+    workInProgressSuspendedRetryLanes = 0,
+    workInProgressRootConcurrentErrors = null,
+    workInProgressRootRecoverableErrors = null,
+    workInProgressRootDidIncludeRecursiveRenderUpdate = !1,
+    globalMostRecentFallbackTime = 0,
+    workInProgressRootRenderTargetTime = Infinity,
+    workInProgressTransitions = null,
+    legacyErrorBoundariesThatAlreadyFailed = null,
+    pendingEffectsStatus = 0,
+    pendingEffectsRoot = null,
+    pendingFinishedWork = null,
+    pendingEffectsLanes = 0,
+    pendingEffectsRemainingLanes = 0,
+    pendingPassiveTransitions = null,
+    pendingRecoverableErrors = null,
+    nestedUpdateCount = 0,
+    rootWithNestedUpdates = null;
+  function requestUpdateLane(fiber) {
+    if (0 === (fiber.mode & 1)) return 2;
+    if (0 !== (executionContext & 2) && 0 !== workInProgressRootRenderLanes) return workInProgressRootRenderLanes & -workInProgressRootRenderLanes;
+    if (null !== ReactSharedInternals.T) return fiber = currentEntangledLane, 0 !== fiber ? fiber : requestTransitionLane();
+    fiber = 0 !== currentUpdatePriority ? currentUpdatePriority : 32;
+    return fiber;
+  }
+  function requestDeferredLane() {
+    0 === workInProgressDeferredLane && (workInProgressDeferredLane = 0 !== (workInProgressRootRenderLanes & 536870912) ? 536870912 : claimNextTransitionLane());
+    var suspenseHandler = suspenseHandlerStackCursor.current;
+    null !== suspenseHandler && (suspenseHandler.flags |= 32);
+    return workInProgressDeferredLane;
+  }
+  function scheduleUpdateOnFiber(root, fiber, lane) {
+    if (root === workInProgressRoot && (2 === workInProgressSuspendedReason || 9 === workInProgressSuspendedReason) || null !== root.cancelPendingCommit) prepareFreshStack(root, 0), markRootSuspended(root, workInProgressRootRenderLanes, workInProgressDeferredLane, !1);
+    markRootUpdated$1(root, lane);
+    if (0 === (executionContext & 2) || root !== workInProgressRoot) root === workInProgressRoot && (0 === (executionContext & 2) && (workInProgressRootInterleavedUpdatedLanes |= lane), 4 === workInProgressRootExitStatus && markRootSuspended(root, workInProgressRootRenderLanes, workInProgressDeferredLane, !1)), ensureRootIsScheduled(root), 2 === lane && 0 === executionContext && 0 === (fiber.mode & 1) && (workInProgressRootRenderTargetTime = _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_now() + 500, flushSyncWorkAcrossRoots_impl(0, !0));
+  }
+  function performWorkOnRoot(root$jscomp$0, lanes, forceSync) {
+    if (0 !== (executionContext & 6)) throw Error("Should not already be working.");
+    var shouldTimeSlice = !forceSync && 0 === (lanes & 124) && 0 === (lanes & root$jscomp$0.expiredLanes) || checkIfRootIsPrerendering(root$jscomp$0, lanes),
+      exitStatus = shouldTimeSlice ? renderRootConcurrent(root$jscomp$0, lanes) : renderRootSync(root$jscomp$0, lanes, !0),
+      renderWasConcurrent = shouldTimeSlice;
+    do {
+      if (0 === exitStatus) {
+        workInProgressRootIsPrerendering && !shouldTimeSlice && markRootSuspended(root$jscomp$0, lanes, 0, !1);
+        break;
+      } else {
+        forceSync = root$jscomp$0.current.alternate;
+        if (renderWasConcurrent && !isRenderConsistentWithExternalStores(forceSync)) {
+          exitStatus = renderRootSync(root$jscomp$0, lanes, !1);
+          renderWasConcurrent = !1;
+          continue;
+        }
+        if (0 !== root$jscomp$0.tag && 2 === exitStatus) {
+          renderWasConcurrent = lanes;
+          if (root$jscomp$0.errorRecoveryDisabledLanes & renderWasConcurrent) var JSCompiler_inline_result = 0;else JSCompiler_inline_result = root$jscomp$0.pendingLanes & -536870913, JSCompiler_inline_result = 0 !== JSCompiler_inline_result ? JSCompiler_inline_result : JSCompiler_inline_result & 536870912 ? 536870912 : 0;
+          if (0 !== JSCompiler_inline_result) {
+            lanes = JSCompiler_inline_result;
+            a: {
+              var root = root$jscomp$0;
+              exitStatus = workInProgressRootConcurrentErrors;
+              JSCompiler_inline_result = renderRootSync(root, JSCompiler_inline_result, !1);
+              if (2 !== JSCompiler_inline_result) {
+                if (workInProgressRootDidAttachPingListener) {
+                  root.errorRecoveryDisabledLanes |= renderWasConcurrent;
+                  workInProgressRootInterleavedUpdatedLanes |= renderWasConcurrent;
+                  exitStatus = 4;
+                  break a;
+                }
+                renderWasConcurrent = workInProgressRootRecoverableErrors;
+                workInProgressRootRecoverableErrors = exitStatus;
+                null !== renderWasConcurrent && (null === workInProgressRootRecoverableErrors ? workInProgressRootRecoverableErrors = renderWasConcurrent : workInProgressRootRecoverableErrors.push.apply(workInProgressRootRecoverableErrors, renderWasConcurrent));
+              }
+              exitStatus = JSCompiler_inline_result;
+            }
+            renderWasConcurrent = !1;
+            if (2 !== exitStatus) continue;
+          }
+        }
+        if (1 === exitStatus) {
+          prepareFreshStack(root$jscomp$0, 0);
+          markRootSuspended(root$jscomp$0, lanes, 0, !0);
+          break;
+        }
+        a: {
+          shouldTimeSlice = root$jscomp$0;
+          renderWasConcurrent = exitStatus;
+          switch (renderWasConcurrent) {
+            case 0:
+            case 1:
+              throw Error("Root did not complete. This is a bug in React.");
+            case 4:
+              if ((lanes & 4194048) !== lanes) break;
+            case 6:
+              markRootSuspended(shouldTimeSlice, lanes, workInProgressDeferredLane, !workInProgressRootDidSkipSuspendedSiblings);
+              break a;
+            case 2:
+              workInProgressRootRecoverableErrors = null;
+              break;
+            case 3:
+            case 5:
+              break;
+            default:
+              throw Error("Unknown root exit status.");
+          }
+          if ((lanes & 62914560) === lanes && 3 === renderWasConcurrent && (exitStatus = globalMostRecentFallbackTime + 300 - _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_now(), 10 < exitStatus)) {
+            markRootSuspended(shouldTimeSlice, lanes, workInProgressDeferredLane, !workInProgressRootDidSkipSuspendedSiblings);
+            if (0 !== getNextLanes(shouldTimeSlice, 0, !0)) break a;
+            shouldTimeSlice.timeoutHandle = scheduleTimeout(commitRootWhenReady.bind(null, shouldTimeSlice, forceSync, workInProgressRootRecoverableErrors, workInProgressTransitions, workInProgressRootDidIncludeRecursiveRenderUpdate, lanes, workInProgressDeferredLane, workInProgressRootInterleavedUpdatedLanes, workInProgressSuspendedRetryLanes, workInProgressRootDidSkipSuspendedSiblings, renderWasConcurrent, 2, -0, 0), exitStatus);
+            break a;
+          }
+          commitRootWhenReady(shouldTimeSlice, forceSync, workInProgressRootRecoverableErrors, workInProgressTransitions, workInProgressRootDidIncludeRecursiveRenderUpdate, lanes, workInProgressDeferredLane, workInProgressRootInterleavedUpdatedLanes, workInProgressSuspendedRetryLanes);
+        }
+      }
+      break;
+    } while (1);
+    ensureRootIsScheduled(root$jscomp$0);
+  }
+  function commitRootWhenReady(root, finishedWork, recoverableErrors, transitions, didIncludeRenderPhaseUpdate, lanes, spawnedLane, updatedLanes, suspendedRetryLanes) {
+    root.timeoutHandle = -1;
+    var subtreeFlags = finishedWork.subtreeFlags;
+    (subtreeFlags & 8192 || 16785408 === (subtreeFlags & 16785408)) && accumulateSuspenseyCommitOnFiber(finishedWork);
+    commitRoot(root, finishedWork, lanes, recoverableErrors, transitions, didIncludeRenderPhaseUpdate, spawnedLane, updatedLanes, suspendedRetryLanes);
+  }
+  function isRenderConsistentWithExternalStores(finishedWork) {
+    for (var node = finishedWork;;) {
+      var tag = node.tag;
+      if ((0 === tag || 11 === tag || 15 === tag) && node.flags & 16384 && (tag = node.updateQueue, null !== tag && (tag = tag.stores, null !== tag))) for (var i = 0; i < tag.length; i++) {
+        var check = tag[i],
+          getSnapshot = check.getSnapshot;
+        check = check.value;
+        try {
+          if (!objectIs(getSnapshot(), check)) return !1;
+        } catch (error) {
+          return !1;
+        }
+      }
+      tag = node.child;
+      if (node.subtreeFlags & 16384 && null !== tag) tag.return = node, node = tag;else {
+        if (node === finishedWork) break;
+        for (; null === node.sibling;) {
+          if (null === node.return || node.return === finishedWork) return !0;
+          node = node.return;
+        }
+        node.sibling.return = node.return;
+        node = node.sibling;
+      }
+    }
+    return !0;
+  }
+  function markRootSuspended(root, suspendedLanes, spawnedLane, didAttemptEntireTree) {
+    suspendedLanes &= ~workInProgressRootPingedLanes;
+    suspendedLanes &= ~workInProgressRootInterleavedUpdatedLanes;
+    root.suspendedLanes |= suspendedLanes;
+    root.pingedLanes &= ~suspendedLanes;
+    didAttemptEntireTree && (root.warmLanes |= suspendedLanes);
+    didAttemptEntireTree = root.expirationTimes;
+    for (var lanes = suspendedLanes; 0 < lanes;) {
+      var index$11 = 31 - clz32(lanes),
+        lane = 1 << index$11;
+      didAttemptEntireTree[index$11] = -1;
+      lanes &= ~lane;
+    }
+    0 !== spawnedLane && markSpawnedDeferredLane(root, spawnedLane, suspendedLanes);
+  }
+  function resetWorkInProgressStack() {
+    if (null !== workInProgress) {
+      if (0 === workInProgressSuspendedReason) var interruptedWork = workInProgress.return;else interruptedWork = workInProgress, lastContextDependency = currentlyRenderingFiber$1 = null, resetHooksOnUnwind(interruptedWork), thenableState = null, thenableIndexCounter = 0, interruptedWork = workInProgress;
+      for (; null !== interruptedWork;) unwindInterruptedWork(interruptedWork.alternate, interruptedWork), interruptedWork = interruptedWork.return;
+      workInProgress = null;
+    }
+  }
+  function prepareFreshStack(root, lanes) {
+    var timeoutHandle = root.timeoutHandle;
+    -1 !== timeoutHandle && (root.timeoutHandle = -1, cancelTimeout(timeoutHandle));
+    timeoutHandle = root.cancelPendingCommit;
+    null !== timeoutHandle && (root.cancelPendingCommit = null, timeoutHandle());
+    resetWorkInProgressStack();
+    workInProgressRoot = root;
+    workInProgress = timeoutHandle = createWorkInProgress(root.current, null);
+    workInProgressRootRenderLanes = lanes;
+    workInProgressSuspendedReason = 0;
+    workInProgressThrownValue = null;
+    workInProgressRootDidSkipSuspendedSiblings = !1;
+    workInProgressRootIsPrerendering = checkIfRootIsPrerendering(root, lanes);
+    workInProgressRootDidAttachPingListener = !1;
+    workInProgressSuspendedRetryLanes = workInProgressDeferredLane = workInProgressRootPingedLanes = workInProgressRootInterleavedUpdatedLanes = workInProgressRootSkippedLanes = workInProgressRootExitStatus = 0;
+    workInProgressRootRecoverableErrors = workInProgressRootConcurrentErrors = null;
+    workInProgressRootDidIncludeRecursiveRenderUpdate = !1;
+    0 !== (lanes & 8) && (lanes |= lanes & 32);
+    var allEntangledLanes = root.entangledLanes;
+    if (0 !== allEntangledLanes) for (root = root.entanglements, allEntangledLanes &= lanes; 0 < allEntangledLanes;) {
+      var index$9 = 31 - clz32(allEntangledLanes),
+        lane = 1 << index$9;
+      lanes |= root[index$9];
+      allEntangledLanes &= ~lane;
+    }
+    entangledRenderLanes = lanes;
+    finishQueueingConcurrentUpdates();
+    return timeoutHandle;
+  }
+  function handleThrow(root, thrownValue) {
+    currentlyRenderingFiber = null;
+    ReactSharedInternals.H = ContextOnlyDispatcher;
+    thrownValue === SuspenseException || thrownValue === SuspenseActionException ? (thrownValue = getSuspendedThenable(), workInProgressSuspendedReason = 3) : thrownValue === SuspenseyCommitException ? (thrownValue = getSuspendedThenable(), workInProgressSuspendedReason = 4) : workInProgressSuspendedReason = thrownValue === SelectiveHydrationException ? 8 : null !== thrownValue && "object" === typeof thrownValue && "function" === typeof thrownValue.then ? 6 : 1;
+    workInProgressThrownValue = thrownValue;
+    null === workInProgress && (workInProgressRootExitStatus = 1, logUncaughtError(root, createCapturedValueAtFiber(thrownValue, root.current)));
+  }
+  function pushDispatcher() {
+    var prevDispatcher = ReactSharedInternals.H;
+    ReactSharedInternals.H = ContextOnlyDispatcher;
+    return null === prevDispatcher ? ContextOnlyDispatcher : prevDispatcher;
+  }
+  function pushAsyncDispatcher() {
+    var prevAsyncDispatcher = ReactSharedInternals.A;
+    ReactSharedInternals.A = DefaultAsyncDispatcher;
+    return prevAsyncDispatcher;
+  }
+  function renderDidSuspendDelayIfPossible() {
+    workInProgressRootExitStatus = 4;
+    workInProgressRootDidSkipSuspendedSiblings || (workInProgressRootRenderLanes & 4194048) !== workInProgressRootRenderLanes && null !== suspenseHandlerStackCursor.current || (workInProgressRootIsPrerendering = !0);
+    0 === (workInProgressRootSkippedLanes & 134217727) && 0 === (workInProgressRootInterleavedUpdatedLanes & 134217727) || null === workInProgressRoot || markRootSuspended(workInProgressRoot, workInProgressRootRenderLanes, workInProgressDeferredLane, !1);
+  }
+  function renderRootSync(root, lanes, shouldYieldForPrerendering) {
+    var prevExecutionContext = executionContext;
+    executionContext |= 2;
+    var prevDispatcher = pushDispatcher(),
+      prevAsyncDispatcher = pushAsyncDispatcher();
+    if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) workInProgressTransitions = null, prepareFreshStack(root, lanes);
+    lanes = !1;
+    var exitStatus = workInProgressRootExitStatus;
+    a: do try {
+      if (0 !== workInProgressSuspendedReason && null !== workInProgress) {
+        var unitOfWork = workInProgress,
+          thrownValue = workInProgressThrownValue;
+        switch (workInProgressSuspendedReason) {
+          case 8:
+            resetWorkInProgressStack();
+            exitStatus = 6;
+            break a;
+          case 3:
+          case 2:
+          case 9:
+          case 6:
+            null === suspenseHandlerStackCursor.current && (lanes = !0);
+            var reason = workInProgressSuspendedReason;
+            workInProgressSuspendedReason = 0;
+            workInProgressThrownValue = null;
+            throwAndUnwindWorkLoop(root, unitOfWork, thrownValue, reason);
+            if (shouldYieldForPrerendering && workInProgressRootIsPrerendering) {
+              exitStatus = 0;
+              break a;
+            }
+            break;
+          default:
+            reason = workInProgressSuspendedReason, workInProgressSuspendedReason = 0, workInProgressThrownValue = null, throwAndUnwindWorkLoop(root, unitOfWork, thrownValue, reason);
+        }
+      }
+      workLoopSync();
+      exitStatus = workInProgressRootExitStatus;
+      break;
+    } catch (thrownValue$134) {
+      handleThrow(root, thrownValue$134);
+    } while (1);
+    lanes && root.shellSuspendCounter++;
+    lastContextDependency = currentlyRenderingFiber$1 = null;
+    executionContext = prevExecutionContext;
+    ReactSharedInternals.H = prevDispatcher;
+    ReactSharedInternals.A = prevAsyncDispatcher;
+    null === workInProgress && (workInProgressRoot = null, workInProgressRootRenderLanes = 0, finishQueueingConcurrentUpdates());
+    return exitStatus;
+  }
+  function workLoopSync() {
+    for (; null !== workInProgress;) performUnitOfWork(workInProgress);
+  }
+  function renderRootConcurrent(root, lanes) {
+    var prevExecutionContext = executionContext;
+    executionContext |= 2;
+    var prevDispatcher = pushDispatcher(),
+      prevAsyncDispatcher = pushAsyncDispatcher();
+    workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes ? (workInProgressTransitions = null, workInProgressRootRenderTargetTime = _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_now() + 500, prepareFreshStack(root, lanes)) : workInProgressRootIsPrerendering = checkIfRootIsPrerendering(root, lanes);
+    a: do try {
+      if (0 !== workInProgressSuspendedReason && null !== workInProgress) {
+        lanes = workInProgress;
+        var thrownValue = workInProgressThrownValue;
+        b: switch (workInProgressSuspendedReason) {
+          case 1:
+            workInProgressSuspendedReason = 0;
+            workInProgressThrownValue = null;
+            throwAndUnwindWorkLoop(root, lanes, thrownValue, 1);
+            break;
+          case 2:
+          case 9:
+            if (isThenableResolved(thrownValue)) {
+              workInProgressSuspendedReason = 0;
+              workInProgressThrownValue = null;
+              replaySuspendedUnitOfWork(lanes);
+              break;
+            }
+            lanes = function lanes() {
+              2 !== workInProgressSuspendedReason && 9 !== workInProgressSuspendedReason || workInProgressRoot !== root || (workInProgressSuspendedReason = 7);
+              ensureRootIsScheduled(root);
+            };
+            thrownValue.then(lanes, lanes);
+            break a;
+          case 3:
+            workInProgressSuspendedReason = 7;
+            break a;
+          case 4:
+            workInProgressSuspendedReason = 5;
+            break a;
+          case 7:
+            isThenableResolved(thrownValue) ? (workInProgressSuspendedReason = 0, workInProgressThrownValue = null, replaySuspendedUnitOfWork(lanes)) : (workInProgressSuspendedReason = 0, workInProgressThrownValue = null, throwAndUnwindWorkLoop(root, lanes, thrownValue, 7));
+            break;
+          case 5:
+            var resource = null;
+            switch (workInProgress.tag) {
+              case 26:
+                resource = workInProgress.memoizedState;
+              case 5:
+              case 27:
+                var hostFiber = workInProgress;
+                if (resource ? shim(resource) : 1) {
+                  workInProgressSuspendedReason = 0;
+                  workInProgressThrownValue = null;
+                  var sibling = hostFiber.sibling;
+                  if (null !== sibling) workInProgress = sibling;else {
+                    var returnFiber = hostFiber.return;
+                    null !== returnFiber ? (workInProgress = returnFiber, completeUnitOfWork(returnFiber)) : workInProgress = null;
+                  }
+                  break b;
+                }
+            }
+            workInProgressSuspendedReason = 0;
+            workInProgressThrownValue = null;
+            throwAndUnwindWorkLoop(root, lanes, thrownValue, 5);
+            break;
+          case 6:
+            workInProgressSuspendedReason = 0;
+            workInProgressThrownValue = null;
+            throwAndUnwindWorkLoop(root, lanes, thrownValue, 6);
+            break;
+          case 8:
+            resetWorkInProgressStack();
+            workInProgressRootExitStatus = 6;
+            break a;
+          default:
+            throw Error("Unexpected SuspendedReason. This is a bug in React.");
+        }
+      }
+      workLoopConcurrentByScheduler();
+      break;
+    } catch (thrownValue$136) {
+      handleThrow(root, thrownValue$136);
+    } while (1);
+    lastContextDependency = currentlyRenderingFiber$1 = null;
+    ReactSharedInternals.H = prevDispatcher;
+    ReactSharedInternals.A = prevAsyncDispatcher;
+    executionContext = prevExecutionContext;
+    if (null !== workInProgress) return 0;
+    workInProgressRoot = null;
+    workInProgressRootRenderLanes = 0;
+    finishQueueingConcurrentUpdates();
+    return workInProgressRootExitStatus;
+  }
+  function workLoopConcurrentByScheduler() {
+    for (; null !== workInProgress && !_$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_shouldYield();) performUnitOfWork(workInProgress);
+  }
+  function performUnitOfWork(unitOfWork) {
+    var next = beginWork(unitOfWork.alternate, unitOfWork, entangledRenderLanes);
+    unitOfWork.memoizedProps = unitOfWork.pendingProps;
+    null === next ? completeUnitOfWork(unitOfWork) : workInProgress = next;
+  }
+  function replaySuspendedUnitOfWork(unitOfWork) {
+    var next = unitOfWork;
+    var current = next.alternate;
+    switch (next.tag) {
+      case 15:
+      case 0:
+        next = replayFunctionComponent(current, next, next.pendingProps, next.type, void 0, workInProgressRootRenderLanes);
+        break;
+      case 11:
+        next = replayFunctionComponent(current, next, next.pendingProps, next.type.render, next.ref, workInProgressRootRenderLanes);
+        break;
+      case 5:
+        resetHooksOnUnwind(next);
+      default:
+        unwindInterruptedWork(current, next), next = workInProgress = resetWorkInProgress(next, entangledRenderLanes), next = beginWork(current, next, entangledRenderLanes);
+    }
+    unitOfWork.memoizedProps = unitOfWork.pendingProps;
+    null === next ? completeUnitOfWork(unitOfWork) : workInProgress = next;
+  }
+  function throwAndUnwindWorkLoop(root, unitOfWork, thrownValue, suspendedReason) {
+    lastContextDependency = currentlyRenderingFiber$1 = null;
+    resetHooksOnUnwind(unitOfWork);
+    thenableState = null;
+    thenableIndexCounter = 0;
+    var returnFiber = unitOfWork.return;
+    try {
+      if (throwException(root, returnFiber, unitOfWork, thrownValue, workInProgressRootRenderLanes)) {
+        workInProgressRootExitStatus = 1;
+        logUncaughtError(root, createCapturedValueAtFiber(thrownValue, root.current));
+        workInProgress = null;
+        return;
+      }
+    } catch (error) {
+      if (null !== returnFiber) throw workInProgress = returnFiber, error;
+      workInProgressRootExitStatus = 1;
+      logUncaughtError(root, createCapturedValueAtFiber(thrownValue, root.current));
+      workInProgress = null;
+      return;
+    }
+    if (unitOfWork.flags & 32768) {
+      if (1 === suspendedReason) root = !0;else if (workInProgressRootIsPrerendering || 0 !== (workInProgressRootRenderLanes & 536870912)) root = !1;else if (workInProgressRootDidSkipSuspendedSiblings = root = !0, 2 === suspendedReason || 9 === suspendedReason || 3 === suspendedReason || 6 === suspendedReason) suspendedReason = suspenseHandlerStackCursor.current, null !== suspendedReason && 13 === suspendedReason.tag && (suspendedReason.flags |= 16384);
+      unwindUnitOfWork(unitOfWork, root);
+    } else completeUnitOfWork(unitOfWork);
+  }
+  function completeUnitOfWork(unitOfWork) {
+    var completedWork = unitOfWork;
+    do {
+      if (0 !== (completedWork.flags & 32768)) {
+        unwindUnitOfWork(completedWork, workInProgressRootDidSkipSuspendedSiblings);
+        return;
+      }
+      unitOfWork = completedWork.return;
+      var next = completeWork(completedWork.alternate, completedWork, entangledRenderLanes);
+      if (null !== next) {
+        workInProgress = next;
+        return;
+      }
+      completedWork = completedWork.sibling;
+      if (null !== completedWork) {
+        workInProgress = completedWork;
+        return;
+      }
+      workInProgress = completedWork = unitOfWork;
+    } while (null !== completedWork);
+    0 === workInProgressRootExitStatus && (workInProgressRootExitStatus = 5);
+  }
+  function unwindUnitOfWork(unitOfWork, skipSiblings) {
+    do {
+      var next = unwindWork(unitOfWork.alternate, unitOfWork);
+      if (null !== next) {
+        next.flags &= 32767;
+        workInProgress = next;
+        return;
+      }
+      next = unitOfWork.return;
+      null !== next && (next.flags |= 32768, next.subtreeFlags = 0, next.deletions = null);
+      if (!skipSiblings && (unitOfWork = unitOfWork.sibling, null !== unitOfWork)) {
+        workInProgress = unitOfWork;
+        return;
+      }
+      workInProgress = unitOfWork = next;
+    } while (null !== unitOfWork);
+    workInProgressRootExitStatus = 6;
+    workInProgress = null;
+  }
+  function commitRoot(root, finishedWork, lanes, recoverableErrors, transitions, didIncludeRenderPhaseUpdate, spawnedLane, updatedLanes, suspendedRetryLanes) {
+    root.cancelPendingCommit = null;
+    do flushPendingEffects(); while (0 !== pendingEffectsStatus);
+    if (0 !== (executionContext & 6)) throw Error("Should not already be working.");
+    if (null !== finishedWork) {
+      if (finishedWork === root.current) throw Error("Cannot commit the same tree as before. This error is likely caused by a bug in React. Please file an issue.");
+      didIncludeRenderPhaseUpdate = finishedWork.lanes | finishedWork.childLanes;
+      didIncludeRenderPhaseUpdate |= concurrentlyUpdatedLanes;
+      markRootFinished(root, lanes, didIncludeRenderPhaseUpdate, spawnedLane, updatedLanes, suspendedRetryLanes);
+      root === workInProgressRoot && (workInProgress = workInProgressRoot = null, workInProgressRootRenderLanes = 0);
+      pendingFinishedWork = finishedWork;
+      pendingEffectsRoot = root;
+      pendingEffectsLanes = lanes;
+      pendingEffectsRemainingLanes = didIncludeRenderPhaseUpdate;
+      pendingPassiveTransitions = transitions;
+      pendingRecoverableErrors = recoverableErrors;
+      0 !== (finishedWork.subtreeFlags & 10256) || 0 !== (finishedWork.flags & 10256) ? (root.callbackNode = null, root.callbackPriority = 0, scheduleCallback(_$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_NormalPriority, function () {
+        flushPassiveEffects(!0);
+        return null;
+      })) : (root.callbackNode = null, root.callbackPriority = 0);
+      recoverableErrors = 0 !== (finishedWork.flags & 13878);
+      if (0 !== (finishedWork.subtreeFlags & 13878) || recoverableErrors) {
+        recoverableErrors = ReactSharedInternals.T;
+        ReactSharedInternals.T = null;
+        transitions = currentUpdatePriority;
+        currentUpdatePriority = 2;
+        spawnedLane = executionContext;
+        executionContext |= 4;
+        try {
+          commitBeforeMutationEffects(root, finishedWork, lanes);
+        } finally {
+          executionContext = spawnedLane, currentUpdatePriority = transitions, ReactSharedInternals.T = recoverableErrors;
+        }
+      }
+      pendingEffectsStatus = 1;
+      flushMutationEffects();
+      flushLayoutEffects();
+      flushSpawnedWork();
+    }
+  }
+  function flushMutationEffects() {
+    if (1 === pendingEffectsStatus) {
+      pendingEffectsStatus = 0;
+      var root = pendingEffectsRoot,
+        finishedWork = pendingFinishedWork,
+        rootMutationHasEffect = 0 !== (finishedWork.flags & 13878);
+      if (0 !== (finishedWork.subtreeFlags & 13878) || rootMutationHasEffect) {
+        rootMutationHasEffect = ReactSharedInternals.T;
+        ReactSharedInternals.T = null;
+        var previousPriority = currentUpdatePriority;
+        currentUpdatePriority = 2;
+        var prevExecutionContext = executionContext;
+        executionContext |= 4;
+        try {
+          commitMutationEffectsOnFiber(finishedWork, root);
+        } finally {
+          executionContext = prevExecutionContext, currentUpdatePriority = previousPriority, ReactSharedInternals.T = rootMutationHasEffect;
+        }
+      }
+      root.current = finishedWork;
+      pendingEffectsStatus = 2;
+    }
+  }
+  function flushLayoutEffects() {
+    if (2 === pendingEffectsStatus) {
+      pendingEffectsStatus = 0;
+      var root = pendingEffectsRoot,
+        finishedWork = pendingFinishedWork,
+        rootHasLayoutEffect = 0 !== (finishedWork.flags & 8772);
+      if (0 !== (finishedWork.subtreeFlags & 8772) || rootHasLayoutEffect) {
+        rootHasLayoutEffect = ReactSharedInternals.T;
+        ReactSharedInternals.T = null;
+        var previousPriority = currentUpdatePriority;
+        currentUpdatePriority = 2;
+        var prevExecutionContext = executionContext;
+        executionContext |= 4;
+        try {
+          commitLayoutEffectOnFiber(root, finishedWork.alternate, finishedWork);
+        } finally {
+          executionContext = prevExecutionContext, currentUpdatePriority = previousPriority, ReactSharedInternals.T = rootHasLayoutEffect;
+        }
+      }
+      pendingEffectsStatus = 3;
+    }
+  }
+  function flushSpawnedWork() {
+    if (4 === pendingEffectsStatus || 3 === pendingEffectsStatus) {
+      pendingEffectsStatus = 0;
+      _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_requestPaint();
+      var root = pendingEffectsRoot,
+        finishedWork = pendingFinishedWork,
+        lanes = pendingEffectsLanes,
+        recoverableErrors = pendingRecoverableErrors;
+      0 !== (finishedWork.subtreeFlags & 10256) || 0 !== (finishedWork.flags & 10256) ? pendingEffectsStatus = 5 : (pendingEffectsStatus = 0, pendingFinishedWork = pendingEffectsRoot = null, releaseRootPooledCache(root, root.pendingLanes));
+      var remainingLanes = root.pendingLanes;
+      0 === remainingLanes && (legacyErrorBoundariesThatAlreadyFailed = null);
+      lanesToEventPriority(lanes);
+      finishedWork = finishedWork.stateNode;
+      if (injectedHook && "function" === typeof injectedHook.onCommitFiberRoot) try {
+        injectedHook.onCommitFiberRoot(rendererID, finishedWork, void 0, 128 === (finishedWork.current.flags & 128));
+      } catch (err) {}
+      if (null !== recoverableErrors) {
+        finishedWork = ReactSharedInternals.T;
+        remainingLanes = currentUpdatePriority;
+        currentUpdatePriority = 2;
+        ReactSharedInternals.T = null;
+        try {
+          for (var onRecoverableError = root.onRecoverableError, i = 0; i < recoverableErrors.length; i++) {
+            var recoverableError = recoverableErrors[i];
+            onRecoverableError(recoverableError.value, {
+              componentStack: recoverableError.stack
+            });
+          }
+        } finally {
+          ReactSharedInternals.T = finishedWork, currentUpdatePriority = remainingLanes;
+        }
+      }
+      0 !== (pendingEffectsLanes & 3) && 0 !== root.tag && flushPendingEffects();
+      ensureRootIsScheduled(root);
+      remainingLanes = root.pendingLanes;
+      0 !== (lanes & 4194090) && 0 !== (remainingLanes & 42) ? root === rootWithNestedUpdates ? nestedUpdateCount++ : (nestedUpdateCount = 0, rootWithNestedUpdates = root) : nestedUpdateCount = 0;
+      flushSyncWorkAcrossRoots_impl(0, !1);
+    }
+  }
+  function releaseRootPooledCache(root, remainingLanes) {
+    0 === (root.pooledCacheLanes &= remainingLanes) && (remainingLanes = root.pooledCache, null != remainingLanes && (root.pooledCache = null, releaseCache(remainingLanes)));
+  }
+  function flushPendingEffects(wasDelayedCommit) {
+    flushMutationEffects();
+    flushLayoutEffects();
+    flushSpawnedWork();
+    return flushPassiveEffects(wasDelayedCommit);
+  }
+  function flushPassiveEffects() {
+    if (5 !== pendingEffectsStatus) return !1;
+    var root = pendingEffectsRoot,
+      remainingLanes = pendingEffectsRemainingLanes;
+    pendingEffectsRemainingLanes = 0;
+    var renderPriority = lanesToEventPriority(pendingEffectsLanes),
+      prevTransition = ReactSharedInternals.T,
+      previousPriority = currentUpdatePriority;
+    try {
+      currentUpdatePriority = 32 > renderPriority ? 32 : renderPriority;
+      ReactSharedInternals.T = null;
+      renderPriority = pendingPassiveTransitions;
+      pendingPassiveTransitions = null;
+      var root$jscomp$0 = pendingEffectsRoot,
+        lanes = pendingEffectsLanes;
+      pendingEffectsStatus = 0;
+      pendingFinishedWork = pendingEffectsRoot = null;
+      pendingEffectsLanes = 0;
+      if (0 !== (executionContext & 6)) throw Error("Cannot flush passive effects while already rendering.");
+      var prevExecutionContext = executionContext;
+      executionContext |= 4;
+      commitPassiveUnmountOnFiber(root$jscomp$0.current);
+      commitPassiveMountOnFiber(root$jscomp$0, root$jscomp$0.current, lanes, renderPriority);
+      executionContext = prevExecutionContext;
+      flushSyncWorkAcrossRoots_impl(0, !1);
+      if (injectedHook && "function" === typeof injectedHook.onPostCommitFiberRoot) try {
+        injectedHook.onPostCommitFiberRoot(rendererID, root$jscomp$0);
+      } catch (err) {}
+      return !0;
+    } finally {
+      currentUpdatePriority = previousPriority, ReactSharedInternals.T = prevTransition, releaseRootPooledCache(root, remainingLanes);
+    }
+  }
+  function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
+    sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
+    sourceFiber = createRootErrorUpdate(rootFiber.stateNode, sourceFiber, 2);
+    rootFiber = enqueueUpdate(rootFiber, sourceFiber, 2);
+    null !== rootFiber && (markRootUpdated$1(rootFiber, 2), ensureRootIsScheduled(rootFiber));
+  }
+  function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {
+    if (3 === sourceFiber.tag) captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);else for (; null !== nearestMountedAncestor;) {
+      if (3 === nearestMountedAncestor.tag) {
+        captureCommitPhaseErrorOnRoot(nearestMountedAncestor, sourceFiber, error);
+        break;
+      } else if (1 === nearestMountedAncestor.tag) {
+        var instance = nearestMountedAncestor.stateNode;
+        if ("function" === typeof nearestMountedAncestor.type.getDerivedStateFromError || "function" === typeof instance.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(instance))) {
+          sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
+          error = createClassErrorUpdate(2);
+          instance = enqueueUpdate(nearestMountedAncestor, error, 2);
+          null !== instance && (initializeClassErrorUpdate(error, instance, nearestMountedAncestor, sourceFiber), markRootUpdated$1(instance, 2), ensureRootIsScheduled(instance));
+          break;
+        }
+      }
+      nearestMountedAncestor = nearestMountedAncestor.return;
+    }
+  }
+  function attachPingListener(root, wakeable, lanes) {
+    var pingCache = root.pingCache;
+    if (null === pingCache) {
+      pingCache = root.pingCache = new PossiblyWeakMap();
+      var threadIDs = new Set();
+      pingCache.set(wakeable, threadIDs);
+    } else threadIDs = pingCache.get(wakeable), void 0 === threadIDs && (threadIDs = new Set(), pingCache.set(wakeable, threadIDs));
+    threadIDs.has(lanes) || (workInProgressRootDidAttachPingListener = !0, threadIDs.add(lanes), root = pingSuspendedRoot.bind(null, root, wakeable, lanes), wakeable.then(root, root));
+  }
+  function pingSuspendedRoot(root, wakeable, pingedLanes) {
+    var pingCache = root.pingCache;
+    null !== pingCache && pingCache.delete(wakeable);
+    root.pingedLanes |= root.suspendedLanes & pingedLanes;
+    root.warmLanes &= ~pingedLanes;
+    workInProgressRoot === root && (workInProgressRootRenderLanes & pingedLanes) === pingedLanes && (4 === workInProgressRootExitStatus || 3 === workInProgressRootExitStatus && (workInProgressRootRenderLanes & 62914560) === workInProgressRootRenderLanes && 300 > _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_now() - globalMostRecentFallbackTime ? 0 === (executionContext & 2) && prepareFreshStack(root, 0) : workInProgressRootPingedLanes |= pingedLanes, workInProgressSuspendedRetryLanes === workInProgressRootRenderLanes && (workInProgressSuspendedRetryLanes = 0));
+    ensureRootIsScheduled(root);
+  }
+  function retryTimedOutBoundary(boundaryFiber, retryLane) {
+    0 === retryLane && (retryLane = 0 === (boundaryFiber.mode & 1) ? 2 : claimNextRetryLane());
+    boundaryFiber = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
+    null !== boundaryFiber && (markRootUpdated$1(boundaryFiber, retryLane), ensureRootIsScheduled(boundaryFiber));
+  }
+  function retryDehydratedSuspenseBoundary(boundaryFiber) {
+    var suspenseState = boundaryFiber.memoizedState,
+      retryLane = 0;
+    null !== suspenseState && (retryLane = suspenseState.retryLane);
+    retryTimedOutBoundary(boundaryFiber, retryLane);
+  }
+  function resolveRetryWakeable(boundaryFiber, wakeable) {
+    var retryLane = 0;
+    switch (boundaryFiber.tag) {
+      case 13:
+        var retryCache = boundaryFiber.stateNode;
+        var suspenseState = boundaryFiber.memoizedState;
+        null !== suspenseState && (retryLane = suspenseState.retryLane);
+        break;
+      case 19:
+        retryCache = boundaryFiber.stateNode;
+        break;
+      case 22:
+        retryCache = boundaryFiber.stateNode._retryCache;
+        break;
+      default:
+        throw Error("Pinged unknown suspense boundary type. This is probably a bug in React.");
+    }
+    null !== retryCache && retryCache.delete(wakeable);
+    retryTimedOutBoundary(boundaryFiber, retryLane);
+  }
+  function scheduleCallback(priorityLevel, callback) {
+    return _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_scheduleCallback(priorityLevel, callback);
+  }
+  function FiberNode(tag, pendingProps, key, mode) {
+    this.tag = tag;
+    this.key = key;
+    this.sibling = this.child = this.return = this.stateNode = this.type = this.elementType = null;
+    this.index = 0;
+    this.refCleanup = this.ref = null;
+    this.pendingProps = pendingProps;
+    this.dependencies = this.memoizedState = this.updateQueue = this.memoizedProps = null;
+    this.mode = mode;
+    this.subtreeFlags = this.flags = 0;
+    this.deletions = null;
+    this.childLanes = this.lanes = 0;
+    this.alternate = null;
+  }
+  function createFiberImplClass(tag, pendingProps, key, mode) {
+    return new FiberNode(tag, pendingProps, key, mode);
+  }
+  function shouldConstruct(Component) {
+    Component = Component.prototype;
+    return !(!Component || !Component.isReactComponent);
+  }
+  function createWorkInProgress(current, pendingProps) {
+    var workInProgress = current.alternate;
+    null === workInProgress ? (workInProgress = createFiberImplClass(current.tag, pendingProps, current.key, current.mode), workInProgress.elementType = current.elementType, workInProgress.type = current.type, workInProgress.stateNode = current.stateNode, workInProgress.alternate = current, current.alternate = workInProgress) : (workInProgress.pendingProps = pendingProps, workInProgress.type = current.type, workInProgress.flags = 0, workInProgress.subtreeFlags = 0, workInProgress.deletions = null);
+    workInProgress.flags = current.flags & 65011712;
+    workInProgress.childLanes = current.childLanes;
+    workInProgress.lanes = current.lanes;
+    workInProgress.child = current.child;
+    workInProgress.memoizedProps = current.memoizedProps;
+    workInProgress.memoizedState = current.memoizedState;
+    workInProgress.updateQueue = current.updateQueue;
+    pendingProps = current.dependencies;
+    workInProgress.dependencies = null === pendingProps ? null : {
+      lanes: pendingProps.lanes,
+      firstContext: pendingProps.firstContext
+    };
+    workInProgress.sibling = current.sibling;
+    workInProgress.index = current.index;
+    workInProgress.ref = current.ref;
+    workInProgress.refCleanup = current.refCleanup;
+    return workInProgress;
+  }
+  function resetWorkInProgress(workInProgress, renderLanes) {
+    workInProgress.flags &= 65011714;
+    var current = workInProgress.alternate;
+    null === current ? (workInProgress.childLanes = 0, workInProgress.lanes = renderLanes, workInProgress.child = null, workInProgress.subtreeFlags = 0, workInProgress.memoizedProps = null, workInProgress.memoizedState = null, workInProgress.updateQueue = null, workInProgress.dependencies = null, workInProgress.stateNode = null) : (workInProgress.childLanes = current.childLanes, workInProgress.lanes = current.lanes, workInProgress.child = current.child, workInProgress.subtreeFlags = 0, workInProgress.deletions = null, workInProgress.memoizedProps = current.memoizedProps, workInProgress.memoizedState = current.memoizedState, workInProgress.updateQueue = current.updateQueue, workInProgress.type = current.type, renderLanes = current.dependencies, workInProgress.dependencies = null === renderLanes ? null : {
+      lanes: renderLanes.lanes,
+      firstContext: renderLanes.firstContext
+    });
+    return workInProgress;
+  }
+  function createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, lanes) {
+    var fiberTag = 0;
+    owner = type;
+    if ("function" === typeof type) shouldConstruct(type) && (fiberTag = 1);else if ("string" === typeof type) fiberTag = 5;else a: switch (type) {
+      case REACT_ACTIVITY_TYPE:
+        return type = createFiberImplClass(31, pendingProps, key, mode), type.elementType = REACT_ACTIVITY_TYPE, type.lanes = lanes, type;
+      case REACT_FRAGMENT_TYPE:
+        return createFiberFromFragment(pendingProps.children, mode, lanes, key);
+      case REACT_STRICT_MODE_TYPE:
+        fiberTag = 8;
+        mode |= 8;
+        0 !== (mode & 1) && (mode |= 16);
+        break;
+      case REACT_PROFILER_TYPE:
+        return type = createFiberImplClass(12, pendingProps, key, mode | 2), type.elementType = REACT_PROFILER_TYPE, type.lanes = lanes, type;
+      case REACT_SUSPENSE_TYPE:
+        return type = createFiberImplClass(13, pendingProps, key, mode), type.elementType = REACT_SUSPENSE_TYPE, type.lanes = lanes, type;
+      case REACT_SUSPENSE_LIST_TYPE:
+        return type = createFiberImplClass(19, pendingProps, key, mode), type.elementType = REACT_SUSPENSE_LIST_TYPE, type.lanes = lanes, type;
+      default:
+        if ("object" === typeof type && null !== type) switch (type.$$typeof) {
+          case REACT_PROVIDER_TYPE:
+          case REACT_CONTEXT_TYPE:
+            fiberTag = 10;
+            break a;
+          case REACT_CONSUMER_TYPE:
+            fiberTag = 9;
+            break a;
+          case REACT_FORWARD_REF_TYPE:
+            fiberTag = 11;
+            break a;
+          case REACT_MEMO_TYPE:
+            fiberTag = 14;
+            break a;
+          case REACT_LAZY_TYPE:
+            fiberTag = 16;
+            owner = null;
+            break a;
+        }
+        fiberTag = 29;
+        pendingProps = Error("Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: " + ((null === type ? "null" : typeof type) + "."));
+        owner = null;
+    }
+    key = createFiberImplClass(fiberTag, pendingProps, key, mode);
+    key.elementType = type;
+    key.type = owner;
+    key.lanes = lanes;
+    return key;
+  }
+  function createFiberFromFragment(elements, mode, lanes, key) {
+    elements = createFiberImplClass(7, elements, key, mode);
+    elements.lanes = lanes;
+    return elements;
+  }
+  function createFiberFromText(content, mode, lanes) {
+    content = createFiberImplClass(6, content, null, mode);
+    content.lanes = lanes;
+    return content;
+  }
+  function createFiberFromPortal(portal, mode, lanes) {
+    mode = createFiberImplClass(4, null !== portal.children ? portal.children : [], portal.key, mode);
+    mode.lanes = lanes;
+    mode.stateNode = {
+      containerInfo: portal.containerInfo,
+      pendingChildren: null,
+      implementation: portal.implementation
+    };
+    return mode;
+  }
+  function FiberRootNode(containerInfo, tag, hydrate, identifierPrefix, onUncaughtError, onCaughtError, onRecoverableError, formState) {
+    this.tag = tag;
+    this.containerInfo = containerInfo;
+    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 = createLaneMap(-1);
+    this.entangledLanes = this.shellSuspendCounter = this.errorRecoveryDisabledLanes = this.expiredLanes = this.warmLanes = this.pingedLanes = this.suspendedLanes = this.pendingLanes = 0;
+    this.entanglements = createLaneMap(0);
+    this.hiddenUpdates = createLaneMap(null);
+    this.identifierPrefix = identifierPrefix;
+    this.onUncaughtError = onUncaughtError;
+    this.onCaughtError = onCaughtError;
+    this.onRecoverableError = onRecoverableError;
+    this.pooledCache = null;
+    this.pooledCacheLanes = 0;
+    this.formState = formState;
+    this.incompleteTransitions = new Map();
+  }
+  function createPortal$1(children, containerInfo, implementation) {
+    var key = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
+    return {
+      $$typeof: REACT_PORTAL_TYPE,
+      key: null == key ? null : "" + key,
+      children: children,
+      containerInfo: containerInfo,
+      implementation: implementation
+    };
+  }
+  function findHostInstance(component) {
+    var fiber = component._reactInternals;
+    if (void 0 === fiber) {
+      if ("function" === typeof component.render) throw Error("Unable to find node on an unmounted component.");
+      component = Object.keys(component).join(",");
+      throw Error("Argument appears to not be a ReactComponent. Keys: " + component);
+    }
+    component = findCurrentFiberUsingSlowPath(fiber);
+    component = null !== component ? findCurrentHostFiberImpl(component) : null;
+    return null === component ? null : getPublicInstance(component.stateNode);
+  }
+  function updateContainer(element, container, parentComponent, callback) {
+    parentComponent = container.current;
+    var lane = requestUpdateLane(parentComponent);
+    null === container.context ? container.context = emptyContextObject : container.pendingContext = emptyContextObject;
+    container = createUpdate(lane);
+    container.payload = {
+      element: element
+    };
+    callback = void 0 === callback ? null : callback;
+    null !== callback && (container.callback = callback);
+    element = enqueueUpdate(parentComponent, container, lane);
+    null !== element && (scheduleUpdateOnFiber(element, parentComponent, lane), entangleTransitions(element, parentComponent, lane));
+    return lane;
+  }
+  var isomorphicReactPackageVersion = React.version;
+  if ("19.1.0" !== isomorphicReactPackageVersion) throw Error('Incompatible React versions: The "react" and "react-native-renderer" packages must have the exact same version. Instead got:\n  - react:                  ' + (isomorphicReactPackageVersion + "\n  - react-native-renderer:  19.1.0\nLearn more: https://react.dev/warnings/version-mismatch"));
+  if ("function" !== typeof _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").ReactFiberErrorDialog.showErrorDialog) throw Error("Expected ReactFiberErrorDialog.showErrorDialog to be a function.");
+  function nativeOnUncaughtError(error, errorInfo) {
+    !1 !== _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").ReactFiberErrorDialog.showErrorDialog({
+      errorBoundary: null,
+      error: error,
+      componentStack: null != errorInfo.componentStack ? errorInfo.componentStack : ""
+    }) && reportGlobalError(error);
+  }
+  function nativeOnCaughtError(error, errorInfo) {
+    !1 !== _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").ReactFiberErrorDialog.showErrorDialog({
+      errorBoundary: errorInfo.errorBoundary,
+      error: error,
+      componentStack: null != errorInfo.componentStack ? errorInfo.componentStack : ""
+    }) && console.error(error);
+  }
+  function unmountComponentAtNode(containerTag) {
+    var root = roots.get(containerTag);
+    root && updateContainer(null, root, null, function () {
+      roots.delete(containerTag);
+    });
+  }
+  batchedUpdatesImpl = function batchedUpdatesImpl(fn, a) {
+    var prevExecutionContext = executionContext;
+    executionContext |= 1;
+    try {
+      return fn(a);
+    } finally {
+      executionContext = prevExecutionContext, 0 === executionContext && (workInProgressRootRenderTargetTime = _$$_REQUIRE(_dependencyMap[3], "scheduler").unstable_now() + 500, flushSyncWorkAcrossRoots_impl(0, !0));
+    }
+  };
+  var roots = new Map(),
+    internals$jscomp$inline_1269 = {
+      bundleType: 0,
+      version: "19.1.0",
+      rendererPackageName: "react-native-renderer",
+      currentDispatcherRef: ReactSharedInternals,
+      reconcilerVersion: "19.1.0"
+    };
+  null !== extraDevToolsConfig && (internals$jscomp$inline_1269.rendererConfig = extraDevToolsConfig);
+  if ("undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) {
+    var hook$jscomp$inline_1605 = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+    if (!hook$jscomp$inline_1605.isDisabled && hook$jscomp$inline_1605.supportsFiber) try {
+      rendererID = hook$jscomp$inline_1605.inject(internals$jscomp$inline_1269), injectedHook = hook$jscomp$inline_1605;
+    } catch (err) {}
+  }
+  exports.createPortal = function (children, containerTag) {
+    return createPortal$1(children, containerTag, null, 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null);
+  };
+  exports.dispatchCommand = function (handle, command, args) {
+    var nativeTag = null != handle._nativeTag ? handle._nativeTag : _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").getNativeTagFromPublicInstance(handle);
+    null != nativeTag && (handle = _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").getNodeFromPublicInstance(handle), null != handle ? nativeFabricUIManager.dispatchCommand(handle, command, args) : _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").UIManager.dispatchViewManagerCommand(nativeTag, command, args));
+  };
+  exports.findHostInstance_DEPRECATED = function (componentOrHandle) {
+    return null == componentOrHandle ? null : componentOrHandle.canonical && componentOrHandle.canonical.publicInstance ? componentOrHandle.canonical.publicInstance : componentOrHandle._nativeTag ? componentOrHandle : findHostInstance(componentOrHandle);
+  };
+  exports.findNodeHandle = function (componentOrHandle) {
+    if (null == componentOrHandle) return null;
+    if ("number" === typeof componentOrHandle) return componentOrHandle;
+    if (componentOrHandle._nativeTag) return componentOrHandle._nativeTag;
+    if (null != componentOrHandle.canonical && null != componentOrHandle.canonical.nativeTag) return componentOrHandle.canonical.nativeTag;
+    var nativeTag = _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").getNativeTagFromPublicInstance(componentOrHandle);
+    if (nativeTag) return nativeTag;
+    componentOrHandle = findHostInstance(componentOrHandle);
+    return null == componentOrHandle ? componentOrHandle : null != componentOrHandle._nativeTag ? componentOrHandle._nativeTag : _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").getNativeTagFromPublicInstance(componentOrHandle);
+  };
+  exports.isChildPublicInstance = function () {
+    throw Error("isChildPublicInstance() is not available in production.");
+  };
+  exports.render = function (element, containerTag, callback, options) {
+    var root = roots.get(containerTag);
+    if (!root) {
+      root = nativeOnUncaughtError;
+      var onCaughtError = nativeOnCaughtError,
+        onRecoverableError = defaultOnRecoverableError;
+      options && void 0 !== options.onUncaughtError && (root = options.onUncaughtError);
+      options && void 0 !== options.onCaughtError && (onCaughtError = options.onCaughtError);
+      options && void 0 !== options.onRecoverableError && (onRecoverableError = options.onRecoverableError);
+      options = new FiberRootNode({
+        containerTag: containerTag,
+        publicInstance: null
+      }, 0, !1, "", root, onCaughtError, onRecoverableError, null);
+      root = createFiberImplClass(3, null, null, 0);
+      options.current = root;
+      root.stateNode = options;
+      onCaughtError = createCache();
+      onCaughtError.refCount++;
+      options.pooledCache = onCaughtError;
+      onCaughtError.refCount++;
+      root.memoizedState = {
+        element: null,
+        isDehydrated: !1,
+        cache: onCaughtError
+      };
+      initializeUpdateQueue(root);
+      root = options;
+      roots.set(containerTag, root);
+    }
+    updateContainer(element, root, null, callback);
+    a: if (element = root.current, element.child) switch (element.child.tag) {
+      case 27:
+      case 5:
+        element = getPublicInstance(element.child.stateNode);
+        break a;
+      default:
+        element = element.child.stateNode;
+    } else element = null;
+    return element;
+  };
+  exports.sendAccessibilityEvent = function (handle, eventType) {
+    var nativeTag = null != handle._nativeTag ? handle._nativeTag : _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").getNativeTagFromPublicInstance(handle);
+    null != nativeTag && (handle = _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").getNodeFromPublicInstance(handle), null != handle ? nativeFabricUIManager.sendAccessibilityEvent(handle, eventType) : _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").legacySendAccessibilityEvent(nativeTag, eventType));
+  };
+  exports.unmountComponentAtNode = unmountComponentAtNode;
+  exports.unmountComponentAtNodeAndRemoveContainer = function (containerTag) {
+    unmountComponentAtNode(containerTag);
+    _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface").UIManager.removeRootView(containerTag);
+  };
+  exports.unstable_batchedUpdates = batchedUpdates$1;
+},523,[110,73,322,516],"../../node_modules/react-native/Libraries/Renderer/implementations/ReactNativeRenderer-prod.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Utilities/Platform"));
+  var ProgressBarAndroid;
+  if (_Platform.default.OS === 'android') {
+    ProgressBarAndroid = _$$_REQUIRE(_dependencyMap[2], "./ProgressBarAndroid").default;
+  } else {
+    ProgressBarAndroid = _$$_REQUIRE(_dependencyMap[3], "../UnimplementedViews/UnimplementedView").default;
+  }
+  var _default = exports.default = ProgressBarAndroid;
+},524,[1,68,524,525],"../../node_modules/react-native/Libraries/Components/ProgressBarAndroid/ProgressBarAndroid.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../../StyleSheet/StyleSheet"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[8], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Components/UnimplementedViews/UnimplementedView.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var UnimplementedView = /*#__PURE__*/function (_React$Component) {
+    function UnimplementedView() {
+      (0, _classCallCheck2.default)(this, UnimplementedView);
+      return _callSuper(this, UnimplementedView, arguments);
+    }
+    (0, _inherits2.default)(UnimplementedView, _React$Component);
+    return (0, _createClass2.default)(UnimplementedView, [{
+      key: "render",
+      value: function render() {
+        var View = _$$_REQUIRE(_dependencyMap[9], "../View/View").default;
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(View, {
+          style: [styles.unimplementedView, this.props.style],
+          children: this.props.children
+        });
+      }
+    }]);
+  }(React.Component);
+  var styles = _StyleSheet.default.create({
+    unimplementedView: __DEV__ ? {
+      alignSelf: 'flex-start',
+      borderColor: 'red',
+      borderWidth: 1
+    } : {}
+  });
+  var _default = exports.default = UnimplementedView;
+},525,[1,11,12,18,20,23,6,73,171,71],"../../node_modules/react-native/Libraries/Components/UnimplementedViews/UnimplementedView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _ActivityIndicatorViewNativeComponent = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../src/private/specs_DEPRECATED/components/ActivityIndicatorViewNativeComponent"));
+  Object.keys(_ActivityIndicatorViewNativeComponent).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _ActivityIndicatorViewNativeComponent[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _ActivityIndicatorViewNativeComponent[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _ActivityIndicatorViewNativeComponent.default;
+},526,[527],"../../node_modules/react-native/Libraries/Components/ActivityIndicator/ActivityIndicatorViewNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = exports.__INTERNAL_VIEW_CONFIG = void 0;
+  var _codegenNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../../../Libraries/Utilities/codegenNativeComponent"));
+  var nativeComponentName = 'RCTActivityIndicatorView';
+  var __INTERNAL_VIEW_CONFIG = exports.__INTERNAL_VIEW_CONFIG = {
+    uiViewClassName: "RCTActivityIndicatorView",
+    validAttributes: {
+      hidesWhenStopped: true,
+      animating: true,
+      color: {
+        process: _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/StyleSheet/processColor").default
+      },
+      size: true
+    }
+  };
+  var _default = exports.default = _$$_REQUIRE(_dependencyMap[3], "react-native/Libraries/NativeComponent/NativeComponentRegistry").get(nativeComponentName, function () {
+    return __INTERNAL_VIEW_CONFIG;
+  });
+},527,[1,319,57,77],"../../node_modules/react-native/src/private/specs_DEPRECATED/components/ActivityIndicatorViewNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../StyleSheet/StyleSheet"));
+  var _Text = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../Text/Text"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../Utilities/Platform"));
+  var _TouchableNativeFeedback = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./Touchable/TouchableNativeFeedback"));
+  var _TouchableOpacity = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./Touchable/TouchableOpacity"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./View/View"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "invariant"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[8], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[9], "react/jsx-runtime");
+  var _this = this,
+    _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Components/Button.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var Touchable = _Platform.default.OS === 'android' ? _TouchableNativeFeedback.default : _TouchableOpacity.default;
+  var Button = React.forwardRef(function (props, ref) {
+    var _accessibilityState2, _accessibilityState3;
+    var accessibilityLabel = props.accessibilityLabel,
+      accessibilityState = props.accessibilityState,
+      ariaBusy = props['aria-busy'],
+      ariaChecked = props['aria-checked'],
+      ariaDisabled = props['aria-disabled'],
+      ariaExpanded = props['aria-expanded'],
+      ariaLabel = props['aria-label'],
+      ariaSelected = props['aria-selected'],
+      importantForAccessibility = props.importantForAccessibility,
+      color = props.color,
+      onPress = props.onPress,
+      touchSoundDisabled = props.touchSoundDisabled,
+      title = props.title,
+      hasTVPreferredFocus = props.hasTVPreferredFocus,
+      nextFocusDown = props.nextFocusDown,
+      nextFocusForward = props.nextFocusForward,
+      nextFocusLeft = props.nextFocusLeft,
+      nextFocusRight = props.nextFocusRight,
+      nextFocusUp = props.nextFocusUp,
+      testID = props.testID,
+      accessible = props.accessible,
+      accessibilityActions = props.accessibilityActions,
+      accessibilityHint = props.accessibilityHint,
+      accessibilityLanguage = props.accessibilityLanguage,
+      onAccessibilityAction = props.onAccessibilityAction;
+    var buttonStyles = [styles.button];
+    var textStyles = [styles.text];
+    if (color) {
+      if (_Platform.default.OS === 'ios') {
+        textStyles.push({
+          color: color
+        });
+      } else {
+        buttonStyles.push({
+          backgroundColor: color
+        });
+      }
+    }
+    var _accessibilityState = {
+      busy: ariaBusy != null ? ariaBusy : accessibilityState == null ? void 0 : accessibilityState.busy,
+      checked: ariaChecked != null ? ariaChecked : accessibilityState == null ? void 0 : accessibilityState.checked,
+      disabled: ariaDisabled != null ? ariaDisabled : accessibilityState == null ? void 0 : accessibilityState.disabled,
+      expanded: ariaExpanded != null ? ariaExpanded : accessibilityState == null ? void 0 : accessibilityState.expanded,
+      selected: ariaSelected != null ? ariaSelected : accessibilityState == null ? void 0 : accessibilityState.selected
+    };
+    var disabled = props.disabled != null ? props.disabled : (_accessibilityState2 = _accessibilityState) == null ? void 0 : _accessibilityState2.disabled;
+    _accessibilityState = disabled !== ((_accessibilityState3 = _accessibilityState) == null ? void 0 : _accessibilityState3.disabled) ? Object.assign({}, _accessibilityState, {
+      disabled: disabled
+    }) : _accessibilityState;
+    if (disabled) {
+      buttonStyles.push(styles.buttonDisabled);
+      textStyles.push(styles.textDisabled);
+    }
+    (0, _invariant.default)(typeof title === 'string', 'The title prop of a Button must be a string');
+    var formattedTitle = _Platform.default.OS === 'android' ? title.toUpperCase() : title;
+    var _importantForAccessibility = importantForAccessibility === 'no' ? 'no-hide-descendants' : importantForAccessibility;
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(Touchable, {
+      accessible: accessible,
+      accessibilityActions: accessibilityActions,
+      onAccessibilityAction: onAccessibilityAction,
+      accessibilityLabel: ariaLabel || accessibilityLabel,
+      accessibilityHint: accessibilityHint,
+      accessibilityLanguage: accessibilityLanguage,
+      accessibilityRole: "button",
+      accessibilityState: _accessibilityState,
+      importantForAccessibility: _importantForAccessibility,
+      hasTVPreferredFocus: hasTVPreferredFocus,
+      nextFocusDown: nextFocusDown,
+      nextFocusForward: nextFocusForward,
+      nextFocusLeft: nextFocusLeft,
+      nextFocusRight: nextFocusRight,
+      nextFocusUp: nextFocusUp,
+      testID: testID,
+      disabled: disabled,
+      onPress: onPress,
+      touchSoundDisabled: touchSoundDisabled,
+      ref: ref,
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+        style: buttonStyles,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+          style: textStyles,
+          disabled: disabled,
+          children: formattedTitle
+        })
+      })
+    });
+  });
+  Button.displayName = 'Button';
+  var styles = _StyleSheet.default.create({
+    button: _Platform.default.select({
+      ios: {},
+      android: {
+        elevation: 4,
+        backgroundColor: '#2196F3',
+        borderRadius: 2
+      }
+    }),
+    text: Object.assign({
+      textAlign: 'center',
+      margin: 8
+    }, _Platform.default.select({
+      ios: {
+        color: '#007AFF',
+        fontSize: 18
+      },
+      android: {
+        color: 'white',
+        fontWeight: '500'
+      }
+    })),
+    buttonDisabled: _Platform.default.select({
+      ios: {},
+      android: {
+        elevation: 0,
+        backgroundColor: '#dfdfdf'
+      }
+    }),
+    textDisabled: _Platform.default.select({
+      ios: {
+        color: '#cdcdcd'
+      },
+      android: {
+        color: '#a1a1a1'
+      }
+    })
+  });
+  var _default = exports.default = Button;
+},528,[1,6,352,68,529,530,71,32,73,171],"../../node_modules/react-native/Libraries/Components/Button.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../../Components/View/View"));
+  var _Pressability = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../../Pressability/Pressability"));
+  var _processColor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "../../StyleSheet/processColor"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "../../Utilities/Platform"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "invariant"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[12], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[13], "react/jsx-runtime");
+  var _excluded = ["onBlur", "onFocus"];
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Components/Touchable/TouchableNativeFeedback.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var TouchableNativeFeedback = /*#__PURE__*/function (_React$Component) {
+    function TouchableNativeFeedback() {
+      var _this;
+      (0, _classCallCheck2.default)(this, TouchableNativeFeedback);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _callSuper(this, TouchableNativeFeedback, [].concat(args));
+      _this.state = {
+        pressability: new _Pressability.default(_this._createPressabilityConfig())
+      };
+      return _this;
+    }
+    (0, _inherits2.default)(TouchableNativeFeedback, _React$Component);
+    return (0, _createClass2.default)(TouchableNativeFeedback, [{
+      key: "_createPressabilityConfig",
+      value: function _createPressabilityConfig() {
+        var _this$props$ariaDisa,
+          _this$props$accessibi,
+          _this2 = this;
+        var accessibilityStateDisabled = (_this$props$ariaDisa = this.props['aria-disabled']) != null ? _this$props$ariaDisa : (_this$props$accessibi = this.props.accessibilityState) == null ? void 0 : _this$props$accessibi.disabled;
+        return {
+          cancelable: !this.props.rejectResponderTermination,
+          disabled: this.props.disabled != null ? this.props.disabled : accessibilityStateDisabled,
+          hitSlop: this.props.hitSlop,
+          delayLongPress: this.props.delayLongPress,
+          delayPressIn: this.props.delayPressIn,
+          delayPressOut: this.props.delayPressOut,
+          minPressDuration: 0,
+          pressRectOffset: this.props.pressRetentionOffset,
+          android_disableSound: this.props.touchSoundDisabled,
+          onLongPress: this.props.onLongPress,
+          onPress: this.props.onPress,
+          onPressIn: function onPressIn(event) {
+            if (_Platform.default.OS === 'android') {
+              _this2._dispatchHotspotUpdate(event);
+              _this2._dispatchPressedStateChange(true);
+            }
+            if (_this2.props.onPressIn != null) {
+              _this2.props.onPressIn(event);
+            }
+          },
+          onPressMove: function onPressMove(event) {
+            if (_Platform.default.OS === 'android') {
+              _this2._dispatchHotspotUpdate(event);
+            }
+          },
+          onPressOut: function onPressOut(event) {
+            if (_Platform.default.OS === 'android') {
+              _this2._dispatchPressedStateChange(false);
+            }
+            if (_this2.props.onPressOut != null) {
+              _this2.props.onPressOut(event);
+            }
+          }
+        };
+      }
+    }, {
+      key: "_dispatchPressedStateChange",
+      value: function _dispatchPressedStateChange(pressed) {
+        if (_Platform.default.OS === 'android') {
+          var hostComponentRef = (0, _$$_REQUIRE(_dependencyMap[14], "../../ReactNative/RendererProxy").findHostInstance_DEPRECATED)(this);
+          if (hostComponentRef == null) {
+            console.warn('Touchable: Unable to find HostComponent instance. ' + 'Has your Touchable component been unmounted?');
+          } else {
+            _$$_REQUIRE(_dependencyMap[15], "../View/ViewNativeComponent").Commands.setPressed(hostComponentRef, pressed);
+          }
+        }
+      }
+    }, {
+      key: "_dispatchHotspotUpdate",
+      value: function _dispatchHotspotUpdate(event) {
+        if (_Platform.default.OS === 'android') {
+          var _event$nativeEvent = event.nativeEvent,
+            locationX = _event$nativeEvent.locationX,
+            locationY = _event$nativeEvent.locationY;
+          var hostComponentRef = (0, _$$_REQUIRE(_dependencyMap[14], "../../ReactNative/RendererProxy").findHostInstance_DEPRECATED)(this);
+          if (hostComponentRef == null) {
+            console.warn('Touchable: Unable to find HostComponent instance. ' + 'Has your Touchable component been unmounted?');
+          } else {
+            _$$_REQUIRE(_dependencyMap[15], "../View/ViewNativeComponent").Commands.hotspotUpdate(hostComponentRef, locationX != null ? locationX : 0, locationY != null ? locationY : 0);
+          }
+        }
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props$ariaBusy, _this$props$accessibi2, _this$props$ariaChec, _this$props$accessibi3, _this$props$ariaDisa2, _this$props$accessibi4, _this$props$ariaExpa, _this$props$accessibi5, _this$props$ariaSele, _this$props$accessibi6, _this$props$ariaValu, _this$props$accessibi7, _this$props$ariaValu2, _this$props$accessibi8, _this$props$ariaValu3, _this$props$accessibi9, _this$props$ariaValu4, _this$props$accessibi0, _this$props$ariaLive, _this$props$ariaLabe, _this$props$ariaModa, _this$props$ariaHidd, _this$props$id;
+        var element = React.Children.only(this.props.children);
+        var children = [element.props.children];
+        if (__DEV__) {
+          if (element.type === _View.default) {
+            children.push(/*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[16], "../../Pressability/PressabilityDebug").PressabilityDebugView, {
+              color: "brown",
+              hitSlop: this.props.hitSlop
+            }));
+          }
+        }
+        var _this$state$pressabil = this.state.pressability.getEventHandlers(),
+          onBlur = _this$state$pressabil.onBlur,
+          onFocus = _this$state$pressabil.onFocus,
+          eventHandlersWithoutBlurAndFocus = (0, _objectWithoutProperties2.default)(_this$state$pressabil, _excluded);
+        var _accessibilityState = {
+          busy: (_this$props$ariaBusy = this.props['aria-busy']) != null ? _this$props$ariaBusy : (_this$props$accessibi2 = this.props.accessibilityState) == null ? void 0 : _this$props$accessibi2.busy,
+          checked: (_this$props$ariaChec = this.props['aria-checked']) != null ? _this$props$ariaChec : (_this$props$accessibi3 = this.props.accessibilityState) == null ? void 0 : _this$props$accessibi3.checked,
+          disabled: (_this$props$ariaDisa2 = this.props['aria-disabled']) != null ? _this$props$ariaDisa2 : (_this$props$accessibi4 = this.props.accessibilityState) == null ? void 0 : _this$props$accessibi4.disabled,
+          expanded: (_this$props$ariaExpa = this.props['aria-expanded']) != null ? _this$props$ariaExpa : (_this$props$accessibi5 = this.props.accessibilityState) == null ? void 0 : _this$props$accessibi5.expanded,
+          selected: (_this$props$ariaSele = this.props['aria-selected']) != null ? _this$props$ariaSele : (_this$props$accessibi6 = this.props.accessibilityState) == null ? void 0 : _this$props$accessibi6.selected
+        };
+        _accessibilityState = this.props.disabled != null ? Object.assign({}, _accessibilityState, {
+          disabled: this.props.disabled
+        }) : _accessibilityState;
+        var accessibilityValue = {
+          max: (_this$props$ariaValu = this.props['aria-valuemax']) != null ? _this$props$ariaValu : (_this$props$accessibi7 = this.props.accessibilityValue) == null ? void 0 : _this$props$accessibi7.max,
+          min: (_this$props$ariaValu2 = this.props['aria-valuemin']) != null ? _this$props$ariaValu2 : (_this$props$accessibi8 = this.props.accessibilityValue) == null ? void 0 : _this$props$accessibi8.min,
+          now: (_this$props$ariaValu3 = this.props['aria-valuenow']) != null ? _this$props$ariaValu3 : (_this$props$accessibi9 = this.props.accessibilityValue) == null ? void 0 : _this$props$accessibi9.now,
+          text: (_this$props$ariaValu4 = this.props['aria-valuetext']) != null ? _this$props$ariaValu4 : (_this$props$accessibi0 = this.props.accessibilityValue) == null ? void 0 : _this$props$accessibi0.text
+        };
+        var accessibilityLiveRegion = this.props['aria-live'] === 'off' ? 'none' : (_this$props$ariaLive = this.props['aria-live']) != null ? _this$props$ariaLive : this.props.accessibilityLiveRegion;
+        var accessibilityLabel = (_this$props$ariaLabe = this.props['aria-label']) != null ? _this$props$ariaLabe : this.props.accessibilityLabel;
+        return React.cloneElement.apply(React, [element, Object.assign({}, eventHandlersWithoutBlurAndFocus, getBackgroundProp(this.props.background === undefined ? TouchableNativeFeedback.SelectableBackground() : this.props.background, this.props.useForeground === true), {
+          accessible: this.props.accessible !== false,
+          accessibilityHint: this.props.accessibilityHint,
+          accessibilityLanguage: this.props.accessibilityLanguage,
+          accessibilityLabel: accessibilityLabel,
+          accessibilityRole: this.props.accessibilityRole,
+          accessibilityState: _accessibilityState,
+          accessibilityActions: this.props.accessibilityActions,
+          onAccessibilityAction: this.props.onAccessibilityAction,
+          accessibilityValue: accessibilityValue,
+          importantForAccessibility: this.props['aria-hidden'] === true ? 'no-hide-descendants' : this.props.importantForAccessibility,
+          accessibilityViewIsModal: (_this$props$ariaModa = this.props['aria-modal']) != null ? _this$props$ariaModa : this.props.accessibilityViewIsModal,
+          accessibilityLiveRegion: accessibilityLiveRegion,
+          accessibilityElementsHidden: (_this$props$ariaHidd = this.props['aria-hidden']) != null ? _this$props$ariaHidd : this.props.accessibilityElementsHidden,
+          hasTVPreferredFocus: this.props.hasTVPreferredFocus,
+          hitSlop: this.props.hitSlop,
+          focusable: this.props.focusable !== false && this.props.onPress !== undefined && !this.props.disabled,
+          nativeID: (_this$props$id = this.props.id) != null ? _this$props$id : this.props.nativeID,
+          nextFocusDown: this.props.nextFocusDown,
+          nextFocusForward: this.props.nextFocusForward,
+          nextFocusLeft: this.props.nextFocusLeft,
+          nextFocusRight: this.props.nextFocusRight,
+          nextFocusUp: this.props.nextFocusUp,
+          onLayout: this.props.onLayout,
+          testID: this.props.testID
+        })].concat(children));
+      }
+    }, {
+      key: "componentDidUpdate",
+      value: function componentDidUpdate(prevProps, prevState) {
+        this.state.pressability.configure(this._createPressabilityConfig());
+      }
+    }, {
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        this.state.pressability.configure(this._createPressabilityConfig());
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        this.state.pressability.reset();
+      }
+    }]);
+  }(React.Component);
+  TouchableNativeFeedback.SelectableBackground = function (rippleRadius) {
+    return {
+      type: 'ThemeAttrAndroid',
+      attribute: 'selectableItemBackground',
+      rippleRadius: rippleRadius
+    };
+  };
+  TouchableNativeFeedback.SelectableBackgroundBorderless = function (rippleRadius) {
+    return {
+      type: 'ThemeAttrAndroid',
+      attribute: 'selectableItemBackgroundBorderless',
+      rippleRadius: rippleRadius
+    };
+  };
+  TouchableNativeFeedback.Ripple = function (color, borderless, rippleRadius) {
+    var processedColor = (0, _processColor.default)(color);
+    (0, _invariant.default)(processedColor == null || typeof processedColor === 'number', 'Unexpected color given for Ripple color');
+    return {
+      type: 'RippleAndroid',
+      color: processedColor,
+      borderless: borderless,
+      rippleRadius: rippleRadius
+    };
+  };
+  TouchableNativeFeedback.canUseNativeForeground = function () {
+    return _Platform.default.OS === 'android';
+  };
+  var getBackgroundProp = _Platform.default.OS === 'android' ? function (background, useForeground) {
+    return useForeground && TouchableNativeFeedback.canUseNativeForeground() ? {
+      nativeForegroundAndroid: background
+    } : {
+      nativeBackgroundAndroid: background
+    };
+  } : function (background, useForeground) {
+    return null;
+  };
+  TouchableNativeFeedback.displayName = 'TouchableNativeFeedback';
+  var _default = exports.default = TouchableNativeFeedback;
+},529,[1,4,11,12,18,20,23,71,341,57,68,32,73,171,106,76,349],"../../node_modules/react-native/Libraries/Components/Touchable/TouchableNativeFeedback.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _Animated = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../../Animated/Animated"));
+  var _Easing = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../../Animated/Easing"));
+  var _Pressability = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "../../Pressability/Pressability"));
+  var _flattenStyle4 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "../../StyleSheet/flattenStyle"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "../../Utilities/Platform"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[12], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[13], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Components/Touchable/TouchableOpacity.js",
+    _this3 = this;
+  var _excluded = ["onBlur", "onFocus"];
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var TouchableOpacity = /*#__PURE__*/function (_React$Component) {
+    function TouchableOpacity() {
+      var _this;
+      (0, _classCallCheck2.default)(this, TouchableOpacity);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _callSuper(this, TouchableOpacity, [].concat(args));
+      _this.state = {
+        anim: new _Animated.default.Value(_this._getChildStyleOpacityWithDefault()),
+        pressability: new _Pressability.default(_this._createPressabilityConfig())
+      };
+      return _this;
+    }
+    (0, _inherits2.default)(TouchableOpacity, _React$Component);
+    return (0, _createClass2.default)(TouchableOpacity, [{
+      key: "_createPressabilityConfig",
+      value: function _createPressabilityConfig() {
+        var _ref,
+          _this$props$disabled,
+          _this$props$accessibi,
+          _this2 = this;
+        return {
+          cancelable: !this.props.rejectResponderTermination,
+          disabled: (_ref = (_this$props$disabled = this.props.disabled) != null ? _this$props$disabled : this.props['aria-disabled']) != null ? _ref : (_this$props$accessibi = this.props.accessibilityState) == null ? void 0 : _this$props$accessibi.disabled,
+          hitSlop: this.props.hitSlop,
+          delayLongPress: this.props.delayLongPress,
+          delayPressIn: this.props.delayPressIn,
+          delayPressOut: this.props.delayPressOut,
+          minPressDuration: 0,
+          pressRectOffset: this.props.pressRetentionOffset,
+          onBlur: function onBlur(event) {
+            if (_Platform.default.isTV) {
+              _this2._opacityInactive(250);
+            }
+            if (_this2.props.onBlur != null) {
+              _this2.props.onBlur(event);
+            }
+          },
+          onFocus: function onFocus(event) {
+            if (_Platform.default.isTV) {
+              _this2._opacityActive(150);
+            }
+            if (_this2.props.onFocus != null) {
+              _this2.props.onFocus(event);
+            }
+          },
+          onLongPress: this.props.onLongPress,
+          onPress: this.props.onPress,
+          onPressIn: function onPressIn(event) {
+            _this2._opacityActive(event.dispatchConfig.registrationName === 'onResponderGrant' ? 0 : 150);
+            if (_this2.props.onPressIn != null) {
+              _this2.props.onPressIn(event);
+            }
+          },
+          onPressOut: function onPressOut(event) {
+            _this2._opacityInactive(250);
+            if (_this2.props.onPressOut != null) {
+              _this2.props.onPressOut(event);
+            }
+          }
+        };
+      }
+    }, {
+      key: "_setOpacityTo",
+      value: function _setOpacityTo(toValue, duration) {
+        _Animated.default.timing(this.state.anim, {
+          toValue: toValue,
+          duration: duration,
+          easing: _Easing.default.inOut(_Easing.default.quad),
+          useNativeDriver: true
+        }).start();
+      }
+    }, {
+      key: "_opacityActive",
+      value: function _opacityActive(duration) {
+        var _this$props$activeOpa;
+        this._setOpacityTo((_this$props$activeOpa = this.props.activeOpacity) != null ? _this$props$activeOpa : 0.2, duration);
+      }
+    }, {
+      key: "_opacityInactive",
+      value: function _opacityInactive(duration) {
+        this._setOpacityTo(this._getChildStyleOpacityWithDefault(), duration);
+      }
+    }, {
+      key: "_getChildStyleOpacityWithDefault",
+      value: function _getChildStyleOpacityWithDefault() {
+        var _flattenStyle;
+        var opacity = (_flattenStyle = (0, _flattenStyle4.default)(this.props.style)) == null ? void 0 : _flattenStyle.opacity;
+        return typeof opacity === 'number' ? opacity : 1;
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props$ariaBusy, _this$props$accessibi2, _this$props$ariaChec, _this$props$accessibi3, _this$props$ariaDisa, _this$props$accessibi4, _this$props$ariaExpa, _this$props$accessibi5, _this$props$ariaSele, _this$props$accessibi6, _this$props$ariaValu, _this$props$accessibi7, _this$props$ariaValu2, _this$props$accessibi8, _this$props$ariaValu3, _this$props$accessibi9, _this$props$ariaValu4, _this$props$accessibi0, _this$props$ariaLive, _this$props$ariaLabe, _this$props$ariaModa, _this$props$ariaHidd, _this$props$id;
+        var _this$state$pressabil = this.state.pressability.getEventHandlers(),
+          onBlur = _this$state$pressabil.onBlur,
+          onFocus = _this$state$pressabil.onFocus,
+          eventHandlersWithoutBlurAndFocus = (0, _objectWithoutProperties2.default)(_this$state$pressabil, _excluded);
+        var _accessibilityState = {
+          busy: (_this$props$ariaBusy = this.props['aria-busy']) != null ? _this$props$ariaBusy : (_this$props$accessibi2 = this.props.accessibilityState) == null ? void 0 : _this$props$accessibi2.busy,
+          checked: (_this$props$ariaChec = this.props['aria-checked']) != null ? _this$props$ariaChec : (_this$props$accessibi3 = this.props.accessibilityState) == null ? void 0 : _this$props$accessibi3.checked,
+          disabled: (_this$props$ariaDisa = this.props['aria-disabled']) != null ? _this$props$ariaDisa : (_this$props$accessibi4 = this.props.accessibilityState) == null ? void 0 : _this$props$accessibi4.disabled,
+          expanded: (_this$props$ariaExpa = this.props['aria-expanded']) != null ? _this$props$ariaExpa : (_this$props$accessibi5 = this.props.accessibilityState) == null ? void 0 : _this$props$accessibi5.expanded,
+          selected: (_this$props$ariaSele = this.props['aria-selected']) != null ? _this$props$ariaSele : (_this$props$accessibi6 = this.props.accessibilityState) == null ? void 0 : _this$props$accessibi6.selected
+        };
+        _accessibilityState = this.props.disabled != null ? Object.assign({}, _accessibilityState, {
+          disabled: this.props.disabled
+        }) : _accessibilityState;
+        var accessibilityValue = {
+          max: (_this$props$ariaValu = this.props['aria-valuemax']) != null ? _this$props$ariaValu : (_this$props$accessibi7 = this.props.accessibilityValue) == null ? void 0 : _this$props$accessibi7.max,
+          min: (_this$props$ariaValu2 = this.props['aria-valuemin']) != null ? _this$props$ariaValu2 : (_this$props$accessibi8 = this.props.accessibilityValue) == null ? void 0 : _this$props$accessibi8.min,
+          now: (_this$props$ariaValu3 = this.props['aria-valuenow']) != null ? _this$props$ariaValu3 : (_this$props$accessibi9 = this.props.accessibilityValue) == null ? void 0 : _this$props$accessibi9.now,
+          text: (_this$props$ariaValu4 = this.props['aria-valuetext']) != null ? _this$props$ariaValu4 : (_this$props$accessibi0 = this.props.accessibilityValue) == null ? void 0 : _this$props$accessibi0.text
+        };
+        var accessibilityLiveRegion = this.props['aria-live'] === 'off' ? 'none' : (_this$props$ariaLive = this.props['aria-live']) != null ? _this$props$ariaLive : this.props.accessibilityLiveRegion;
+        var accessibilityLabel = (_this$props$ariaLabe = this.props['aria-label']) != null ? _this$props$ariaLabe : this.props.accessibilityLabel;
+        return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_Animated.default.View, Object.assign({
+          accessible: this.props.accessible !== false,
+          accessibilityLabel: accessibilityLabel,
+          accessibilityHint: this.props.accessibilityHint,
+          accessibilityLanguage: this.props.accessibilityLanguage,
+          accessibilityRole: this.props.accessibilityRole,
+          accessibilityState: _accessibilityState,
+          accessibilityActions: this.props.accessibilityActions,
+          onAccessibilityAction: this.props.onAccessibilityAction,
+          accessibilityValue: accessibilityValue,
+          importantForAccessibility: this.props['aria-hidden'] === true ? 'no-hide-descendants' : this.props.importantForAccessibility,
+          accessibilityViewIsModal: (_this$props$ariaModa = this.props['aria-modal']) != null ? _this$props$ariaModa : this.props.accessibilityViewIsModal,
+          accessibilityLiveRegion: accessibilityLiveRegion,
+          accessibilityElementsHidden: (_this$props$ariaHidd = this.props['aria-hidden']) != null ? _this$props$ariaHidd : this.props.accessibilityElementsHidden,
+          style: [this.props.style, {
+            opacity: this.state.anim
+          }],
+          nativeID: (_this$props$id = this.props.id) != null ? _this$props$id : this.props.nativeID,
+          testID: this.props.testID,
+          onLayout: this.props.onLayout,
+          nextFocusDown: this.props.nextFocusDown,
+          nextFocusForward: this.props.nextFocusForward,
+          nextFocusLeft: this.props.nextFocusLeft,
+          nextFocusRight: this.props.nextFocusRight,
+          nextFocusUp: this.props.nextFocusUp,
+          hasTVPreferredFocus: this.props.hasTVPreferredFocus,
+          hitSlop: this.props.hitSlop,
+          focusable: this.props.focusable !== false && this.props.onPress !== undefined && !this.props.disabled,
+          ref: this.props.hostRef
+        }, eventHandlersWithoutBlurAndFocus, {
+          children: [this.props.children, __DEV__ ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[14], "../../Pressability/PressabilityDebug").PressabilityDebugView, {
+            color: "cyan",
+            hitSlop: this.props.hitSlop
+          }) : null]
+        }));
+      }
+    }, {
+      key: "componentDidUpdate",
+      value: function componentDidUpdate(prevProps, prevState) {
+        var _flattenStyle2, _flattenStyle3;
+        this.state.pressability.configure(this._createPressabilityConfig());
+        if (this.props.disabled !== prevProps.disabled || ((_flattenStyle2 = (0, _flattenStyle4.default)(prevProps.style)) == null ? void 0 : _flattenStyle2.opacity) !== ((_flattenStyle3 = (0, _flattenStyle4.default)(this.props.style)) == null ? void 0 : _flattenStyle3.opacity)) {
+          this._opacityInactive(250);
+        }
+      }
+    }, {
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        this.state.pressability.configure(this._createPressabilityConfig());
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        this.state.pressability.reset();
+        this.state.anim.resetAnimation();
+      }
+    }]);
+  }(React.Component);
+  var Touchable = React.forwardRef(function (props, ref) {
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(TouchableOpacity, Object.assign({}, props, {
+      hostRef: ref
+    }));
+  });
+  Touchable.displayName = 'TouchableOpacity';
+  var _default = exports.default = Touchable;
+},530,[1,4,11,12,18,20,23,442,411,341,9,68,73,171,349],"../../node_modules/react-native/Libraries/Components/Touchable/TouchableOpacity.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _DrawerLayoutAndroidFallback = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./DrawerLayoutAndroidFallback"));
+  var _default = exports.default = _DrawerLayoutAndroidFallback.default;
+},531,[1,532],"../../node_modules/react-native/Libraries/Components/DrawerAndroid/DrawerLayoutAndroid.ios.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var _UnimplementedView = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../UnimplementedViews/UnimplementedView"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[8], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Components/DrawerAndroid/DrawerLayoutAndroidFallback.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var DrawerLayoutAndroid = exports.default = /*#__PURE__*/function (_React$Component) {
+    function DrawerLayoutAndroid() {
+      (0, _classCallCheck2.default)(this, DrawerLayoutAndroid);
+      return _callSuper(this, DrawerLayoutAndroid, arguments);
+    }
+    (0, _inherits2.default)(DrawerLayoutAndroid, _React$Component);
+    return (0, _createClass2.default)(DrawerLayoutAndroid, [{
+      key: "render",
+      value: function render() {
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(_UnimplementedView.default, Object.assign({}, this.props));
+      }
+    }, {
+      key: "openDrawer",
+      value: function openDrawer() {
+        throw new Error('DrawerLayoutAndroid is only available on Android');
+      }
+    }, {
+      key: "closeDrawer",
+      value: function closeDrawer() {
+        throw new Error('DrawerLayoutAndroid is only available on Android');
+      }
+    }, {
+      key: "blur",
+      value: function blur() {
+        throw new Error('DrawerLayoutAndroid is only available on Android');
+      }
+    }, {
+      key: "focus",
+      value: function focus() {
+        throw new Error('DrawerLayoutAndroid is only available on Android');
+      }
+    }, {
+      key: "measure",
+      value: function measure(callback) {
+        throw new Error('DrawerLayoutAndroid is only available on Android');
+      }
+    }, {
+      key: "measureInWindow",
+      value: function measureInWindow(callback) {
+        throw new Error('DrawerLayoutAndroid is only available on Android');
+      }
+    }, {
+      key: "measureLayout",
+      value: function measureLayout(relativeToNativeNode, onSuccess, onFail) {
+        throw new Error('DrawerLayoutAndroid is only available on Android');
+      }
+    }, {
+      key: "setNativeProps",
+      value: function setNativeProps(nativeProps) {
+        throw new Error('DrawerLayoutAndroid is only available on Android');
+      }
+    }]);
+  }(React.Component);
+},532,[1,11,12,18,20,23,525,73,171],"../../node_modules/react-native/Libraries/Components/DrawerAndroid/DrawerLayoutAndroidFallback.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../Components/View/View"));
+  var _flattenStyle = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../StyleSheet/flattenStyle"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "../StyleSheet/StyleSheet"));
+  var _Image = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./Image"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[11], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[12], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Image/ImageBackground.js";
+  var _excluded = ["children", "style", "imageStyle", "imageRef", "importantForAccessibility"];
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var ImageBackground = /*#__PURE__*/function (_React$Component) {
+    function ImageBackground() {
+      var _this;
+      (0, _classCallCheck2.default)(this, ImageBackground);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _callSuper(this, ImageBackground, [].concat(args));
+      _this._viewRef = null;
+      _this._captureRef = function (ref) {
+        _this._viewRef = ref;
+      };
+      return _this;
+    }
+    (0, _inherits2.default)(ImageBackground, _React$Component);
+    return (0, _createClass2.default)(ImageBackground, [{
+      key: "setNativeProps",
+      value: function setNativeProps(props) {
+        var viewRef = this._viewRef;
+        if (viewRef) {
+          viewRef.setNativeProps(props);
+        }
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props = this.props,
+          children = _this$props.children,
+          style = _this$props.style,
+          imageStyle = _this$props.imageStyle,
+          imageRef = _this$props.imageRef,
+          importantForAccessibility = _this$props.importantForAccessibility,
+          props = (0, _objectWithoutProperties2.default)(_this$props, _excluded);
+        var flattenedStyle = (0, _flattenStyle.default)(style);
+        return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_View.default, {
+          accessibilityIgnoresInvertColors: true,
+          importantForAccessibility: importantForAccessibility,
+          style: style,
+          ref: this._captureRef,
+          children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_Image.default, Object.assign({}, props, {
+            importantForAccessibility: importantForAccessibility,
+            style: [_StyleSheet.default.absoluteFill, {
+              width: flattenedStyle == null ? void 0 : flattenedStyle.width,
+              height: flattenedStyle == null ? void 0 : flattenedStyle.height
+            }, imageStyle],
+            ref: imageRef
+          })), children]
+        });
+      }
+    }]);
+  }(React.Component);
+  var _default = exports.default = ImageBackground;
+},533,[1,4,11,12,18,20,23,71,9,6,355,73,171],"../../node_modules/react-native/Libraries/Image/ImageBackground.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _SafeAreaView = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Components/SafeAreaView/SafeAreaView"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../StyleSheet/StyleSheet"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../Utilities/Platform"));
+  var _useWindowDimensions2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../../Utilities/useWindowDimensions"));
+  var _RCTInputAccessoryViewNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./RCTInputAccessoryViewNativeComponent"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[6], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[7], "react/jsx-runtime");
+  var _this = this,
+    _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Components/TextInput/InputAccessoryView.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var InputAccessoryView = function InputAccessoryView(props) {
+    var _useWindowDimensions = (0, _useWindowDimensions2.default)(),
+      width = _useWindowDimensions.width;
+    if (_Platform.default.OS === 'ios') {
+      if (React.Children.count(props.children) === 0) {
+        return null;
+      }
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(_RCTInputAccessoryViewNativeComponent.default, {
+        style: [props.style, styles.container],
+        nativeID: props.nativeID,
+        backgroundColor: props.backgroundColor,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_SafeAreaView.default, {
+          style: [styles.safeAreaView, {
+            width: width
+          }],
+          children: props.children
+        })
+      });
+    } else {
+      console.warn('<InputAccessoryView> is only supported on iOS.');
+      return null;
+    }
+  };
+  var styles = _StyleSheet.default.create({
+    container: {
+      position: 'absolute'
+    },
+    safeAreaView: {
+      flex: 1
+    }
+  });
+  var _default = exports.default = InputAccessoryView;
+},534,[1,385,6,68,535,536,73,171],"../../node_modules/react-native/Libraries/Components/TextInput/InputAccessoryView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = useWindowDimensions;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _Dimensions = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./Dimensions"));
+  var _react = _$$_REQUIRE(_dependencyMap[3], "react");
+  function useWindowDimensions() {
+    var _useState = (0, _react.useState)(function () {
+        return _Dimensions.default.get('window');
+      }),
+      _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+      dimensions = _useState2[0],
+      setDimensions = _useState2[1];
+    (0, _react.useEffect)(function () {
+      function handleChange(_ref) {
+        var window = _ref.window;
+        if (dimensions.width !== window.width || dimensions.height !== window.height || dimensions.scale !== window.scale || dimensions.fontScale !== window.fontScale) {
+          setDimensions(window);
+        }
+      }
+      var subscription = _Dimensions.default.addEventListener('change', handleChange);
+      handleChange({
+        window: _Dimensions.default.get('window')
+      });
+      return function () {
+        subscription.remove();
+      };
+    }, [dimensions]);
+    return dimensions;
+  }
+},535,[1,34,16,73],"../../node_modules/react-native/Libraries/Utilities/useWindowDimensions.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _RCTInputAccessoryViewNativeComponent = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../src/private/specs_DEPRECATED/components/RCTInputAccessoryViewNativeComponent"));
+  Object.keys(_RCTInputAccessoryViewNativeComponent).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _RCTInputAccessoryViewNativeComponent[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _RCTInputAccessoryViewNativeComponent[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _RCTInputAccessoryViewNativeComponent.default;
+},536,[537],"../../node_modules/react-native/Libraries/Components/TextInput/RCTInputAccessoryViewNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = exports.__INTERNAL_VIEW_CONFIG = void 0;
+  var _codegenNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../../../Libraries/Utilities/codegenNativeComponent"));
+  var nativeComponentName = 'RCTInputAccessoryView';
+  var __INTERNAL_VIEW_CONFIG = exports.__INTERNAL_VIEW_CONFIG = {
+    uiViewClassName: "RCTInputAccessoryView",
+    validAttributes: {
+      backgroundColor: {
+        process: _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/StyleSheet/processColor").default
+      }
+    }
+  };
+  var _default = exports.default = _$$_REQUIRE(_dependencyMap[3], "react-native/Libraries/NativeComponent/NativeComponentRegistry").get(nativeComponentName, function () {
+    return __INTERNAL_VIEW_CONFIG;
+  });
+},537,[1,319,57,77],"../../node_modules/react-native/src/private/specs_DEPRECATED/components/RCTInputAccessoryViewNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties"));
+  var _asyncToGenerator2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/asyncToGenerator"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits"));
+  var _LayoutAnimation = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../../LayoutAnimation/LayoutAnimation"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "../../StyleSheet/StyleSheet"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "../../Utilities/Platform"));
+  var _AccessibilityInfo = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "../AccessibilityInfo/AccessibilityInfo"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "../View/View"));
+  var _Keyboard = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[13], "./Keyboard"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[14], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[15], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Components/Keyboard/KeyboardAvoidingView.js";
+  var _excluded = ["behavior", "children", "contentContainerStyle", "enabled", "keyboardVerticalOffset", "style", "onLayout"];
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var KeyboardAvoidingView = /*#__PURE__*/function (_React$Component) {
+    function KeyboardAvoidingView(props) {
+      var _this;
+      (0, _classCallCheck2.default)(this, KeyboardAvoidingView);
+      _this = _callSuper(this, KeyboardAvoidingView, [props]);
+      _this._frame = null;
+      _this._keyboardEvent = null;
+      _this._subscriptions = [];
+      _this._initialFrameHeight = 0;
+      _this._bottom = 0;
+      _this._onKeyboardChange = function (event) {
+        _this._keyboardEvent = event;
+        _this._updateBottomIfNecessary();
+      };
+      _this._onKeyboardHide = function (event) {
+        _this._keyboardEvent = null;
+        _this._updateBottomIfNecessary();
+      };
+      _this._onLayout = /*#__PURE__*/function () {
+        var _ref = (0, _asyncToGenerator2.default)(function* (event) {
+          event.persist();
+          var oldFrame = _this._frame;
+          _this._frame = event.nativeEvent.layout;
+          if (!_this._initialFrameHeight) {
+            _this._initialFrameHeight = _this._frame.height;
+          }
+          if (!oldFrame || oldFrame.height !== _this._frame.height) {
+            yield _this._updateBottomIfNecessary();
+          }
+          if (_this.props.onLayout) {
+            _this.props.onLayout(event);
+          }
+        });
+        return function (_x) {
+          return _ref.apply(this, arguments);
+        };
+      }();
+      _this._setBottom = function (value) {
+        var _this$props$enabled;
+        var enabled = (_this$props$enabled = _this.props.enabled) != null ? _this$props$enabled : true;
+        _this._bottom = value;
+        if (enabled) {
+          _this.setState({
+            bottom: value
+          });
+        }
+      };
+      _this._updateBottomIfNecessary = /*#__PURE__*/(0, _asyncToGenerator2.default)(function* () {
+        var _this$props$enabled2;
+        if (_this._keyboardEvent == null) {
+          _this._setBottom(0);
+          return;
+        }
+        var _this$_keyboardEvent = _this._keyboardEvent,
+          duration = _this$_keyboardEvent.duration,
+          easing = _this$_keyboardEvent.easing,
+          endCoordinates = _this$_keyboardEvent.endCoordinates;
+        var height = yield _this._relativeKeyboardHeight(endCoordinates);
+        if (_this._bottom === height) {
+          return;
+        }
+        _this._setBottom(height);
+        var enabled = (_this$props$enabled2 = _this.props.enabled) != null ? _this$props$enabled2 : true;
+        if (enabled && duration && easing) {
+          _LayoutAnimation.default.configureNext({
+            duration: duration > 10 ? duration : 10,
+            update: {
+              duration: duration > 10 ? duration : 10,
+              type: _LayoutAnimation.default.Types[easing] || 'keyboard'
+            }
+          });
+        }
+      });
+      _this.state = {
+        bottom: 0
+      };
+      _this.viewRef = React.createRef();
+      return _this;
+    }
+    (0, _inherits2.default)(KeyboardAvoidingView, _React$Component);
+    return (0, _createClass2.default)(KeyboardAvoidingView, [{
+      key: "_relativeKeyboardHeight",
+      value: function () {
+        var _relativeKeyboardHeight2 = (0, _asyncToGenerator2.default)(function* (keyboardFrame) {
+          var _this$props$keyboardV;
+          var frame = this._frame;
+          if (!frame || !keyboardFrame) {
+            return 0;
+          }
+          if (_Platform.default.OS === 'ios' && keyboardFrame.screenY === 0 && (yield _AccessibilityInfo.default.prefersCrossFadeTransitions())) {
+            return 0;
+          }
+          var keyboardY = keyboardFrame.screenY - ((_this$props$keyboardV = this.props.keyboardVerticalOffset) != null ? _this$props$keyboardV : 0);
+          if (this.props.behavior === 'height') {
+            return Math.max(this.state.bottom + frame.y + frame.height - keyboardY, 0);
+          }
+          return Math.max(frame.y + frame.height - keyboardY, 0);
+        });
+        function _relativeKeyboardHeight(_x2) {
+          return _relativeKeyboardHeight2.apply(this, arguments);
+        }
+        return _relativeKeyboardHeight;
+      }()
+    }, {
+      key: "componentDidUpdate",
+      value: function componentDidUpdate(_, prevState) {
+        var _this$props$enabled3;
+        var enabled = (_this$props$enabled3 = this.props.enabled) != null ? _this$props$enabled3 : true;
+        if (enabled && this._bottom !== prevState.bottom) {
+          this.setState({
+            bottom: this._bottom
+          });
+        }
+      }
+    }, {
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        if (!_Keyboard.default.isVisible()) {
+          this._keyboardEvent = null;
+          this._setBottom(0);
+        }
+        if (_Platform.default.OS === 'ios') {
+          this._subscriptions = [_Keyboard.default.addListener('keyboardWillHide', this._onKeyboardHide), _Keyboard.default.addListener('keyboardWillShow', this._onKeyboardChange)];
+        } else {
+          this._subscriptions = [_Keyboard.default.addListener('keyboardDidHide', this._onKeyboardChange), _Keyboard.default.addListener('keyboardDidShow', this._onKeyboardChange)];
+        }
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        this._subscriptions.forEach(function (subscription) {
+          subscription.remove();
+        });
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props = this.props,
+          behavior = _this$props.behavior,
+          children = _this$props.children,
+          contentContainerStyle = _this$props.contentContainerStyle,
+          _this$props$enabled4 = _this$props.enabled,
+          enabled = _this$props$enabled4 === void 0 ? true : _this$props$enabled4,
+          _this$props$keyboardV2 = _this$props.keyboardVerticalOffset,
+          keyboardVerticalOffset = _this$props$keyboardV2 === void 0 ? 0 : _this$props$keyboardV2,
+          style = _this$props.style,
+          onLayout = _this$props.onLayout,
+          props = (0, _objectWithoutProperties2.default)(_this$props, _excluded);
+        var bottomHeight = enabled === true ? this.state.bottom : 0;
+        switch (behavior) {
+          case 'height':
+            var heightStyle;
+            if (this._frame != null && this.state.bottom > 0) {
+              heightStyle = {
+                height: this._initialFrameHeight - bottomHeight,
+                flex: 0
+              };
+            }
+            return /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, Object.assign({
+              ref: this.viewRef,
+              style: _StyleSheet.default.compose(style, heightStyle),
+              onLayout: this._onLayout
+            }, props, {
+              children: children
+            }));
+          case 'position':
+            return /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, Object.assign({
+              ref: this.viewRef,
+              style: style,
+              onLayout: this._onLayout
+            }, props, {
+              children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+                style: _StyleSheet.default.compose(contentContainerStyle, {
+                  bottom: bottomHeight
+                }),
+                children: children
+              })
+            }));
+          case 'padding':
+            return /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, Object.assign({
+              ref: this.viewRef,
+              style: _StyleSheet.default.compose(style, {
+                paddingBottom: bottomHeight
+              }),
+              onLayout: this._onLayout
+            }, props, {
+              children: children
+            }));
+          default:
+            return /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, Object.assign({
+              ref: this.viewRef,
+              onLayout: this._onLayout,
+              style: style
+            }, props, {
+              children: children
+            }));
+        }
+      }
+    }]);
+  }(React.Component);
+  var _default = exports.default = KeyboardAvoidingView;
+},538,[1,4,167,11,12,18,20,23,435,6,68,539,71,434,73,171],"../../node_modules/react-native/Libraries/Components/Keyboard/KeyboardAvoidingView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _RCTDeviceEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../EventEmitter/RCTDeviceEventEmitter"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../Utilities/Platform"));
+  var _legacySendAccessibilityEvent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./legacySendAccessibilityEvent"));
+  var _NativeAccessibilityInfo = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./NativeAccessibilityInfo"));
+  var _NativeAccessibilityManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./NativeAccessibilityManager"));
+  var EventNames = _Platform.default.OS === 'android' ? new Map([['change', 'touchExplorationDidChange'], ['reduceMotionChanged', 'reduceMotionDidChange'], ['highTextContrastChanged', 'highTextContrastDidChange'], ['screenReaderChanged', 'touchExplorationDidChange'], ['accessibilityServiceChanged', 'accessibilityServiceDidChange'], ['invertColorsChanged', 'invertColorDidChange'], ['grayscaleChanged', 'grayscaleModeDidChange']]) : new Map([['announcementFinished', 'announcementFinished'], ['boldTextChanged', 'boldTextChanged'], ['change', 'screenReaderChanged'], ['grayscaleChanged', 'grayscaleChanged'], ['invertColorsChanged', 'invertColorsChanged'], ['reduceMotionChanged', 'reduceMotionChanged'], ['reduceTransparencyChanged', 'reduceTransparencyChanged'], ['screenReaderChanged', 'screenReaderChanged'], ['darkerSystemColorsChanged', 'darkerSystemColorsChanged']]);
+  var AccessibilityInfo = {
+    isBoldTextEnabled: function isBoldTextEnabled() {
+      if (_Platform.default.OS === 'android') {
+        return Promise.resolve(false);
+      } else {
+        return new Promise(function (resolve, reject) {
+          if (_NativeAccessibilityManager.default != null) {
+            _NativeAccessibilityManager.default.getCurrentBoldTextState(resolve, reject);
+          } else {
+            reject(null);
+          }
+        });
+      }
+    },
+    isGrayscaleEnabled: function isGrayscaleEnabled() {
+      if (_Platform.default.OS === 'android') {
+        return new Promise(function (resolve, reject) {
+          if ((_NativeAccessibilityInfo.default == null ? void 0 : _NativeAccessibilityInfo.default.isGrayscaleEnabled) != null) {
+            _NativeAccessibilityInfo.default.isGrayscaleEnabled(resolve);
+          } else {
+            reject(null);
+          }
+        });
+      } else {
+        return new Promise(function (resolve, reject) {
+          if (_NativeAccessibilityManager.default != null) {
+            _NativeAccessibilityManager.default.getCurrentGrayscaleState(resolve, reject);
+          } else {
+            reject(null);
+          }
+        });
+      }
+    },
+    isInvertColorsEnabled: function isInvertColorsEnabled() {
+      if (_Platform.default.OS === 'android') {
+        return new Promise(function (resolve, reject) {
+          if ((_NativeAccessibilityInfo.default == null ? void 0 : _NativeAccessibilityInfo.default.isInvertColorsEnabled) != null) {
+            _NativeAccessibilityInfo.default.isInvertColorsEnabled(resolve);
+          } else {
+            reject(null);
+          }
+        });
+      } else {
+        return new Promise(function (resolve, reject) {
+          if (_NativeAccessibilityManager.default != null) {
+            _NativeAccessibilityManager.default.getCurrentInvertColorsState(resolve, reject);
+          } else {
+            reject(null);
+          }
+        });
+      }
+    },
+    isReduceMotionEnabled: function isReduceMotionEnabled() {
+      return new Promise(function (resolve, reject) {
+        if (_Platform.default.OS === 'android') {
+          if (_NativeAccessibilityInfo.default != null) {
+            _NativeAccessibilityInfo.default.isReduceMotionEnabled(resolve);
+          } else {
+            reject(null);
+          }
+        } else {
+          if (_NativeAccessibilityManager.default != null) {
+            _NativeAccessibilityManager.default.getCurrentReduceMotionState(resolve, reject);
+          } else {
+            reject(null);
+          }
+        }
+      });
+    },
+    isHighTextContrastEnabled: function isHighTextContrastEnabled() {
+      return new Promise(function (resolve, reject) {
+        if (_Platform.default.OS === 'android') {
+          if ((_NativeAccessibilityInfo.default == null ? void 0 : _NativeAccessibilityInfo.default.isHighTextContrastEnabled) != null) {
+            _NativeAccessibilityInfo.default.isHighTextContrastEnabled(resolve);
+          } else {
+            reject(null);
+          }
+        } else {
+          return Promise.resolve(false);
+        }
+      });
+    },
+    isDarkerSystemColorsEnabled: function isDarkerSystemColorsEnabled() {
+      return new Promise(function (resolve, reject) {
+        if (_Platform.default.OS === 'android') {
+          return Promise.resolve(false);
+        } else {
+          if ((_NativeAccessibilityManager.default == null ? void 0 : _NativeAccessibilityManager.default.getCurrentDarkerSystemColorsState) != null) {
+            _NativeAccessibilityManager.default.getCurrentDarkerSystemColorsState(resolve, reject);
+          } else {
+            reject(null);
+          }
+        }
+      });
+    },
+    prefersCrossFadeTransitions: function prefersCrossFadeTransitions() {
+      return new Promise(function (resolve, reject) {
+        if (_Platform.default.OS === 'android') {
+          return Promise.resolve(false);
+        } else {
+          if ((_NativeAccessibilityManager.default == null ? void 0 : _NativeAccessibilityManager.default.getCurrentPrefersCrossFadeTransitionsState) != null) {
+            _NativeAccessibilityManager.default.getCurrentPrefersCrossFadeTransitionsState(resolve, reject);
+          } else {
+            reject(null);
+          }
+        }
+      });
+    },
+    isReduceTransparencyEnabled: function isReduceTransparencyEnabled() {
+      if (_Platform.default.OS === 'android') {
+        return Promise.resolve(false);
+      } else {
+        return new Promise(function (resolve, reject) {
+          if (_NativeAccessibilityManager.default != null) {
+            _NativeAccessibilityManager.default.getCurrentReduceTransparencyState(resolve, reject);
+          } else {
+            reject(null);
+          }
+        });
+      }
+    },
+    isScreenReaderEnabled: function isScreenReaderEnabled() {
+      return new Promise(function (resolve, reject) {
+        if (_Platform.default.OS === 'android') {
+          if (_NativeAccessibilityInfo.default != null) {
+            _NativeAccessibilityInfo.default.isTouchExplorationEnabled(resolve);
+          } else {
+            reject(null);
+          }
+        } else {
+          if (_NativeAccessibilityManager.default != null) {
+            _NativeAccessibilityManager.default.getCurrentVoiceOverState(resolve, reject);
+          } else {
+            reject(null);
+          }
+        }
+      });
+    },
+    isAccessibilityServiceEnabled: function isAccessibilityServiceEnabled() {
+      return new Promise(function (resolve, reject) {
+        if (_Platform.default.OS === 'android') {
+          if (_NativeAccessibilityInfo.default != null && _NativeAccessibilityInfo.default.isAccessibilityServiceEnabled != null) {
+            _NativeAccessibilityInfo.default.isAccessibilityServiceEnabled(resolve);
+          } else {
+            reject(null);
+          }
+        } else {
+          reject(null);
+        }
+      });
+    },
+    addEventListener: function addEventListener(eventName, handler) {
+      var deviceEventName = EventNames.get(eventName);
+      return deviceEventName == null ? {
+        remove: function remove() {}
+      } : _RCTDeviceEventEmitter.default.addListener(deviceEventName, handler);
+    },
+    setAccessibilityFocus: function setAccessibilityFocus(reactTag) {
+      (0, _legacySendAccessibilityEvent.default)(reactTag, 'focus');
+    },
+    sendAccessibilityEvent: function sendAccessibilityEvent(handle, eventType) {
+      if (_Platform.default.OS === 'ios' && eventType === 'click') {
+        return;
+      }
+      (0, _$$_REQUIRE(_dependencyMap[6], "../../ReactNative/RendererProxy").sendAccessibilityEvent)(handle, eventType);
+    },
+    announceForAccessibility: function announceForAccessibility(announcement) {
+      if (_Platform.default.OS === 'android') {
+        _NativeAccessibilityInfo.default == null || _NativeAccessibilityInfo.default.announceForAccessibility(announcement);
+      } else {
+        _NativeAccessibilityManager.default == null || _NativeAccessibilityManager.default.announceForAccessibility(announcement);
+      }
+    },
+    announceForAccessibilityWithOptions: function announceForAccessibilityWithOptions(announcement, options) {
+      if (_Platform.default.OS === 'android') {
+        _NativeAccessibilityInfo.default == null || _NativeAccessibilityInfo.default.announceForAccessibility(announcement);
+      } else {
+        if (_NativeAccessibilityManager.default != null && _NativeAccessibilityManager.default.announceForAccessibilityWithOptions) {
+          _NativeAccessibilityManager.default == null || _NativeAccessibilityManager.default.announceForAccessibilityWithOptions(announcement, options);
+        } else {
+          _NativeAccessibilityManager.default == null || _NativeAccessibilityManager.default.announceForAccessibility(announcement);
+        }
+      }
+    },
+    getRecommendedTimeoutMillis: function getRecommendedTimeoutMillis(originalTimeout) {
+      if (_Platform.default.OS === 'android') {
+        return new Promise(function (resolve, reject) {
+          if (_NativeAccessibilityInfo.default != null && _NativeAccessibilityInfo.default.getRecommendedTimeoutMillis) {
+            _NativeAccessibilityInfo.default.getRecommendedTimeoutMillis(originalTimeout, resolve);
+          } else {
+            resolve(originalTimeout);
+          }
+        });
+      } else {
+        return Promise.resolve(originalTimeout);
+      }
+    }
+  };
+  var _default = exports.default = AccessibilityInfo;
+},539,[1,17,68,325,540,326,106],"../../node_modules/react-native/Libraries/Components/AccessibilityInfo/AccessibilityInfo.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeAccessibilityInfo = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../src/private/specs_DEPRECATED/modules/NativeAccessibilityInfo"));
+  Object.keys(_NativeAccessibilityInfo).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeAccessibilityInfo[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeAccessibilityInfo[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeAccessibilityInfo.default;
+},540,[541],"../../node_modules/react-native/Libraries/Components/AccessibilityInfo/NativeAccessibilityInfo.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.get('AccessibilityInfo');
+},541,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeAccessibilityInfo.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../StyleSheet/StyleSheet"));
+  var _LayoutConformanceNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./LayoutConformanceNativeComponent"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[3], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[4], "react/jsx-runtime");
+  var _global,
+    _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Components/LayoutConformance/LayoutConformance.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var isFabricUIManagerInstalled = ((_global = global) == null ? void 0 : _global.nativeFabricUIManager) != null;
+  function LayoutConformance(props) {
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_LayoutConformanceNativeComponent.default, Object.assign({}, props, {
+      style: styles.container
+    }));
+  }
+  function UnimplementedLayoutConformance(props) {
+    if (__DEV__) {
+      var warnOnce = _$$_REQUIRE(_dependencyMap[5], "../../Utilities/warnOnce").default;
+      warnOnce('layoutconformance-unsupported', '"LayoutConformance" is only supported in the New Architecture');
+    }
+    return props.children;
+  }
+  var _default = exports.default = isFabricUIManagerInstalled ? LayoutConformance : UnimplementedLayoutConformance;
+  var styles = _StyleSheet.default.create({
+    container: {
+      display: 'contents'
+    }
+  });
+},542,[1,6,543,73,171,46],"../../node_modules/react-native/Libraries/Components/LayoutConformance/LayoutConformance.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var NativeComponentRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../NativeComponent/NativeComponentRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var LayoutConformanceNativeComponent = NativeComponentRegistry.get('LayoutConformance', function () {
+    return {
+      uiViewClassName: 'LayoutConformance',
+      validAttributes: {
+        mode: true
+      }
+    };
+  });
+  var _default = exports.default = LayoutConformanceNativeComponent;
+},543,[77],"../../node_modules/react-native/Libraries/Components/LayoutConformance/LayoutConformanceNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties"));
+  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/defineProperty"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits"));
+  var _NativeEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../EventEmitter/NativeEventEmitter"));
+  var _NativeModalManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./NativeModalManager"));
+  var _RCTModalHostViewNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./RCTModalHostViewNativeComponent"));
+  var _virtualizedLists = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "@react-native/virtualized-lists"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[12], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[13], "react/jsx-runtime");
+  var _excluded = ["ref"];
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Modal/Modal.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  var VirtualizedListContextResetter = _virtualizedLists.default.VirtualizedListContextResetter;
+  var ModalEventEmitter = "ios" === 'ios' && _NativeModalManager.default != null ? new _NativeEventEmitter.default("ios" !== 'ios' ? null : _NativeModalManager.default) : null;
+  var uniqueModalIdentifier = 0;
+  function confirmProps(props) {
+    if (__DEV__) {
+      if (props.presentationStyle && props.presentationStyle !== 'overFullScreen' && props.transparent === true) {
+        console.warn(`Modal with '${props.presentationStyle}' presentation style and 'transparent' value is not supported.`);
+      }
+      if (props.navigationBarTranslucent === true && props.statusBarTranslucent !== true) {
+        console.warn('Modal with translucent navigation bar and without translucent status bar is not supported.');
+      }
+    }
+  }
+  var Modal = /*#__PURE__*/function (_React$Component) {
+    function Modal(props) {
+      var _this;
+      (0, _classCallCheck2.default)(this, Modal);
+      _this = _callSuper(this, Modal, [props]);
+      if (__DEV__) {
+        confirmProps(props);
+      }
+      _this._identifier = uniqueModalIdentifier++;
+      _this.state = {
+        isRendered: props.visible === true
+      };
+      return _this;
+    }
+    (0, _inherits2.default)(Modal, _React$Component);
+    return (0, _createClass2.default)(Modal, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        var _this2 = this;
+        if (ModalEventEmitter) {
+          this._eventSubscription = ModalEventEmitter.addListener('modalDismissed', function (event) {
+            _this2.setState({
+              isRendered: false
+            }, function () {
+              if (event.modalID === _this2._identifier && _this2.props.onDismiss) {
+                _this2.props.onDismiss();
+              }
+            });
+          });
+        }
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        if ("ios" === 'ios') {
+          this.setState({
+            isRendered: false
+          });
+        }
+        if (this._eventSubscription) {
+          this._eventSubscription.remove();
+        }
+      }
+    }, {
+      key: "componentDidUpdate",
+      value: function componentDidUpdate(prevProps) {
+        if (prevProps.visible === false && this.props.visible === true) {
+          this.setState({
+            isRendered: true
+          });
+        }
+        if (__DEV__) {
+          confirmProps(this.props);
+        }
+      }
+    }, {
+      key: "_shouldShowModal",
+      value: function _shouldShowModal() {
+        if ("ios" === 'ios') {
+          return this.props.visible === true || this.state.isRendered === true;
+        }
+        return this.props.visible === true;
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props$backdropC,
+          _this3 = this;
+        if (!this._shouldShowModal()) {
+          return null;
+        }
+        var containerStyles = {
+          backgroundColor: this.props.transparent === true ? 'transparent' : (_this$props$backdropC = this.props.backdropColor) != null ? _this$props$backdropC : 'white'
+        };
+        var animationType = this.props.animationType || 'none';
+        var presentationStyle = this.props.presentationStyle;
+        if (!presentationStyle) {
+          presentationStyle = 'fullScreen';
+          if (this.props.transparent === true) {
+            presentationStyle = 'overFullScreen';
+          }
+        }
+        var innerChildren = __DEV__ ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[14], "../ReactNative/AppContainer").default, {
+          rootTag: this.context,
+          children: this.props.children
+        }) : this.props.children;
+        var onDismiss = function onDismiss() {
+          if ("ios" === 'ios') {
+            _this3.setState({
+              isRendered: false
+            }, function () {
+              if (_this3.props.onDismiss) {
+                _this3.props.onDismiss();
+              }
+            });
+          }
+        };
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(_RCTModalHostViewNativeComponent.default, {
+          animationType: animationType,
+          presentationStyle: presentationStyle,
+          transparent: this.props.transparent,
+          hardwareAccelerated: this.props.hardwareAccelerated,
+          onRequestClose: this.props.onRequestClose,
+          onShow: this.props.onShow,
+          onDismiss: onDismiss,
+          ref: this.props.modalRef,
+          visible: this.props.visible,
+          statusBarTranslucent: this.props.statusBarTranslucent,
+          navigationBarTranslucent: this.props.navigationBarTranslucent,
+          identifier: this._identifier,
+          style: styles.modal,
+          onStartShouldSetResponder: this._shouldSetResponder,
+          supportedOrientations: this.props.supportedOrientations,
+          onOrientationChange: this.props.onOrientationChange,
+          testID: this.props.testID,
+          children: /*#__PURE__*/(0, _jsxRuntime.jsx)(VirtualizedListContextResetter, {
+            children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[15], "../Components/ScrollView/ScrollView").default.Context.Provider, {
+              value: null,
+              children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[16], "../Components/View/View").default, {
+                style: [styles.container, containerStyles],
+                collapsable: false,
+                children: innerChildren
+              })
+            })
+          })
+        });
+      }
+    }, {
+      key: "_shouldSetResponder",
+      value: function _shouldSetResponder() {
+        return true;
+      }
+    }]);
+  }(React.Component);
+  Modal.defaultProps = {
+    visible: true,
+    hardwareAccelerated: false
+  };
+  Modal.contextType = _$$_REQUIRE(_dependencyMap[17], "../ReactNative/RootTag").RootTagContext;
+  var side = _$$_REQUIRE(_dependencyMap[18], "../ReactNative/I18nManager").default.getConstants().isRTL ? 'right' : 'left';
+  var styles = _$$_REQUIRE(_dependencyMap[19], "../StyleSheet/StyleSheet").default.create({
+    modal: {
+      position: 'absolute'
+    },
+    container: (0, _defineProperty2.default)((0, _defineProperty2.default)((0, _defineProperty2.default)({}, side, 0), "top", 0), "flex", 1)
+  });
+  function Wrapper(_ref) {
+    var ref = _ref.ref,
+      props = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(Modal, Object.assign({}, props, {
+      modalRef: ref
+    }));
+  }
+  Wrapper.displayName = 'Modal';
+  Wrapper.Context = VirtualizedListContextResetter;
+  var _default = exports.default = Wrapper;
+},544,[1,4,65,11,12,18,20,23,221,545,547,447,73,171,314,387,71,360,380,6],"../../node_modules/react-native/Libraries/Modal/Modal.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeModalManager = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativeModalManager"));
+  Object.keys(_NativeModalManager).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeModalManager[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeModalManager[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeModalManager.default;
+},545,[546],"../../node_modules/react-native/Libraries/Modal/NativeModalManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.get('ModalManager');
+},546,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeModalManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _RCTModalHostViewNativeComponent = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/components/RCTModalHostViewNativeComponent"));
+  Object.keys(_RCTModalHostViewNativeComponent).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _RCTModalHostViewNativeComponent[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _RCTModalHostViewNativeComponent[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _RCTModalHostViewNativeComponent.default;
+},547,[548],"../../node_modules/react-native/Libraries/Modal/RCTModalHostViewNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = exports.__INTERNAL_VIEW_CONFIG = void 0;
+  var _codegenNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../../../Libraries/Utilities/codegenNativeComponent"));
+  var nativeComponentName = 'RCTModalHostView';
+  var __INTERNAL_VIEW_CONFIG = exports.__INTERNAL_VIEW_CONFIG = {
+    uiViewClassName: "RCTModalHostView",
+    directEventTypes: {
+      topRequestClose: {
+        registrationName: "onRequestClose"
+      },
+      topShow: {
+        registrationName: "onShow"
+      },
+      topDismiss: {
+        registrationName: "onDismiss"
+      },
+      topOrientationChange: {
+        registrationName: "onOrientationChange"
+      }
+    },
+    validAttributes: Object.assign({
+      animationType: true,
+      presentationStyle: true,
+      transparent: true,
+      statusBarTranslucent: true,
+      navigationBarTranslucent: true,
+      hardwareAccelerated: true,
+      visible: true,
+      animated: true,
+      supportedOrientations: true,
+      identifier: true
+    }, _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/NativeComponent/ViewConfigIgnore").ConditionallyIgnoredEventHandlers({
+      onRequestClose: true,
+      onShow: true,
+      onDismiss: true,
+      onOrientationChange: true
+    }))
+  };
+  var _default = exports.default = _$$_REQUIRE(_dependencyMap[3], "react-native/Libraries/NativeComponent/NativeComponentRegistry").get(nativeComponentName, function () {
+    return __INTERNAL_VIEW_CONFIG;
+  });
+},548,[1,319,104,77],"../../node_modules/react-native/src/private/specs_DEPRECATED/components/RCTModalHostViewNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/objectWithoutProperties"));
+  var _usePressability = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../Pressability/usePressability"));
+  var _useMergeRefs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../../Utilities/useMergeRefs"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../View/View"));
+  var _useAndroidRippleForView = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./useAndroidRippleForView"));
+  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "react"));
+  var React = _react;
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[8], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Components/Pressable/Pressable.js";
+  var _excluded = ["accessible", "accessibilityState", "aria-live", "android_disableSound", "android_ripple", "aria-busy", "aria-checked", "aria-disabled", "aria-expanded", "aria-label", "aria-selected", "cancelable", "children", "delayHoverIn", "delayHoverOut", "delayLongPress", "disabled", "focusable", "hitSlop", "onHoverIn", "onHoverOut", "onLongPress", "onPress", "onPressIn", "onPressMove", "onPressOut", "pressRetentionOffset", "style", "testOnly_pressed", "unstable_pressDelay"];
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function Pressable(props, forwardedRef) {
+    var _props$ariaValuemax, _props$accessibilityV, _props$ariaValuemin, _props$accessibilityV2, _props$ariaValuenow, _props$accessibilityV3, _props$ariaValuetext, _props$accessibilityV4, _restProps$ariaModal;
+    var accessible = props.accessible,
+      accessibilityState = props.accessibilityState,
+      ariaLive = props['aria-live'],
+      android_disableSound = props.android_disableSound,
+      android_ripple = props.android_ripple,
+      ariaBusy = props['aria-busy'],
+      ariaChecked = props['aria-checked'],
+      ariaDisabled = props['aria-disabled'],
+      ariaExpanded = props['aria-expanded'],
+      ariaLabel = props['aria-label'],
+      ariaSelected = props['aria-selected'],
+      cancelable = props.cancelable,
+      children = props.children,
+      delayHoverIn = props.delayHoverIn,
+      delayHoverOut = props.delayHoverOut,
+      delayLongPress = props.delayLongPress,
+      disabled = props.disabled,
+      focusable = props.focusable,
+      hitSlop = props.hitSlop,
+      onHoverIn = props.onHoverIn,
+      onHoverOut = props.onHoverOut,
+      onLongPress = props.onLongPress,
+      onPress = props.onPress,
+      _onPressIn = props.onPressIn,
+      _onPressMove = props.onPressMove,
+      _onPressOut = props.onPressOut,
+      pressRetentionOffset = props.pressRetentionOffset,
+      style = props.style,
+      testOnly_pressed = props.testOnly_pressed,
+      unstable_pressDelay = props.unstable_pressDelay,
+      restProps = (0, _objectWithoutProperties2.default)(props, _excluded);
+    var viewRef = (0, _react.useRef)(null);
+    var mergedRef = (0, _useMergeRefs.default)(forwardedRef, viewRef);
+    var android_rippleConfig = (0, _useAndroidRippleForView.default)(android_ripple, viewRef);
+    var _usePressState = usePressState(testOnly_pressed === true),
+      _usePressState2 = (0, _slicedToArray2.default)(_usePressState, 2),
+      pressed = _usePressState2[0],
+      setPressed = _usePressState2[1];
+    var shouldUpdatePressed = typeof children === 'function' || typeof style === 'function';
+    var _accessibilityState = {
+      busy: ariaBusy != null ? ariaBusy : accessibilityState == null ? void 0 : accessibilityState.busy,
+      checked: ariaChecked != null ? ariaChecked : accessibilityState == null ? void 0 : accessibilityState.checked,
+      disabled: ariaDisabled != null ? ariaDisabled : accessibilityState == null ? void 0 : accessibilityState.disabled,
+      expanded: ariaExpanded != null ? ariaExpanded : accessibilityState == null ? void 0 : accessibilityState.expanded,
+      selected: ariaSelected != null ? ariaSelected : accessibilityState == null ? void 0 : accessibilityState.selected
+    };
+    _accessibilityState = disabled != null ? Object.assign({}, _accessibilityState, {
+      disabled: disabled
+    }) : _accessibilityState;
+    var accessibilityValue = {
+      max: (_props$ariaValuemax = props['aria-valuemax']) != null ? _props$ariaValuemax : (_props$accessibilityV = props.accessibilityValue) == null ? void 0 : _props$accessibilityV.max,
+      min: (_props$ariaValuemin = props['aria-valuemin']) != null ? _props$ariaValuemin : (_props$accessibilityV2 = props.accessibilityValue) == null ? void 0 : _props$accessibilityV2.min,
+      now: (_props$ariaValuenow = props['aria-valuenow']) != null ? _props$ariaValuenow : (_props$accessibilityV3 = props.accessibilityValue) == null ? void 0 : _props$accessibilityV3.now,
+      text: (_props$ariaValuetext = props['aria-valuetext']) != null ? _props$ariaValuetext : (_props$accessibilityV4 = props.accessibilityValue) == null ? void 0 : _props$accessibilityV4.text
+    };
+    var accessibilityLiveRegion = ariaLive === 'off' ? 'none' : ariaLive != null ? ariaLive : props.accessibilityLiveRegion;
+    var accessibilityLabel = ariaLabel != null ? ariaLabel : props.accessibilityLabel;
+    var restPropsWithDefaults = Object.assign({}, restProps, android_rippleConfig == null ? void 0 : android_rippleConfig.viewProps, {
+      accessible: accessible !== false,
+      accessibilityViewIsModal: (_restProps$ariaModal = restProps['aria-modal']) != null ? _restProps$ariaModal : restProps.accessibilityViewIsModal,
+      accessibilityLiveRegion: accessibilityLiveRegion,
+      accessibilityLabel: accessibilityLabel,
+      accessibilityState: _accessibilityState,
+      focusable: focusable !== false,
+      accessibilityValue: accessibilityValue,
+      hitSlop: hitSlop
+    });
+    var config = (0, _react.useMemo)(function () {
+      return {
+        cancelable: cancelable,
+        disabled: disabled,
+        hitSlop: hitSlop,
+        pressRectOffset: pressRetentionOffset,
+        android_disableSound: android_disableSound,
+        delayHoverIn: delayHoverIn,
+        delayHoverOut: delayHoverOut,
+        delayLongPress: delayLongPress,
+        delayPressIn: unstable_pressDelay,
+        onHoverIn: onHoverIn,
+        onHoverOut: onHoverOut,
+        onLongPress: onLongPress,
+        onPress: onPress,
+        onPressIn: function onPressIn(event) {
+          if (android_rippleConfig != null) {
+            android_rippleConfig.onPressIn(event);
+          }
+          shouldUpdatePressed && setPressed(true);
+          if (_onPressIn != null) {
+            _onPressIn(event);
+          }
+        },
+        onPressMove: function onPressMove(event) {
+          android_rippleConfig == null || android_rippleConfig.onPressMove(event);
+          if (_onPressMove != null) {
+            _onPressMove(event);
+          }
+        },
+        onPressOut: function onPressOut(event) {
+          if (android_rippleConfig != null) {
+            android_rippleConfig.onPressOut(event);
+          }
+          shouldUpdatePressed && setPressed(false);
+          if (_onPressOut != null) {
+            _onPressOut(event);
+          }
+        }
+      };
+    }, [android_disableSound, android_rippleConfig, cancelable, delayHoverIn, delayHoverOut, delayLongPress, disabled, hitSlop, onHoverIn, onHoverOut, onLongPress, onPress, _onPressIn, _onPressMove, _onPressOut, pressRetentionOffset, setPressed, shouldUpdatePressed, unstable_pressDelay]);
+    var eventHandlers = (0, _usePressability.default)(config);
+    return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_View.default, Object.assign({}, restPropsWithDefaults, eventHandlers, {
+      ref: mergedRef,
+      style: typeof style === 'function' ? style({
+        pressed: pressed
+      }) : style,
+      collapsable: false,
+      children: [typeof children === 'function' ? children({
+        pressed: pressed
+      }) : children, __DEV__ ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[9], "../../Pressability/PressabilityDebug").PressabilityDebugView, {
+        color: "red",
+        hitSlop: hitSlop
+      }) : null]
+    }));
+  }
+  function usePressState(forcePressed) {
+    var _useState = (0, _react.useState)(false),
+      _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+      pressed = _useState2[0],
+      setPressed = _useState2[1];
+    return [pressed || forcePressed, setPressed];
+  }
+  var MemoedPressable = React.memo(React.forwardRef(Pressable));
+  MemoedPressable.displayName = 'Pressable';
+  var _default = exports.default = MemoedPressable;
+},549,[1,34,4,340,364,71,550,73,171,349],"../../node_modules/react-native/Libraries/Components/Pressable/Pressable.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = useAndroidRippleForView;
+  var _processColor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../StyleSheet/processColor"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../Utilities/Platform"));
+  var _View = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../View/View"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "invariant"));
+  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[5], "react"));
+  var React = _react;
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function useAndroidRippleForView(rippleConfig, viewRef) {
+    var _ref = rippleConfig != null ? rippleConfig : {},
+      color = _ref.color,
+      borderless = _ref.borderless,
+      radius = _ref.radius,
+      foreground = _ref.foreground;
+    return (0, _react.useMemo)(function () {
+      if (_Platform.default.OS === 'android' && (color != null || borderless != null || radius != null)) {
+        var processedColor = (0, _processColor.default)(color);
+        (0, _invariant.default)(processedColor == null || typeof processedColor === 'number', 'Unexpected color given for Ripple color');
+        var nativeRippleValue = {
+          type: 'RippleAndroid',
+          color: processedColor,
+          borderless: borderless === true,
+          rippleRadius: radius
+        };
+        return {
+          viewProps: foreground === true ? {
+            nativeForegroundAndroid: nativeRippleValue
+          } : {
+            nativeBackgroundAndroid: nativeRippleValue
+          },
+          onPressIn: function onPressIn(event) {
+            var view = viewRef.current;
+            if (view != null) {
+              var _event$nativeEvent$lo, _event$nativeEvent$lo2;
+              _$$_REQUIRE(_dependencyMap[6], "../View/ViewNativeComponent").Commands.hotspotUpdate(view, (_event$nativeEvent$lo = event.nativeEvent.locationX) != null ? _event$nativeEvent$lo : 0, (_event$nativeEvent$lo2 = event.nativeEvent.locationY) != null ? _event$nativeEvent$lo2 : 0);
+              _$$_REQUIRE(_dependencyMap[6], "../View/ViewNativeComponent").Commands.setPressed(view, true);
+            }
+          },
+          onPressMove: function onPressMove(event) {
+            var view = viewRef.current;
+            if (view != null) {
+              var _event$nativeEvent$lo3, _event$nativeEvent$lo4;
+              _$$_REQUIRE(_dependencyMap[6], "../View/ViewNativeComponent").Commands.hotspotUpdate(view, (_event$nativeEvent$lo3 = event.nativeEvent.locationX) != null ? _event$nativeEvent$lo3 : 0, (_event$nativeEvent$lo4 = event.nativeEvent.locationY) != null ? _event$nativeEvent$lo4 : 0);
+            }
+          },
+          onPressOut: function onPressOut(event) {
+            var view = viewRef.current;
+            if (view != null) {
+              _$$_REQUIRE(_dependencyMap[6], "../View/ViewNativeComponent").Commands.setPressed(view, false);
+            }
+          }
+        };
+      }
+      return null;
+    }, [borderless, color, foreground, radius, viewRef]);
+  }
+},550,[1,57,68,71,32,73,76],"../../node_modules/react-native/Libraries/Components/Pressable/useAndroidRippleForView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));
+  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));
+  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));
+  var _processColor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../../StyleSheet/processColor"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../../Utilities/Platform"));
+  var _NativeStatusBarManagerAndroid = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./NativeStatusBarManagerAndroid"));
+  var _NativeStatusBarManagerIOS = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./NativeStatusBarManagerIOS"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "invariant"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[11], "react"));
+  var _StatusBar, _NativeStatusBarManag;
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+  function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+  function mergePropsStack(propsStack, defaultValues) {
+    return propsStack.reduce(function (prev, cur) {
+      for (var prop in cur) {
+        if (cur[prop] != null) {
+          prev[prop] = cur[prop];
+        }
+      }
+      return prev;
+    }, Object.assign({}, defaultValues));
+  }
+  function createStackEntry(props) {
+    var _props$animated, _props$showHideTransi;
+    var animated = (_props$animated = props.animated) != null ? _props$animated : false;
+    var showHideTransition = (_props$showHideTransi = props.showHideTransition) != null ? _props$showHideTransi : 'fade';
+    return {
+      backgroundColor: props.backgroundColor != null ? {
+        value: props.backgroundColor,
+        animated: animated
+      } : null,
+      barStyle: props.barStyle != null ? {
+        value: props.barStyle,
+        animated: animated
+      } : null,
+      translucent: props.translucent,
+      hidden: props.hidden != null ? {
+        value: props.hidden,
+        animated: animated,
+        transition: showHideTransition
+      } : null,
+      networkActivityIndicatorVisible: props.networkActivityIndicatorVisible
+    };
+  }
+  var StatusBar = /*#__PURE__*/function (_React$Component) {
+    function StatusBar() {
+      var _this;
+      (0, _classCallCheck2.default)(this, StatusBar);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _callSuper(this, StatusBar, [].concat(args));
+      _this._stackEntry = null;
+      return _this;
+    }
+    (0, _inherits2.default)(StatusBar, _React$Component);
+    return (0, _createClass2.default)(StatusBar, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        this._stackEntry = StatusBar.pushStackEntry(this.props);
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        if (this._stackEntry != null) {
+          StatusBar.popStackEntry(this._stackEntry);
+        }
+      }
+    }, {
+      key: "componentDidUpdate",
+      value: function componentDidUpdate() {
+        if (this._stackEntry != null) {
+          this._stackEntry = StatusBar.replaceStackEntry(this._stackEntry, this.props);
+        }
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        return null;
+      }
+    }], [{
+      key: "setHidden",
+      value: function setHidden(hidden, animation) {
+        animation = animation || 'none';
+        StatusBar._defaultProps.hidden.value = hidden;
+        if (_Platform.default.OS === 'ios') {
+          _NativeStatusBarManagerIOS.default.setHidden(hidden, animation);
+        } else if (_Platform.default.OS === 'android') {
+          _NativeStatusBarManagerAndroid.default.setHidden(hidden);
+        }
+      }
+    }, {
+      key: "setBarStyle",
+      value: function setBarStyle(style, animated) {
+        animated = animated || false;
+        StatusBar._defaultProps.barStyle.value = style;
+        if (_Platform.default.OS === 'ios') {
+          _NativeStatusBarManagerIOS.default.setStyle(style, animated);
+        } else if (_Platform.default.OS === 'android') {
+          _NativeStatusBarManagerAndroid.default.setStyle(style);
+        }
+      }
+    }, {
+      key: "setNetworkActivityIndicatorVisible",
+      value: function setNetworkActivityIndicatorVisible(visible) {
+        if (_Platform.default.OS !== 'ios') {
+          console.warn('`setNetworkActivityIndicatorVisible` is only available on iOS');
+          return;
+        }
+        StatusBar._defaultProps.networkActivityIndicatorVisible = visible;
+        _NativeStatusBarManagerIOS.default.setNetworkActivityIndicatorVisible(visible);
+      }
+    }, {
+      key: "setBackgroundColor",
+      value: function setBackgroundColor(color, animated) {
+        if (_Platform.default.OS !== 'android') {
+          console.warn('`setBackgroundColor` is only available on Android');
+          return;
+        }
+        animated = animated || false;
+        StatusBar._defaultProps.backgroundColor.value = color;
+        var processedColor = (0, _processColor.default)(color);
+        if (processedColor == null) {
+          console.warn(`\`StatusBar.setBackgroundColor\`: Color ${String(color)} parsed to null or undefined`);
+          return;
+        }
+        (0, _invariant.default)(typeof processedColor === 'number', 'Unexpected color given for StatusBar.setBackgroundColor');
+        _NativeStatusBarManagerAndroid.default.setColor(processedColor, animated);
+      }
+    }, {
+      key: "setTranslucent",
+      value: function setTranslucent(translucent) {
+        if (_Platform.default.OS !== 'android') {
+          console.warn('`setTranslucent` is only available on Android');
+          return;
+        }
+        StatusBar._defaultProps.translucent = translucent;
+        _NativeStatusBarManagerAndroid.default.setTranslucent(translucent);
+      }
+    }, {
+      key: "pushStackEntry",
+      value: function pushStackEntry(props) {
+        var entry = createStackEntry(props);
+        StatusBar._propsStack.push(entry);
+        StatusBar._updatePropsStack();
+        return entry;
+      }
+    }, {
+      key: "popStackEntry",
+      value: function popStackEntry(entry) {
+        var index = StatusBar._propsStack.indexOf(entry);
+        if (index !== -1) {
+          StatusBar._propsStack.splice(index, 1);
+        }
+        StatusBar._updatePropsStack();
+      }
+    }, {
+      key: "replaceStackEntry",
+      value: function replaceStackEntry(entry, props) {
+        var newEntry = createStackEntry(props);
+        var index = StatusBar._propsStack.indexOf(entry);
+        if (index !== -1) {
+          StatusBar._propsStack[index] = newEntry;
+        }
+        StatusBar._updatePropsStack();
+        return newEntry;
+      }
+    }]);
+  }(React.Component);
+  _StatusBar = StatusBar;
+  StatusBar._propsStack = [];
+  StatusBar._defaultProps = createStackEntry({
+    backgroundColor: _Platform.default.OS === 'android' ? (_NativeStatusBarManag = _NativeStatusBarManagerAndroid.default.getConstants().DEFAULT_BACKGROUND_COLOR) != null ? _NativeStatusBarManag : 'black' : 'black',
+    barStyle: 'default',
+    translucent: false,
+    hidden: false,
+    networkActivityIndicatorVisible: false
+  });
+  StatusBar._updateImmediate = null;
+  StatusBar._currentValues = null;
+  StatusBar.currentHeight = _Platform.default.OS === 'android' ? _NativeStatusBarManagerAndroid.default.getConstants().HEIGHT : null;
+  StatusBar._updatePropsStack = function () {
+    clearImmediate(_StatusBar._updateImmediate);
+    _StatusBar._updateImmediate = setImmediate(function () {
+      var oldProps = _StatusBar._currentValues;
+      var mergedProps = mergePropsStack(_StatusBar._propsStack, _StatusBar._defaultProps);
+      if (_Platform.default.OS === 'ios') {
+        var _oldProps$barStyle, _oldProps$hidden;
+        if (!oldProps || ((_oldProps$barStyle = oldProps.barStyle) == null ? void 0 : _oldProps$barStyle.value) !== mergedProps.barStyle.value) {
+          _NativeStatusBarManagerIOS.default.setStyle(mergedProps.barStyle.value, mergedProps.barStyle.animated || false);
+        }
+        if (!oldProps || ((_oldProps$hidden = oldProps.hidden) == null ? void 0 : _oldProps$hidden.value) !== mergedProps.hidden.value) {
+          _NativeStatusBarManagerIOS.default.setHidden(mergedProps.hidden.value, mergedProps.hidden.animated ? mergedProps.hidden.transition : 'none');
+        }
+        if (!oldProps || oldProps.networkActivityIndicatorVisible !== mergedProps.networkActivityIndicatorVisible) {
+          _NativeStatusBarManagerIOS.default.setNetworkActivityIndicatorVisible(mergedProps.networkActivityIndicatorVisible);
+        }
+      } else if (_Platform.default.OS === 'android') {
+        var _oldProps$hidden2;
+        _NativeStatusBarManagerAndroid.default.setStyle(mergedProps.barStyle.value);
+        var processedColor = (0, _processColor.default)(mergedProps.backgroundColor.value);
+        if (processedColor == null) {
+          console.warn(`\`StatusBar._updatePropsStack\`: Color ${mergedProps.backgroundColor.value} parsed to null or undefined`);
+        } else {
+          (0, _invariant.default)(typeof processedColor === 'number', 'Unexpected color given in StatusBar._updatePropsStack');
+          _NativeStatusBarManagerAndroid.default.setColor(processedColor, mergedProps.backgroundColor.animated);
+        }
+        if (!oldProps || ((_oldProps$hidden2 = oldProps.hidden) == null ? void 0 : _oldProps$hidden2.value) !== mergedProps.hidden.value) {
+          _NativeStatusBarManagerAndroid.default.setHidden(mergedProps.hidden.value);
+        }
+        if (!oldProps || oldProps.translucent !== mergedProps.translucent || mergedProps.translucent) {
+          _NativeStatusBarManagerAndroid.default.setTranslucent(mergedProps.translucent);
+        }
+      }
+      _StatusBar._currentValues = mergedProps;
+    });
+  };
+  var _default = exports.default = StatusBar;
+},551,[1,11,12,18,20,23,57,68,552,554,32,73],"../../node_modules/react-native/Libraries/Components/StatusBar/StatusBar.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeStatusBarManagerAndroid = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../src/private/specs_DEPRECATED/modules/NativeStatusBarManagerAndroid"));
+  Object.keys(_NativeStatusBarManagerAndroid).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeStatusBarManagerAndroid[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeStatusBarManagerAndroid[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeStatusBarManagerAndroid.default;
+},552,[553],"../../node_modules/react-native/Libraries/Components/StatusBar/NativeStatusBarManagerAndroid.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var NativeModule = TurboModuleRegistry.getEnforcing('StatusBarManager');
+  var constants = null;
+  var NativeStatusBarManager = {
+    getConstants: function getConstants() {
+      if (constants == null) {
+        constants = NativeModule.getConstants();
+      }
+      return constants;
+    },
+    setColor: function setColor(color, animated) {
+      NativeModule.setColor(color, animated);
+    },
+    setTranslucent: function setTranslucent(translucent) {
+      NativeModule.setTranslucent(translucent);
+    },
+    setStyle: function setStyle(statusBarStyle) {
+      NativeModule.setStyle(statusBarStyle);
+    },
+    setHidden: function setHidden(hidden) {
+      NativeModule.setHidden(hidden);
+    }
+  };
+  var _default = exports.default = NativeStatusBarManager;
+},553,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeStatusBarManagerAndroid.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeStatusBarManagerIOS = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../src/private/specs_DEPRECATED/modules/NativeStatusBarManagerIOS"));
+  Object.keys(_NativeStatusBarManagerIOS).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeStatusBarManagerIOS[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeStatusBarManagerIOS[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeStatusBarManagerIOS.default;
+},554,[555],"../../node_modules/react-native/Libraries/Components/StatusBar/NativeStatusBarManagerIOS.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var NativeModule = TurboModuleRegistry.getEnforcing('StatusBarManager');
+  var constants = null;
+  var NativeStatusBarManager = {
+    getConstants: function getConstants() {
+      if (constants == null) {
+        constants = NativeModule.getConstants();
+      }
+      return constants;
+    },
+    getHeight: function getHeight(callback) {
+      NativeModule.getHeight(callback);
+    },
+    setNetworkActivityIndicatorVisible: function setNetworkActivityIndicatorVisible(visible) {
+      NativeModule.setNetworkActivityIndicatorVisible(visible);
+    },
+    addListener: function addListener(eventType) {
+      NativeModule.addListener(eventType);
+    },
+    removeListeners: function removeListeners(count) {
+      NativeModule.removeListeners(count);
+    },
+    setStyle: function setStyle(statusBarStyle, animated) {
+      NativeModule.setStyle(statusBarStyle, animated);
+    },
+    setHidden: function setHidden(hidden, withAnimation) {
+      NativeModule.setHidden(hidden, withAnimation);
+    }
+  };
+  var _default = exports.default = NativeStatusBarManager;
+},555,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeStatusBarManagerIOS.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));
+  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/objectWithoutProperties"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/StyleSheet"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../../Utilities/Platform"));
+  var _useMergeRefs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../../Utilities/useMergeRefs"));
+  var _AndroidSwitchNativeComponent = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[6], "./AndroidSwitchNativeComponent"));
+  var _SwitchNativeComponent = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "./SwitchNativeComponent"));
+  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[8], "react"));
+  var React = _react;
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[9], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Components/Switch/Switch.js";
+  var _excluded = ["disabled", "ios_backgroundColor", "onChange", "onValueChange", "style", "thumbColor", "trackColor", "value"],
+    _excluded2 = ["onTintColor", "tintColor"];
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var returnsFalse = function returnsFalse() {
+    return false;
+  };
+  var returnsTrue = function returnsTrue() {
+    return true;
+  };
+  var Switch = React.forwardRef(function Switch(props, forwardedRef) {
+    var disabled = props.disabled,
+      ios_backgroundColor = props.ios_backgroundColor,
+      onChange = props.onChange,
+      onValueChange = props.onValueChange,
+      style = props.style,
+      thumbColor = props.thumbColor,
+      trackColor = props.trackColor,
+      value = props.value,
+      restProps = (0, _objectWithoutProperties2.default)(props, _excluded);
+    var trackColorForFalse = trackColor == null ? void 0 : trackColor.false;
+    var trackColorForTrue = trackColor == null ? void 0 : trackColor.true;
+    var nativeSwitchRef = (0, _react.useRef)(null);
+    var ref = (0, _useMergeRefs.default)(nativeSwitchRef, forwardedRef);
+    var _useState = (0, _react.useState)({
+        value: null
+      }),
+      _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+      native = _useState2[0],
+      setNative = _useState2[1];
+    var handleChange = function handleChange(event) {
+      onChange == null || onChange(event);
+      onValueChange == null || onValueChange(event.nativeEvent.value);
+      setNative({
+        value: event.nativeEvent.value
+      });
+    };
+    (0, _react.useLayoutEffect)(function () {
+      var _nativeSwitchRef$curr;
+      var jsValue = value === true;
+      var shouldUpdateNativeSwitch = native.value != null && native.value !== jsValue;
+      if (shouldUpdateNativeSwitch && ((_nativeSwitchRef$curr = nativeSwitchRef.current) == null ? void 0 : _nativeSwitchRef$curr.setNativeProps) != null) {
+        if (_Platform.default.OS === 'android') {
+          _AndroidSwitchNativeComponent.Commands.setNativeValue(nativeSwitchRef.current, jsValue);
+        } else {
+          _SwitchNativeComponent.Commands.setValue(nativeSwitchRef.current, jsValue);
+        }
+      }
+    }, [value, native]);
+    if (_Platform.default.OS === 'android') {
+      var _props$accessibilityR;
+      var onTintColor = restProps.onTintColor,
+        tintColor = restProps.tintColor,
+        androidProps = (0, _objectWithoutProperties2.default)(restProps, _excluded2);
+      var accessibilityState = androidProps.accessibilityState;
+      var _disabled = disabled != null ? disabled : accessibilityState == null ? void 0 : accessibilityState.disabled;
+      var _accessibilityState = _disabled !== (accessibilityState == null ? void 0 : accessibilityState.disabled) ? Object.assign({}, accessibilityState, {
+        disabled: _disabled
+      }) : accessibilityState;
+      var platformProps = {
+        accessibilityState: _accessibilityState,
+        enabled: _disabled !== true,
+        on: value === true,
+        style: style,
+        thumbTintColor: thumbColor,
+        trackColorForFalse: trackColorForFalse,
+        trackColorForTrue: trackColorForTrue,
+        trackTintColor: value === true ? trackColorForTrue : trackColorForFalse
+      };
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(_AndroidSwitchNativeComponent.default, Object.assign({}, androidProps, platformProps, {
+        accessibilityRole: (_props$accessibilityR = props.accessibilityRole) != null ? _props$accessibilityR : 'switch',
+        onChange: handleChange,
+        onResponderTerminationRequest: returnsFalse,
+        onStartShouldSetResponder: returnsTrue,
+        ref: ref
+      }));
+    } else {
+      var _props$accessibilityR2;
+      var _platformProps = {
+        disabled: disabled,
+        onTintColor: trackColorForTrue,
+        style: _StyleSheet.default.compose({
+          height: 31,
+          width: 51
+        }, _StyleSheet.default.compose(style, ios_backgroundColor == null ? null : {
+          backgroundColor: ios_backgroundColor,
+          borderRadius: 16
+        })),
+        thumbTintColor: thumbColor,
+        tintColor: trackColorForFalse,
+        value: value === true
+      };
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(_SwitchNativeComponent.default, Object.assign({}, restProps, _platformProps, {
+        accessibilityRole: (_props$accessibilityR2 = props.accessibilityRole) != null ? _props$accessibilityR2 : 'switch',
+        onChange: handleChange,
+        onResponderTerminationRequest: returnsFalse,
+        onStartShouldSetResponder: returnsTrue,
+        ref: ref
+      }));
+    }
+  });
+  var _default = exports.default = Switch;
+},556,[1,34,4,6,68,364,557,559,73,171],"../../node_modules/react-native/Libraries/Components/Switch/Switch.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _AndroidSwitchNativeComponent = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../src/private/specs_DEPRECATED/components/AndroidSwitchNativeComponent"));
+  Object.keys(_AndroidSwitchNativeComponent).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _AndroidSwitchNativeComponent[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _AndroidSwitchNativeComponent[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _AndroidSwitchNativeComponent.default;
+},557,[558],"../../node_modules/react-native/Libraries/Components/Switch/AndroidSwitchNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = exports.__INTERNAL_VIEW_CONFIG = exports.Commands = void 0;
+  var _codegenNativeCommands = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../../../Libraries/Utilities/codegenNativeCommands"));
+  var _codegenNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../../../Libraries/Utilities/codegenNativeComponent"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[3], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var nativeComponentName = 'AndroidSwitch';
+  var __INTERNAL_VIEW_CONFIG = exports.__INTERNAL_VIEW_CONFIG = {
+    uiViewClassName: "AndroidSwitch",
+    bubblingEventTypes: {
+      topChange: {
+        phasedRegistrationNames: {
+          captured: "onChangeCapture",
+          bubbled: "onChange"
+        }
+      }
+    },
+    validAttributes: Object.assign({
+      disabled: true,
+      enabled: true,
+      thumbColor: {
+        process: _$$_REQUIRE(_dependencyMap[4], "react-native/Libraries/StyleSheet/processColor").default
+      },
+      trackColorForFalse: {
+        process: _$$_REQUIRE(_dependencyMap[4], "react-native/Libraries/StyleSheet/processColor").default
+      },
+      trackColorForTrue: {
+        process: _$$_REQUIRE(_dependencyMap[4], "react-native/Libraries/StyleSheet/processColor").default
+      },
+      value: true,
+      on: true,
+      thumbTintColor: {
+        process: _$$_REQUIRE(_dependencyMap[4], "react-native/Libraries/StyleSheet/processColor").default
+      },
+      trackTintColor: {
+        process: _$$_REQUIRE(_dependencyMap[4], "react-native/Libraries/StyleSheet/processColor").default
+      }
+    }, _$$_REQUIRE(_dependencyMap[5], "react-native/Libraries/NativeComponent/ViewConfigIgnore").ConditionallyIgnoredEventHandlers({
+      onChange: true
+    }))
+  };
+  var _default = exports.default = _$$_REQUIRE(_dependencyMap[6], "react-native/Libraries/NativeComponent/NativeComponentRegistry").get(nativeComponentName, function () {
+    return __INTERNAL_VIEW_CONFIG;
+  });
+  var Commands = exports.Commands = {
+    setNativeValue: function setNativeValue(ref, value) {
+      _$$_REQUIRE(_dependencyMap[7], "react-native/Libraries/ReactNative/RendererProxy").dispatchCommand(ref, "setNativeValue", [value]);
+    }
+  };
+},558,[1,105,319,73,57,104,77,106],"../../node_modules/react-native/src/private/specs_DEPRECATED/components/AndroidSwitchNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _SwitchNativeComponent = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../src/private/specs_DEPRECATED/components/SwitchNativeComponent"));
+  Object.keys(_SwitchNativeComponent).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _SwitchNativeComponent[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _SwitchNativeComponent[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _SwitchNativeComponent.default;
+},559,[560],"../../node_modules/react-native/Libraries/Components/Switch/SwitchNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = exports.__INTERNAL_VIEW_CONFIG = exports.Commands = void 0;
+  var _codegenNativeCommands = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../../../Libraries/Utilities/codegenNativeCommands"));
+  var _codegenNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../../../Libraries/Utilities/codegenNativeComponent"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[3], "react"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var nativeComponentName = 'RCTSwitch';
+  var __INTERNAL_VIEW_CONFIG = exports.__INTERNAL_VIEW_CONFIG = {
+    uiViewClassName: "RCTSwitch",
+    bubblingEventTypes: {
+      topChange: {
+        phasedRegistrationNames: {
+          captured: "onChangeCapture",
+          bubbled: "onChange"
+        }
+      }
+    },
+    validAttributes: Object.assign({
+      disabled: true,
+      value: true,
+      tintColor: {
+        process: _$$_REQUIRE(_dependencyMap[4], "react-native/Libraries/StyleSheet/processColor").default
+      },
+      onTintColor: {
+        process: _$$_REQUIRE(_dependencyMap[4], "react-native/Libraries/StyleSheet/processColor").default
+      },
+      thumbTintColor: {
+        process: _$$_REQUIRE(_dependencyMap[4], "react-native/Libraries/StyleSheet/processColor").default
+      },
+      thumbColor: {
+        process: _$$_REQUIRE(_dependencyMap[4], "react-native/Libraries/StyleSheet/processColor").default
+      },
+      trackColorForFalse: {
+        process: _$$_REQUIRE(_dependencyMap[4], "react-native/Libraries/StyleSheet/processColor").default
+      },
+      trackColorForTrue: {
+        process: _$$_REQUIRE(_dependencyMap[4], "react-native/Libraries/StyleSheet/processColor").default
+      }
+    }, _$$_REQUIRE(_dependencyMap[5], "react-native/Libraries/NativeComponent/ViewConfigIgnore").ConditionallyIgnoredEventHandlers({
+      onChange: true
+    }))
+  };
+  var _default = exports.default = _$$_REQUIRE(_dependencyMap[6], "react-native/Libraries/NativeComponent/NativeComponentRegistry").get(nativeComponentName, function () {
+    return __INTERNAL_VIEW_CONFIG;
+  });
+  var Commands = exports.Commands = {
+    setValue: function setValue(ref, value) {
+      _$$_REQUIRE(_dependencyMap[7], "react-native/Libraries/ReactNative/RendererProxy").dispatchCommand(ref, "setValue", [value]);
+    }
+  };
+},560,[1,105,319,73,57,104,77,106],"../../node_modules/react-native/src/private/specs_DEPRECATED/components/SwitchNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties"));
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/slicedToArray"));
+  var _usePressability2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../Pressability/usePressability"));
+  var _flattenStyle = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../../StyleSheet/flattenStyle"));
+  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../../StyleSheet/StyleSheet"));
+  var _Text = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../../Text/Text"));
+  var _TextAncestor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../../Text/TextAncestor"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../../Utilities/Platform"));
+  var _useMergeRefs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "../../Utilities/useMergeRefs"));
+  var _TextInputState = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./TextInputState"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "invariant"));
+  var _nullthrows = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "nullthrows"));
+  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[13], "react"));
+  var React = _react;
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[14], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Components/TextInput/TextInput.js";
+  var _excluded = ["aria-busy", "aria-checked", "aria-disabled", "aria-expanded", "aria-selected", "accessibilityState", "id", "tabIndex", "selection", "selectionColor", "selectionHandleColor", "cursorColor"],
+    _excluded2 = ["onBlur", "onFocus"],
+    _excluded3 = ["allowFontScaling", "rejectResponderTermination", "underlineColorAndroid", "autoComplete", "textContentType", "readOnly", "editable", "enterKeyHint", "returnKeyType", "inputMode", "showSoftInputOnFocus", "keyboardType"];
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var AndroidTextInput;
+  var AndroidTextInputCommands;
+  var RCTSinglelineTextInputView;
+  var RCTSinglelineTextInputNativeCommands;
+  var RCTMultilineTextInputView;
+  var RCTMultilineTextInputNativeCommands;
+  if (_Platform.default.OS === 'android') {
+    AndroidTextInput = _$$_REQUIRE(_dependencyMap[15], "./AndroidTextInputNativeComponent").default;
+    AndroidTextInputCommands = _$$_REQUIRE(_dependencyMap[15], "./AndroidTextInputNativeComponent").Commands;
+  } else if (_Platform.default.OS === 'ios') {
+    RCTSinglelineTextInputView = _$$_REQUIRE(_dependencyMap[16], "./RCTSingelineTextInputNativeComponent").default;
+    RCTSinglelineTextInputNativeCommands = _$$_REQUIRE(_dependencyMap[16], "./RCTSingelineTextInputNativeComponent").Commands;
+    RCTMultilineTextInputView = _$$_REQUIRE(_dependencyMap[17], "./RCTMultilineTextInputNativeComponent").default;
+    RCTMultilineTextInputNativeCommands = _$$_REQUIRE(_dependencyMap[17], "./RCTMultilineTextInputNativeComponent").Commands;
+  }
+  var emptyFunctionThatReturnsTrue = function emptyFunctionThatReturnsTrue() {
+    return true;
+  };
+  function useTextInputStateSynchronization(_ref) {
+    var props = _ref.props,
+      mostRecentEventCount = _ref.mostRecentEventCount,
+      selection = _ref.selection,
+      inputRef = _ref.inputRef,
+      text = _ref.text,
+      viewCommands = _ref.viewCommands;
+    var _useState = (0, _react.useState)(props.value),
+      _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+      lastNativeText = _useState2[0],
+      setLastNativeText = _useState2[1];
+    var _useState3 = (0, _react.useState)({
+        selection: {
+          start: -1,
+          end: -1
+        },
+        mostRecentEventCount: mostRecentEventCount
+      }),
+      _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
+      lastNativeSelectionState = _useState4[0],
+      setLastNativeSelection = _useState4[1];
+    var lastNativeSelection = lastNativeSelectionState.selection;
+    (0, _react.useLayoutEffect)(function () {
+      var nativeUpdate = {};
+      if (lastNativeText !== props.value && typeof props.value === 'string') {
+        nativeUpdate.text = props.value;
+        setLastNativeText(props.value);
+      }
+      if (selection && lastNativeSelection && (lastNativeSelection.start !== selection.start || lastNativeSelection.end !== selection.end)) {
+        nativeUpdate.selection = selection;
+        setLastNativeSelection({
+          selection: selection,
+          mostRecentEventCount: mostRecentEventCount
+        });
+      }
+      if (Object.keys(nativeUpdate).length === 0) {
+        return;
+      }
+      if (inputRef.current != null) {
+        var _selection$start, _selection$end;
+        viewCommands.setTextAndSelection(inputRef.current, mostRecentEventCount, text, (_selection$start = selection == null ? void 0 : selection.start) != null ? _selection$start : -1, (_selection$end = selection == null ? void 0 : selection.end) != null ? _selection$end : -1);
+      }
+    }, [mostRecentEventCount, inputRef, props.value, props.defaultValue, lastNativeText, selection, lastNativeSelection, text, viewCommands]);
+    return {
+      setLastNativeText: setLastNativeText,
+      setLastNativeSelection: setLastNativeSelection
+    };
+  }
+  function InternalTextInput(props) {
+    var _propsSelection$end, _props$multiline;
+    var ariaBusy = props['aria-busy'],
+      ariaChecked = props['aria-checked'],
+      ariaDisabled = props['aria-disabled'],
+      ariaExpanded = props['aria-expanded'],
+      ariaSelected = props['aria-selected'],
+      accessibilityState = props.accessibilityState,
+      id = props.id,
+      tabIndex = props.tabIndex,
+      propsSelection = props.selection,
+      selectionColor = props.selectionColor,
+      selectionHandleColor = props.selectionHandleColor,
+      cursorColor = props.cursorColor,
+      otherProps = (0, _objectWithoutProperties2.default)(props, _excluded);
+    var inputRef = (0, _react.useRef)(null);
+    var selection = propsSelection == null ? null : {
+      start: propsSelection.start,
+      end: (_propsSelection$end = propsSelection.end) != null ? _propsSelection$end : propsSelection.start
+    };
+    var text = typeof props.value === 'string' ? props.value : typeof props.defaultValue === 'string' ? props.defaultValue : undefined;
+    var viewCommands = AndroidTextInputCommands || (props.multiline === true ? RCTMultilineTextInputNativeCommands : RCTSinglelineTextInputNativeCommands);
+    var _useState5 = (0, _react.useState)(0),
+      _useState6 = (0, _slicedToArray2.default)(_useState5, 2),
+      mostRecentEventCount = _useState6[0],
+      setMostRecentEventCount = _useState6[1];
+    var _useTextInputStateSyn = useTextInputStateSynchronization({
+        props: props,
+        inputRef: inputRef,
+        mostRecentEventCount: mostRecentEventCount,
+        selection: selection,
+        text: text,
+        viewCommands: viewCommands
+      }),
+      setLastNativeText = _useTextInputStateSyn.setLastNativeText,
+      setLastNativeSelection = _useTextInputStateSyn.setLastNativeSelection;
+    (0, _react.useLayoutEffect)(function () {
+      var inputRefValue = inputRef.current;
+      if (inputRefValue != null) {
+        _TextInputState.default.registerInput(inputRefValue);
+        return function () {
+          _TextInputState.default.unregisterInput(inputRefValue);
+          if (_TextInputState.default.currentlyFocusedInput() === inputRefValue) {
+            (0, _nullthrows.default)(inputRefValue).blur();
+          }
+        };
+      }
+    }, []);
+    var setLocalRef = (0, _react.useCallback)(function (instance) {
+      inputRef.current = instance;
+      if (instance != null) {
+        Object.assign(instance, {
+          clear: function clear() {
+            if (inputRef.current != null) {
+              viewCommands.setTextAndSelection(inputRef.current, mostRecentEventCount, '', 0, 0);
+            }
+          },
+          isFocused: function isFocused() {
+            return _TextInputState.default.currentlyFocusedInput() === inputRef.current;
+          },
+          getNativeRef: function getNativeRef() {
+            return inputRef.current;
+          },
+          setSelection: function setSelection(start, end) {
+            if (inputRef.current != null) {
+              viewCommands.setTextAndSelection(inputRef.current, mostRecentEventCount, null, start, end);
+            }
+          }
+        });
+      }
+    }, [mostRecentEventCount, viewCommands]);
+    var ref = (0, _useMergeRefs.default)(setLocalRef, props.forwardedRef);
+    var _onChange = function _onChange(event) {
+      var currentText = event.nativeEvent.text;
+      props.onChange && props.onChange(event);
+      props.onChangeText && props.onChangeText(currentText);
+      if (inputRef.current == null) {
+        return;
+      }
+      setLastNativeText(currentText);
+      setMostRecentEventCount(event.nativeEvent.eventCount);
+    };
+    var _onSelectionChange = function _onSelectionChange(event) {
+      props.onSelectionChange && props.onSelectionChange(event);
+      if (inputRef.current == null) {
+        return;
+      }
+      setLastNativeSelection({
+        selection: event.nativeEvent.selection,
+        mostRecentEventCount: mostRecentEventCount
+      });
+    };
+    var _onFocus = function _onFocus(event) {
+      _TextInputState.default.focusInput(inputRef.current);
+      if (props.onFocus) {
+        props.onFocus(event);
+      }
+    };
+    var _onBlur = function _onBlur(event) {
+      _TextInputState.default.blurInput(inputRef.current);
+      if (props.onBlur) {
+        props.onBlur(event);
+      }
+    };
+    var _onScroll = function _onScroll(event) {
+      props.onScroll && props.onScroll(event);
+    };
+    var textInput = null;
+    var multiline = (_props$multiline = props.multiline) != null ? _props$multiline : false;
+    var submitBehavior;
+    if (props.submitBehavior != null) {
+      if (!multiline && props.submitBehavior === 'newline') {
+        submitBehavior = 'blurAndSubmit';
+      } else {
+        submitBehavior = props.submitBehavior;
+      }
+    } else if (multiline) {
+      if (props.blurOnSubmit === true) {
+        submitBehavior = 'blurAndSubmit';
+      } else {
+        submitBehavior = 'newline';
+      }
+    } else {
+      if (props.blurOnSubmit !== false) {
+        submitBehavior = 'blurAndSubmit';
+      } else {
+        submitBehavior = 'submit';
+      }
+    }
+    var accessible = props.accessible !== false;
+    var focusable = props.focusable !== false;
+    var editable = props.editable,
+      hitSlop = props.hitSlop,
+      _onPress = props.onPress,
+      onPressIn = props.onPressIn,
+      onPressOut = props.onPressOut,
+      rejectResponderTermination = props.rejectResponderTermination;
+    var config = React.useMemo(function () {
+      return {
+        hitSlop: hitSlop,
+        onPress: function onPress(event) {
+          _onPress == null || _onPress(event);
+          if (editable !== false) {
+            if (inputRef.current != null) {
+              inputRef.current.focus();
+            }
+          }
+        },
+        onPressIn: onPressIn,
+        onPressOut: onPressOut,
+        cancelable: _Platform.default.OS === 'ios' ? !rejectResponderTermination : null
+      };
+    }, [editable, hitSlop, _onPress, onPressIn, onPressOut, rejectResponderTermination]);
+    var caretHidden = props.caretHidden;
+    if (_Platform.default.isTesting) {
+      caretHidden = true;
+    }
+    var _usePressability = (0, _usePressability2.default)(config),
+      onBlur = _usePressability.onBlur,
+      onFocus = _usePressability.onFocus,
+      eventHandlers = (0, _objectWithoutProperties2.default)(_usePressability, _excluded2);
+    var _accessibilityState;
+    if (accessibilityState != null || ariaBusy != null || ariaChecked != null || ariaDisabled != null || ariaExpanded != null || ariaSelected != null) {
+      _accessibilityState = {
+        busy: ariaBusy != null ? ariaBusy : accessibilityState == null ? void 0 : accessibilityState.busy,
+        checked: ariaChecked != null ? ariaChecked : accessibilityState == null ? void 0 : accessibilityState.checked,
+        disabled: ariaDisabled != null ? ariaDisabled : accessibilityState == null ? void 0 : accessibilityState.disabled,
+        expanded: ariaExpanded != null ? ariaExpanded : accessibilityState == null ? void 0 : accessibilityState.expanded,
+        selected: ariaSelected != null ? ariaSelected : accessibilityState == null ? void 0 : accessibilityState.selected
+      };
+    }
+    var _style = props.style;
+    var flattenedStyle = (0, _flattenStyle.default)(props.style);
+    if (flattenedStyle != null) {
+      var overrides = null;
+      if (typeof (flattenedStyle == null ? void 0 : flattenedStyle.fontWeight) === 'number') {
+        overrides = overrides || {};
+        overrides.fontWeight = flattenedStyle.fontWeight.toString();
+      }
+      if (flattenedStyle.verticalAlign != null) {
+        overrides = overrides || {};
+        overrides.textAlignVertical = verticalAlignToTextAlignVerticalMap[flattenedStyle.verticalAlign];
+        overrides.verticalAlign = undefined;
+      }
+      if (overrides != null) {
+        _style = [_style, overrides];
+      }
+    }
+    if (_Platform.default.OS === 'ios') {
+      var _props$rows;
+      var RCTTextInputView = props.multiline === true ? RCTMultilineTextInputView : RCTSinglelineTextInputView;
+      var useMultilineDefaultStyle = props.multiline === true && (flattenedStyle == null || flattenedStyle.padding == null && flattenedStyle.paddingVertical == null && flattenedStyle.paddingTop == null);
+      textInput = /*#__PURE__*/(0, _jsxRuntime.jsx)(RCTTextInputView, Object.assign({
+        ref: ref
+      }, otherProps, eventHandlers, {
+        acceptDragAndDropTypes: props.experimental_acceptDragAndDropTypes,
+        accessibilityState: _accessibilityState,
+        accessible: accessible,
+        submitBehavior: submitBehavior,
+        caretHidden: caretHidden,
+        dataDetectorTypes: props.dataDetectorTypes,
+        focusable: tabIndex !== undefined ? !tabIndex : focusable,
+        mostRecentEventCount: mostRecentEventCount,
+        nativeID: id != null ? id : props.nativeID,
+        numberOfLines: (_props$rows = props.rows) != null ? _props$rows : props.numberOfLines,
+        onBlur: _onBlur,
+        onChange: _onChange,
+        onContentSizeChange: props.onContentSizeChange,
+        onFocus: _onFocus,
+        onScroll: _onScroll,
+        onSelectionChange: _onSelectionChange,
+        onSelectionChangeShouldSetResponder: emptyFunctionThatReturnsTrue,
+        selection: selection,
+        selectionColor: selectionColor,
+        style: _StyleSheet.default.compose(useMultilineDefaultStyle ? styles.multilineDefault : null, _style),
+        text: text
+      }));
+    } else if (_Platform.default.OS === 'android') {
+      var _props$ariaLabelledb, _props$placeholder, _props$rows2;
+      var autoCapitalize = props.autoCapitalize || 'sentences';
+      var _accessibilityLabelledBy = (_props$ariaLabelledb = props == null ? void 0 : props['aria-labelledby']) != null ? _props$ariaLabelledb : props == null ? void 0 : props.accessibilityLabelledBy;
+      var placeholder = (_props$placeholder = props.placeholder) != null ? _props$placeholder : '';
+      var children = props.children;
+      var childCount = React.Children.count(children);
+      (0, _invariant.default)(!(props.value != null && childCount), 'Cannot specify both value and children.');
+      if (childCount > 1) {
+        children = /*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+          children: children
+        });
+      }
+      var colorProps = {
+        selectionColor: selectionColor,
+        selectionHandleColor: selectionHandleColor === undefined ? selectionColor : selectionHandleColor,
+        cursorColor: cursorColor === undefined ? selectionColor : cursorColor
+      };
+      textInput = /*#__PURE__*/(0, _jsxRuntime.jsx)(AndroidTextInput, Object.assign({
+        ref: ref
+      }, otherProps, colorProps, eventHandlers, {
+        accessibilityState: _accessibilityState,
+        accessibilityLabelledBy: _accessibilityLabelledBy,
+        accessible: accessible,
+        acceptDragAndDropTypes: props.experimental_acceptDragAndDropTypes,
+        autoCapitalize: autoCapitalize,
+        submitBehavior: submitBehavior,
+        caretHidden: caretHidden,
+        children: children,
+        disableFullscreenUI: props.disableFullscreenUI,
+        focusable: tabIndex !== undefined ? !tabIndex : focusable,
+        mostRecentEventCount: mostRecentEventCount,
+        nativeID: id != null ? id : props.nativeID,
+        numberOfLines: (_props$rows2 = props.rows) != null ? _props$rows2 : props.numberOfLines,
+        onBlur: _onBlur,
+        onChange: _onChange,
+        onFocus: _onFocus,
+        onScroll: _onScroll,
+        onSelectionChange: _onSelectionChange,
+        placeholder: placeholder,
+        style: _style,
+        text: text,
+        textBreakStrategy: props.textBreakStrategy
+      }));
+    }
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_TextAncestor.default.Provider, {
+      value: true,
+      children: textInput
+    });
+  }
+  var enterKeyHintToReturnTypeMap = {
+    enter: 'default',
+    done: 'done',
+    go: 'go',
+    next: 'next',
+    previous: 'previous',
+    search: 'search',
+    send: 'send'
+  };
+  var inputModeToKeyboardTypeMap = {
+    none: 'default',
+    text: 'default',
+    decimal: 'decimal-pad',
+    numeric: 'number-pad',
+    tel: 'phone-pad',
+    search: _Platform.default.OS === 'ios' ? 'web-search' : 'default',
+    email: 'email-address',
+    url: 'url'
+  };
+  var autoCompleteWebToAutoCompleteAndroidMap = {
+    'address-line1': 'postal-address-region',
+    'address-line2': 'postal-address-locality',
+    bday: 'birthdate-full',
+    'bday-day': 'birthdate-day',
+    'bday-month': 'birthdate-month',
+    'bday-year': 'birthdate-year',
+    'cc-csc': 'cc-csc',
+    'cc-exp': 'cc-exp',
+    'cc-exp-month': 'cc-exp-month',
+    'cc-exp-year': 'cc-exp-year',
+    'cc-number': 'cc-number',
+    country: 'postal-address-country',
+    'current-password': 'password',
+    email: 'email',
+    'honorific-prefix': 'name-prefix',
+    'honorific-suffix': 'name-suffix',
+    name: 'name',
+    'additional-name': 'name-middle',
+    'family-name': 'name-family',
+    'given-name': 'name-given',
+    'new-password': 'password-new',
+    off: 'off',
+    'one-time-code': 'sms-otp',
+    'postal-code': 'postal-code',
+    sex: 'gender',
+    'street-address': 'street-address',
+    tel: 'tel',
+    'tel-country-code': 'tel-country-code',
+    'tel-national': 'tel-national',
+    username: 'username'
+  };
+  var autoCompleteWebToTextContentTypeMap = {
+    'address-line1': 'streetAddressLine1',
+    'address-line2': 'streetAddressLine2',
+    bday: 'birthdate',
+    'bday-day': 'birthdateDay',
+    'bday-month': 'birthdateMonth',
+    'bday-year': 'birthdateYear',
+    'cc-csc': 'creditCardSecurityCode',
+    'cc-exp-month': 'creditCardExpirationMonth',
+    'cc-exp-year': 'creditCardExpirationYear',
+    'cc-exp': 'creditCardExpiration',
+    'cc-given-name': 'creditCardGivenName',
+    'cc-additional-name': 'creditCardMiddleName',
+    'cc-family-name': 'creditCardFamilyName',
+    'cc-name': 'creditCardName',
+    'cc-number': 'creditCardNumber',
+    'cc-type': 'creditCardType',
+    'current-password': 'password',
+    country: 'countryName',
+    email: 'emailAddress',
+    name: 'name',
+    'additional-name': 'middleName',
+    'family-name': 'familyName',
+    'given-name': 'givenName',
+    nickname: 'nickname',
+    'honorific-prefix': 'namePrefix',
+    'honorific-suffix': 'nameSuffix',
+    'new-password': 'newPassword',
+    off: 'none',
+    'one-time-code': 'oneTimeCode',
+    organization: 'organizationName',
+    'organization-title': 'jobTitle',
+    'postal-code': 'postalCode',
+    'street-address': 'fullStreetAddress',
+    tel: 'telephoneNumber',
+    url: 'URL',
+    username: 'username'
+  };
+  var ExportedForwardRef = React.forwardRef(function TextInput(_ref2, forwardedRef) {
+    var _autoCompleteWebToAut;
+    var _ref2$allowFontScalin = _ref2.allowFontScaling,
+      allowFontScaling = _ref2$allowFontScalin === void 0 ? true : _ref2$allowFontScalin,
+      _ref2$rejectResponder = _ref2.rejectResponderTermination,
+      rejectResponderTermination = _ref2$rejectResponder === void 0 ? true : _ref2$rejectResponder,
+      _ref2$underlineColorA = _ref2.underlineColorAndroid,
+      underlineColorAndroid = _ref2$underlineColorA === void 0 ? 'transparent' : _ref2$underlineColorA,
+      autoComplete = _ref2.autoComplete,
+      textContentType = _ref2.textContentType,
+      readOnly = _ref2.readOnly,
+      editable = _ref2.editable,
+      enterKeyHint = _ref2.enterKeyHint,
+      returnKeyType = _ref2.returnKeyType,
+      inputMode = _ref2.inputMode,
+      showSoftInputOnFocus = _ref2.showSoftInputOnFocus,
+      keyboardType = _ref2.keyboardType,
+      restProps = (0, _objectWithoutProperties2.default)(_ref2, _excluded3);
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(InternalTextInput, Object.assign({
+      allowFontScaling: allowFontScaling,
+      rejectResponderTermination: rejectResponderTermination,
+      underlineColorAndroid: underlineColorAndroid,
+      editable: readOnly !== undefined ? !readOnly : editable,
+      returnKeyType: enterKeyHint ? enterKeyHintToReturnTypeMap[enterKeyHint] : returnKeyType,
+      keyboardType: inputMode ? inputModeToKeyboardTypeMap[inputMode] : keyboardType,
+      showSoftInputOnFocus: inputMode == null ? showSoftInputOnFocus : inputMode !== 'none',
+      autoComplete: _Platform.default.OS === 'android' ? (_autoCompleteWebToAut = autoCompleteWebToAutoCompleteAndroidMap[autoComplete]) != null ? _autoCompleteWebToAut : autoComplete : undefined,
+      textContentType: textContentType != null ? textContentType : _Platform.default.OS === 'ios' && autoComplete && autoComplete in autoCompleteWebToTextContentTypeMap ? autoCompleteWebToTextContentTypeMap[autoComplete] : textContentType
+    }, restProps, {
+      forwardedRef: forwardedRef
+    }));
+  });
+  ExportedForwardRef.displayName = 'TextInput';
+  ExportedForwardRef.State = {
+    currentlyFocusedInput: _TextInputState.default.currentlyFocusedInput,
+    currentlyFocusedField: _TextInputState.default.currentlyFocusedField,
+    focusTextInput: _TextInputState.default.focusTextInput,
+    blurTextInput: _TextInputState.default.blurTextInput
+  };
+  var styles = _StyleSheet.default.create({
+    multilineDefault: {
+      paddingTop: 5
+    }
+  });
+  var verticalAlignToTextAlignVerticalMap = {
+    auto: 'auto',
+    top: 'top',
+    bottom: 'bottom',
+    middle: 'center'
+  };
+  var _default = exports.default = ExportedForwardRef;
+},561,[1,4,34,340,9,6,352,72,68,364,130,32,80,73,171,133,131,562],"../../node_modules/react-native/Libraries/Components/TextInput/TextInput.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = exports.__INTERNAL_VIEW_CONFIG = exports.Commands = void 0;
+  var NativeComponentRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../NativeComponent/NativeComponentRegistry"));
+  var _codegenNativeCommands = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../Utilities/codegenNativeCommands"));
+  var _RCTTextInputViewConfig = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./RCTTextInputViewConfig"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var Commands = exports.Commands = (0, _codegenNativeCommands.default)({
+    supportedCommands: ['focus', 'blur', 'setTextAndSelection']
+  });
+  var __INTERNAL_VIEW_CONFIG = exports.__INTERNAL_VIEW_CONFIG = Object.assign({
+    uiViewClassName: 'RCTMultilineTextInputView'
+  }, _RCTTextInputViewConfig.default, {
+    validAttributes: Object.assign({}, _RCTTextInputViewConfig.default.validAttributes, {
+      dataDetectorTypes: true
+    })
+  });
+  var MultilineTextInputNativeComponent = NativeComponentRegistry.get('RCTMultilineTextInputView', function () {
+    return __INTERNAL_VIEW_CONFIG;
+  });
+  var _default = exports.default = MultilineTextInputNativeComponent;
+},562,[1,77,105,132],"../../node_modules/react-native/Libraries/Components/TextInput/RCTMultilineTextInputNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties"));
+  var _UIManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../ReactNative/UIManager"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../Utilities/Platform"));
+  var _SoundManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../Sound/SoundManager"));
+  var _BoundingDimensions = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./BoundingDimensions"));
+  var _Position = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./Position"));
+  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "react"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[8], "react/jsx-runtime");
+  var _this2 = this,
+    _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/node_modules/react-native/Libraries/Components/Touchable/Touchable.js";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var extractSingleTouch = function extractSingleTouch(nativeEvent) {
+    var touches = nativeEvent.touches;
+    var changedTouches = nativeEvent.changedTouches;
+    var hasTouches = touches && touches.length > 0;
+    var hasChangedTouches = changedTouches && changedTouches.length > 0;
+    return !hasTouches && hasChangedTouches ? changedTouches[0] : hasTouches ? touches[0] : nativeEvent;
+  };
+  var States = {
+    NOT_RESPONDER: 'NOT_RESPONDER',
+    RESPONDER_INACTIVE_PRESS_IN: 'RESPONDER_INACTIVE_PRESS_IN',
+    RESPONDER_INACTIVE_PRESS_OUT: 'RESPONDER_INACTIVE_PRESS_OUT',
+    RESPONDER_ACTIVE_PRESS_IN: 'RESPONDER_ACTIVE_PRESS_IN',
+    RESPONDER_ACTIVE_PRESS_OUT: 'RESPONDER_ACTIVE_PRESS_OUT',
+    RESPONDER_ACTIVE_LONG_PRESS_IN: 'RESPONDER_ACTIVE_LONG_PRESS_IN',
+    RESPONDER_ACTIVE_LONG_PRESS_OUT: 'RESPONDER_ACTIVE_LONG_PRESS_OUT',
+    ERROR: 'ERROR'
+  };
+  var baseStatesConditions = {
+    NOT_RESPONDER: false,
+    RESPONDER_INACTIVE_PRESS_IN: false,
+    RESPONDER_INACTIVE_PRESS_OUT: false,
+    RESPONDER_ACTIVE_PRESS_IN: false,
+    RESPONDER_ACTIVE_PRESS_OUT: false,
+    RESPONDER_ACTIVE_LONG_PRESS_IN: false,
+    RESPONDER_ACTIVE_LONG_PRESS_OUT: false,
+    ERROR: false
+  };
+  var IsActive = Object.assign({}, baseStatesConditions, {
+    RESPONDER_ACTIVE_PRESS_OUT: true,
+    RESPONDER_ACTIVE_PRESS_IN: true
+  });
+  var IsPressingIn = Object.assign({}, baseStatesConditions, {
+    RESPONDER_INACTIVE_PRESS_IN: true,
+    RESPONDER_ACTIVE_PRESS_IN: true,
+    RESPONDER_ACTIVE_LONG_PRESS_IN: true
+  });
+  var IsLongPressingIn = Object.assign({}, baseStatesConditions, {
+    RESPONDER_ACTIVE_LONG_PRESS_IN: true
+  });
+  var Signals = {
+    DELAY: 'DELAY',
+    RESPONDER_GRANT: 'RESPONDER_GRANT',
+    RESPONDER_RELEASE: 'RESPONDER_RELEASE',
+    RESPONDER_TERMINATED: 'RESPONDER_TERMINATED',
+    ENTER_PRESS_RECT: 'ENTER_PRESS_RECT',
+    LEAVE_PRESS_RECT: 'LEAVE_PRESS_RECT',
+    LONG_PRESS_DETECTED: 'LONG_PRESS_DETECTED'
+  };
+  var Transitions = {
+    NOT_RESPONDER: {
+      DELAY: States.ERROR,
+      RESPONDER_GRANT: States.RESPONDER_INACTIVE_PRESS_IN,
+      RESPONDER_RELEASE: States.ERROR,
+      RESPONDER_TERMINATED: States.ERROR,
+      ENTER_PRESS_RECT: States.ERROR,
+      LEAVE_PRESS_RECT: States.ERROR,
+      LONG_PRESS_DETECTED: States.ERROR
+    },
+    RESPONDER_INACTIVE_PRESS_IN: {
+      DELAY: States.RESPONDER_ACTIVE_PRESS_IN,
+      RESPONDER_GRANT: States.ERROR,
+      RESPONDER_RELEASE: States.NOT_RESPONDER,
+      RESPONDER_TERMINATED: States.NOT_RESPONDER,
+      ENTER_PRESS_RECT: States.RESPONDER_INACTIVE_PRESS_IN,
+      LEAVE_PRESS_RECT: States.RESPONDER_INACTIVE_PRESS_OUT,
+      LONG_PRESS_DETECTED: States.ERROR
+    },
+    RESPONDER_INACTIVE_PRESS_OUT: {
+      DELAY: States.RESPONDER_ACTIVE_PRESS_OUT,
+      RESPONDER_GRANT: States.ERROR,
+      RESPONDER_RELEASE: States.NOT_RESPONDER,
+      RESPONDER_TERMINATED: States.NOT_RESPONDER,
+      ENTER_PRESS_RECT: States.RESPONDER_INACTIVE_PRESS_IN,
+      LEAVE_PRESS_RECT: States.RESPONDER_INACTIVE_PRESS_OUT,
+      LONG_PRESS_DETECTED: States.ERROR
+    },
+    RESPONDER_ACTIVE_PRESS_IN: {
+      DELAY: States.ERROR,
+      RESPONDER_GRANT: States.ERROR,
+      RESPONDER_RELEASE: States.NOT_RESPONDER,
+      RESPONDER_TERMINATED: States.NOT_RESPONDER,
+      ENTER_PRESS_RECT: States.RESPONDER_ACTIVE_PRESS_IN,
+      LEAVE_PRESS_RECT: States.RESPONDER_ACTIVE_PRESS_OUT,
+      LONG_PRESS_DETECTED: States.RESPONDER_ACTIVE_LONG_PRESS_IN
+    },
+    RESPONDER_ACTIVE_PRESS_OUT: {
+      DELAY: States.ERROR,
+      RESPONDER_GRANT: States.ERROR,
+      RESPONDER_RELEASE: States.NOT_RESPONDER,
+      RESPONDER_TERMINATED: States.NOT_RESPONDER,
+      ENTER_PRESS_RECT: States.RESPONDER_ACTIVE_PRESS_IN,
+      LEAVE_PRESS_RECT: States.RESPONDER_ACTIVE_PRESS_OUT,
+      LONG_PRESS_DETECTED: States.ERROR
+    },
+    RESPONDER_ACTIVE_LONG_PRESS_IN: {
+      DELAY: States.ERROR,
+      RESPONDER_GRANT: States.ERROR,
+      RESPONDER_RELEASE: States.NOT_RESPONDER,
+      RESPONDER_TERMINATED: States.NOT_RESPONDER,
+      ENTER_PRESS_RECT: States.RESPONDER_ACTIVE_LONG_PRESS_IN,
+      LEAVE_PRESS_RECT: States.RESPONDER_ACTIVE_LONG_PRESS_OUT,
+      LONG_PRESS_DETECTED: States.RESPONDER_ACTIVE_LONG_PRESS_IN
+    },
+    RESPONDER_ACTIVE_LONG_PRESS_OUT: {
+      DELAY: States.ERROR,
+      RESPONDER_GRANT: States.ERROR,
+      RESPONDER_RELEASE: States.NOT_RESPONDER,
+      RESPONDER_TERMINATED: States.NOT_RESPONDER,
+      ENTER_PRESS_RECT: States.RESPONDER_ACTIVE_LONG_PRESS_IN,
+      LEAVE_PRESS_RECT: States.RESPONDER_ACTIVE_LONG_PRESS_OUT,
+      LONG_PRESS_DETECTED: States.ERROR
+    },
+    error: {
+      DELAY: States.NOT_RESPONDER,
+      RESPONDER_GRANT: States.RESPONDER_INACTIVE_PRESS_IN,
+      RESPONDER_RELEASE: States.NOT_RESPONDER,
+      RESPONDER_TERMINATED: States.NOT_RESPONDER,
+      ENTER_PRESS_RECT: States.NOT_RESPONDER,
+      LEAVE_PRESS_RECT: States.NOT_RESPONDER,
+      LONG_PRESS_DETECTED: States.NOT_RESPONDER
+    }
+  };
+  var HIGHLIGHT_DELAY_MS = 130;
+  var PRESS_EXPAND_PX = 20;
+  var LONG_PRESS_THRESHOLD = 500;
+  var LONG_PRESS_DELAY_MS = LONG_PRESS_THRESHOLD - HIGHLIGHT_DELAY_MS;
+  var LONG_PRESS_ALLOWED_MOVEMENT = 10;
+  var TouchableMixinImpl = {
+    componentDidMount: function componentDidMount() {
+      if (!_Platform.default.isTV) {
+        return;
+      }
+    },
+    componentWillUnmount: function componentWillUnmount() {
+      this.touchableDelayTimeout && clearTimeout(this.touchableDelayTimeout);
+      this.longPressDelayTimeout && clearTimeout(this.longPressDelayTimeout);
+      this.pressOutDelayTimeout && clearTimeout(this.pressOutDelayTimeout);
+    },
+    touchableGetInitialState: function touchableGetInitialState() {
+      return {
+        touchable: {
+          touchState: undefined,
+          responderID: null
+        }
+      };
+    },
+    touchableHandleResponderTerminationRequest: function touchableHandleResponderTerminationRequest() {
+      return !this.props.rejectResponderTermination;
+    },
+    touchableHandleStartShouldSetResponder: function touchableHandleStartShouldSetResponder() {
+      return !this.props.disabled;
+    },
+    touchableLongPressCancelsPress: function touchableLongPressCancelsPress() {
+      return true;
+    },
+    touchableHandleResponderGrant: function touchableHandleResponderGrant(e) {
+      var dispatchID = e.currentTarget;
+      e.persist();
+      this.pressOutDelayTimeout && clearTimeout(this.pressOutDelayTimeout);
+      this.pressOutDelayTimeout = null;
+      this.state.touchable.touchState = States.NOT_RESPONDER;
+      this.state.touchable.responderID = dispatchID;
+      this._receiveSignal(Signals.RESPONDER_GRANT, e);
+      var delayMS = this.touchableGetHighlightDelayMS !== undefined ? Math.max(this.touchableGetHighlightDelayMS(), 0) : HIGHLIGHT_DELAY_MS;
+      delayMS = isNaN(delayMS) ? HIGHLIGHT_DELAY_MS : delayMS;
+      if (delayMS !== 0) {
+        this.touchableDelayTimeout = setTimeout(this._handleDelay.bind(this, e), delayMS);
+      } else {
+        this._handleDelay(e);
+      }
+      var longDelayMS = this.touchableGetLongPressDelayMS !== undefined ? Math.max(this.touchableGetLongPressDelayMS(), 10) : LONG_PRESS_DELAY_MS;
+      longDelayMS = isNaN(longDelayMS) ? LONG_PRESS_DELAY_MS : longDelayMS;
+      this.longPressDelayTimeout = setTimeout(this._handleLongDelay.bind(this, e), longDelayMS + delayMS);
+    },
+    touchableHandleResponderRelease: function touchableHandleResponderRelease(e) {
+      this.pressInLocation = null;
+      this._receiveSignal(Signals.RESPONDER_RELEASE, e);
+    },
+    touchableHandleResponderTerminate: function touchableHandleResponderTerminate(e) {
+      this.pressInLocation = null;
+      this._receiveSignal(Signals.RESPONDER_TERMINATED, e);
+    },
+    touchableHandleResponderMove: function touchableHandleResponderMove(e) {
+      if (!this.state.touchable.positionOnActivate) {
+        return;
+      }
+      var positionOnActivate = this.state.touchable.positionOnActivate;
+      var dimensionsOnActivate = this.state.touchable.dimensionsOnActivate;
+      var pressRectOffset = this.touchableGetPressRectOffset ? this.touchableGetPressRectOffset() : {
+        left: PRESS_EXPAND_PX,
+        right: PRESS_EXPAND_PX,
+        top: PRESS_EXPAND_PX,
+        bottom: PRESS_EXPAND_PX
+      };
+      var pressExpandLeft = pressRectOffset.left;
+      var pressExpandTop = pressRectOffset.top;
+      var pressExpandRight = pressRectOffset.right;
+      var pressExpandBottom = pressRectOffset.bottom;
+      var hitSlop = this.touchableGetHitSlop ? this.touchableGetHitSlop() : null;
+      if (hitSlop) {
+        pressExpandLeft += hitSlop.left || 0;
+        pressExpandTop += hitSlop.top || 0;
+        pressExpandRight += hitSlop.right || 0;
+        pressExpandBottom += hitSlop.bottom || 0;
+      }
+      var touch = extractSingleTouch(e.nativeEvent);
+      var pageX = touch && touch.pageX;
+      var pageY = touch && touch.pageY;
+      if (this.pressInLocation) {
+        var movedDistance = this._getDistanceBetweenPoints(pageX, pageY, this.pressInLocation.pageX, this.pressInLocation.pageY);
+        if (movedDistance > LONG_PRESS_ALLOWED_MOVEMENT) {
+          this._cancelLongPressDelayTimeout();
+        }
+      }
+      var isTouchWithinActive = pageX > positionOnActivate.left - pressExpandLeft && pageY > positionOnActivate.top - pressExpandTop && pageX < positionOnActivate.left + dimensionsOnActivate.width + pressExpandRight && pageY < positionOnActivate.top + dimensionsOnActivate.height + pressExpandBottom;
+      if (isTouchWithinActive) {
+        var prevState = this.state.touchable.touchState;
+        this._receiveSignal(Signals.ENTER_PRESS_RECT, e);
+        var curState = this.state.touchable.touchState;
+        if (curState === States.RESPONDER_INACTIVE_PRESS_IN && prevState !== States.RESPONDER_INACTIVE_PRESS_IN) {
+          this._cancelLongPressDelayTimeout();
+        }
+      } else {
+        this._cancelLongPressDelayTimeout();
+        this._receiveSignal(Signals.LEAVE_PRESS_RECT, e);
+      }
+    },
+    touchableHandleFocus: function touchableHandleFocus(e) {
+      this.props.onFocus && this.props.onFocus(e);
+    },
+    touchableHandleBlur: function touchableHandleBlur(e) {
+      this.props.onBlur && this.props.onBlur(e);
+    },
+    _remeasureMetricsOnActivation: function _remeasureMetricsOnActivation() {
+      var responderID = this.state.touchable.responderID;
+      if (responderID == null) {
+        return;
+      }
+      if (typeof responderID === 'number') {
+        _UIManager.default.measure(responderID, this._handleQueryLayout);
+      } else {
+        responderID.measure(this._handleQueryLayout);
+      }
+    },
+    _handleQueryLayout: function _handleQueryLayout(l, t, w, h, globalX, globalY) {
+      if (!l && !t && !w && !h && !globalX && !globalY) {
+        return;
+      }
+      this.state.touchable.positionOnActivate && _Position.default.release(this.state.touchable.positionOnActivate);
+      this.state.touchable.dimensionsOnActivate && _BoundingDimensions.default.release(this.state.touchable.dimensionsOnActivate);
+      this.state.touchable.positionOnActivate = _Position.default.getPooled(globalX, globalY);
+      this.state.touchable.dimensionsOnActivate = _BoundingDimensions.default.getPooled(w, h);
+    },
+    _handleDelay: function _handleDelay(e) {
+      this.touchableDelayTimeout = null;
+      this._receiveSignal(Signals.DELAY, e);
+    },
+    _handleLongDelay: function _handleLongDelay(e) {
+      this.longPressDelayTimeout = null;
+      var curState = this.state.touchable.touchState;
+      if (curState === States.RESPONDER_ACTIVE_PRESS_IN || curState === States.RESPONDER_ACTIVE_LONG_PRESS_IN) {
+        this._receiveSignal(Signals.LONG_PRESS_DETECTED, e);
+      }
+    },
+    _receiveSignal: function _receiveSignal(signal, e) {
+      var responderID = this.state.touchable.responderID;
+      var curState = this.state.touchable.touchState;
+      var nextState = Transitions[curState] && Transitions[curState][signal];
+      if (!responderID && signal === Signals.RESPONDER_RELEASE) {
+        return;
+      }
+      if (!nextState) {
+        throw new Error('Unrecognized signal `' + signal + '` or state `' + curState + '` for Touchable responder `' + typeof this.state.touchable.responderID === 'number' ? this.state.touchable.responderID : 'host component' + '`');
+      }
+      if (nextState === States.ERROR) {
+        throw new Error('Touchable cannot transition from `' + curState + '` to `' + signal + '` for responder `' + typeof this.state.touchable.responderID === 'number' ? this.state.touchable.responderID : '<<host component>>' + '`');
+      }
+      if (curState !== nextState) {
+        this._performSideEffectsForTransition(curState, nextState, signal, e);
+        this.state.touchable.touchState = nextState;
+      }
+    },
+    _cancelLongPressDelayTimeout: function _cancelLongPressDelayTimeout() {
+      this.longPressDelayTimeout && clearTimeout(this.longPressDelayTimeout);
+      this.longPressDelayTimeout = null;
+    },
+    _isHighlight: function _isHighlight(state) {
+      return state === States.RESPONDER_ACTIVE_PRESS_IN || state === States.RESPONDER_ACTIVE_LONG_PRESS_IN;
+    },
+    _savePressInLocation: function _savePressInLocation(e) {
+      var touch = extractSingleTouch(e.nativeEvent);
+      var pageX = touch && touch.pageX;
+      var pageY = touch && touch.pageY;
+      var locationX = touch && touch.locationX;
+      var locationY = touch && touch.locationY;
+      this.pressInLocation = {
+        pageX: pageX,
+        pageY: pageY,
+        locationX: locationX,
+        locationY: locationY
+      };
+    },
+    _getDistanceBetweenPoints: function _getDistanceBetweenPoints(aX, aY, bX, bY) {
+      var deltaX = aX - bX;
+      var deltaY = aY - bY;
+      return Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+    },
+    _performSideEffectsForTransition: function _performSideEffectsForTransition(curState, nextState, signal, e) {
+      var curIsHighlight = this._isHighlight(curState);
+      var newIsHighlight = this._isHighlight(nextState);
+      var isFinalSignal = signal === Signals.RESPONDER_TERMINATED || signal === Signals.RESPONDER_RELEASE;
+      if (isFinalSignal) {
+        this._cancelLongPressDelayTimeout();
+      }
+      var isInitialTransition = curState === States.NOT_RESPONDER && nextState === States.RESPONDER_INACTIVE_PRESS_IN;
+      var isActiveTransition = !IsActive[curState] && IsActive[nextState];
+      if (isInitialTransition || isActiveTransition) {
+        this._remeasureMetricsOnActivation();
+      }
+      if (IsPressingIn[curState] && signal === Signals.LONG_PRESS_DETECTED) {
+        this.touchableHandleLongPress && this.touchableHandleLongPress(e);
+      }
+      if (newIsHighlight && !curIsHighlight) {
+        this._startHighlight(e);
+      } else if (!newIsHighlight && curIsHighlight) {
+        this._endHighlight(e);
+      }
+      if (IsPressingIn[curState] && signal === Signals.RESPONDER_RELEASE) {
+        var hasLongPressHandler = !!this.props.onLongPress;
+        var pressIsLongButStillCallOnPress = IsLongPressingIn[curState] && (!hasLongPressHandler || !this.touchableLongPressCancelsPress());
+        var shouldInvokePress = !IsLongPressingIn[curState] || pressIsLongButStillCallOnPress;
+        if (shouldInvokePress && this.touchableHandlePress) {
+          if (!newIsHighlight && !curIsHighlight) {
+            this._startHighlight(e);
+            this._endHighlight(e);
+          }
+          if (_Platform.default.OS === 'android' && !this.props.touchSoundDisabled) {
+            _SoundManager.default.playTouchSound();
+          }
+          this.touchableHandlePress(e);
+        }
+      }
+      this.touchableDelayTimeout && clearTimeout(this.touchableDelayTimeout);
+      this.touchableDelayTimeout = null;
+    },
+    _startHighlight: function _startHighlight(e) {
+      this._savePressInLocation(e);
+      this.touchableHandleActivePressIn && this.touchableHandleActivePressIn(e);
+    },
+    _endHighlight: function _endHighlight(e) {
+      var _this = this;
+      if (this.touchableHandleActivePressOut) {
+        if (this.touchableGetPressOutDelayMS && this.touchableGetPressOutDelayMS()) {
+          this.pressOutDelayTimeout = setTimeout(function () {
+            _this.touchableHandleActivePressOut(e);
+          }, this.touchableGetPressOutDelayMS());
+        } else {
+          this.touchableHandleActivePressOut(e);
+        }
+      }
+    },
+    withoutDefaultFocusAndBlur: {}
+  };
+  var touchableHandleFocus = TouchableMixinImpl.touchableHandleFocus,
+    touchableHandleBlur = TouchableMixinImpl.touchableHandleBlur,
+    TouchableMixinWithoutDefaultFocusAndBlur = (0, _objectWithoutProperties2.default)(TouchableMixinImpl, ["touchableHandleFocus", "touchableHandleBlur"]);
+  TouchableMixinImpl.withoutDefaultFocusAndBlur = TouchableMixinWithoutDefaultFocusAndBlur;
+  var TouchableImpl = {
+    Mixin: TouchableMixinImpl,
+    renderDebugView: function renderDebugView(_ref) {
+      var color = _ref.color,
+        hitSlop = _ref.hitSlop;
+      if (__DEV__) {
+        return /*#__PURE__*/(0, _jsxRuntime.jsx)(_$$_REQUIRE(_dependencyMap[9], "../../Pressability/PressabilityDebug").PressabilityDebugView, {
+          color: color,
+          hitSlop: hitSlop
+        });
+      }
+      return null;
+    }
+  };
+  var _default = exports.default = TouchableImpl;
+},563,[1,4,79,68,342,564,566,73,171,349],"../../node_modules/react-native/Libraries/Components/Touchable/Touchable.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _PooledClass = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./PooledClass"));
+  var twoArgumentPooler = _PooledClass.default.twoArgumentPooler;
+  function BoundingDimensions(width, height) {
+    this.width = width;
+    this.height = height;
+  }
+  BoundingDimensions.prototype.destructor = function () {
+    this.width = null;
+    this.height = null;
+  };
+  BoundingDimensions.getPooledFromElement = function (element) {
+    return BoundingDimensions.getPooled(element.offsetWidth, element.offsetHeight);
+  };
+  _PooledClass.default.addPoolingTo(BoundingDimensions, twoArgumentPooler);
+  var _default = exports.default = BoundingDimensions;
+},564,[1,565],"../../node_modules/react-native/Libraries/Components/Touchable/BoundingDimensions.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "invariant"));
+  var oneArgumentPooler = function oneArgumentPooler(copyFieldsFrom) {
+    var Klass = this;
+    if (Klass.instancePool.length) {
+      var _instance = Klass.instancePool.pop();
+      Klass.call(_instance, copyFieldsFrom);
+      return _instance;
+    } else {
+      return new Klass(copyFieldsFrom);
+    }
+  };
+  var twoArgumentPooler = function twoArgumentPooler(a1, a2) {
+    var Klass = this;
+    if (Klass.instancePool.length) {
+      var _instance2 = Klass.instancePool.pop();
+      Klass.call(_instance2, a1, a2);
+      return _instance2;
+    } else {
+      return new Klass(a1, a2);
+    }
+  };
+  var threeArgumentPooler = function threeArgumentPooler(a1, a2, a3) {
+    var Klass = this;
+    if (Klass.instancePool.length) {
+      var _instance3 = Klass.instancePool.pop();
+      Klass.call(_instance3, a1, a2, a3);
+      return _instance3;
+    } else {
+      return new Klass(a1, a2, a3);
+    }
+  };
+  var fourArgumentPooler = function fourArgumentPooler(a1, a2, a3, a4) {
+    var Klass = this;
+    if (Klass.instancePool.length) {
+      var _instance4 = Klass.instancePool.pop();
+      Klass.call(_instance4, a1, a2, a3, a4);
+      return _instance4;
+    } else {
+      return new Klass(a1, a2, a3, a4);
+    }
+  };
+  var standardReleaser = function standardReleaser(instance) {
+    var Klass = this;
+    (0, _invariant.default)(instance instanceof Klass, 'Trying to release an instance into a pool of a different type.');
+    instance.destructor();
+    if (Klass.instancePool.length < Klass.poolSize) {
+      Klass.instancePool.push(instance);
+    }
+  };
+  var DEFAULT_POOL_SIZE = 10;
+  var DEFAULT_POOLER = oneArgumentPooler;
+  var addPoolingTo = function addPoolingTo(CopyConstructor, pooler) {
+    var NewKlass = CopyConstructor;
+    NewKlass.instancePool = [];
+    NewKlass.getPooled = pooler || DEFAULT_POOLER;
+    if (!NewKlass.poolSize) {
+      NewKlass.poolSize = DEFAULT_POOL_SIZE;
+    }
+    NewKlass.release = standardReleaser;
+    return NewKlass;
+  };
+  var PooledClass = {
+    addPoolingTo: addPoolingTo,
+    oneArgumentPooler: oneArgumentPooler,
+    twoArgumentPooler: twoArgumentPooler,
+    threeArgumentPooler: threeArgumentPooler,
+    fourArgumentPooler: fourArgumentPooler
+  };
+  var _default = exports.default = PooledClass;
+},565,[1,32],"../../node_modules/react-native/Libraries/Components/Touchable/PooledClass.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _PooledClass = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./PooledClass"));
+  var twoArgumentPooler = _PooledClass.default.twoArgumentPooler;
+  function Position(left, top) {
+    this.left = left;
+    this.top = top;
+  }
+  Position.prototype.destructor = function () {
+    this.left = null;
+    this.top = null;
+  };
+  _PooledClass.default.addPoolingTo(Position, twoArgumentPooler);
+  var _default = exports.default = Position;
+},566,[1,565],"../../node_modules/react-native/Libraries/Components/Touchable/Position.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _virtualizedLists = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@react-native/virtualized-lists"));
+  var VirtualizedList = _virtualizedLists.default.VirtualizedList;
+  var _default = exports.default = VirtualizedList;
+},567,[1,447],"../../node_modules/react-native/Libraries/Lists/VirtualizedList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _virtualizedLists = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@react-native/virtualized-lists"));
+  var VirtualizedSectionList = _virtualizedLists.default.VirtualizedSectionList;
+  var _default = exports.default = VirtualizedSectionList;
+},568,[1,447],"../../node_modules/react-native/Libraries/Lists/VirtualizedSectionList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties"));
+  var _NativeActionSheetManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./NativeActionSheetManager"));
+  var _excluded = ["tintColor", "cancelButtonTintColor", "disabledButtonTintColor", "destructiveButtonIndex"];
+  var ActionSheetIOS = {
+    showActionSheetWithOptions: function showActionSheetWithOptions(options, callback) {
+      _$$_REQUIRE(_dependencyMap[3], "invariant")(typeof options === 'object' && options !== null, 'Options must be a valid object');
+      _$$_REQUIRE(_dependencyMap[3], "invariant")(typeof callback === 'function', 'Must provide a valid callback');
+      _$$_REQUIRE(_dependencyMap[3], "invariant")(_NativeActionSheetManager.default, "ActionSheetManager doesn't exist");
+      var tintColor = options.tintColor,
+        cancelButtonTintColor = options.cancelButtonTintColor,
+        disabledButtonTintColor = options.disabledButtonTintColor,
+        destructiveButtonIndex = options.destructiveButtonIndex,
+        remainingOptions = (0, _objectWithoutProperties2.default)(options, _excluded);
+      var destructiveButtonIndices = null;
+      if (Array.isArray(destructiveButtonIndex)) {
+        destructiveButtonIndices = destructiveButtonIndex;
+      } else if (typeof destructiveButtonIndex === 'number') {
+        destructiveButtonIndices = [destructiveButtonIndex];
+      }
+      var processedTintColor = _$$_REQUIRE(_dependencyMap[4], "../StyleSheet/processColor").default(tintColor);
+      var processedCancelButtonTintColor = _$$_REQUIRE(_dependencyMap[4], "../StyleSheet/processColor").default(cancelButtonTintColor);
+      var processedDisabledButtonTintColor = _$$_REQUIRE(_dependencyMap[4], "../StyleSheet/processColor").default(disabledButtonTintColor);
+      _$$_REQUIRE(_dependencyMap[3], "invariant")(processedTintColor == null || typeof processedTintColor === 'number', 'Unexpected color given for ActionSheetIOS.showActionSheetWithOptions tintColor');
+      _$$_REQUIRE(_dependencyMap[3], "invariant")(processedCancelButtonTintColor == null || typeof processedCancelButtonTintColor === 'number', 'Unexpected color given for ActionSheetIOS.showActionSheetWithOptions cancelButtonTintColor');
+      _$$_REQUIRE(_dependencyMap[3], "invariant")(processedDisabledButtonTintColor == null || typeof processedDisabledButtonTintColor === 'number', 'Unexpected color given for ActionSheetIOS.showActionSheetWithOptions disabledButtonTintColor');
+      _NativeActionSheetManager.default.showActionSheetWithOptions(Object.assign({}, remainingOptions, {
+        tintColor: processedTintColor,
+        cancelButtonTintColor: processedCancelButtonTintColor,
+        disabledButtonTintColor: processedDisabledButtonTintColor,
+        destructiveButtonIndices: destructiveButtonIndices
+      }), callback);
+    },
+    showShareActionSheetWithOptions: function showShareActionSheetWithOptions(options, failureCallback, successCallback) {
+      _$$_REQUIRE(_dependencyMap[3], "invariant")(typeof options === 'object' && options !== null, 'Options must be a valid object');
+      _$$_REQUIRE(_dependencyMap[3], "invariant")(typeof failureCallback === 'function', 'Must provide a valid failureCallback');
+      _$$_REQUIRE(_dependencyMap[3], "invariant")(typeof successCallback === 'function', 'Must provide a valid successCallback');
+      _$$_REQUIRE(_dependencyMap[3], "invariant")(_NativeActionSheetManager.default, "ActionSheetManager doesn't exist");
+      _NativeActionSheetManager.default.showShareActionSheetWithOptions(Object.assign({}, options, {
+        tintColor: _$$_REQUIRE(_dependencyMap[4], "../StyleSheet/processColor").default(options.tintColor)
+      }), failureCallback, successCallback);
+    },
+    dismissActionSheet: function dismissActionSheet() {
+      _$$_REQUIRE(_dependencyMap[3], "invariant")(_NativeActionSheetManager.default, "ActionSheetManager doesn't exist");
+      if (typeof _NativeActionSheetManager.default.dismissActionSheet === 'function') {
+        _NativeActionSheetManager.default.dismissActionSheet();
+      }
+    }
+  };
+  var _default = exports.default = ActionSheetIOS;
+},569,[1,4,570,32,57],"../../node_modules/react-native/Libraries/ActionSheetIOS/ActionSheetIOS.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeActionSheetManager = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativeActionSheetManager"));
+  Object.keys(_NativeActionSheetManager).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeActionSheetManager[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeActionSheetManager[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeActionSheetManager.default;
+},570,[571],"../../node_modules/react-native/Libraries/ActionSheetIOS/NativeActionSheetManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.get('ActionSheetManager');
+},571,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeActionSheetManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _NativeClipboard = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativeClipboard"));
+  var _default = exports.default = {
+    getString: function getString() {
+      return _NativeClipboard.default.getString();
+    },
+    setString: function setString(content) {
+      _NativeClipboard.default.setString(content);
+    }
+  };
+},572,[1,573],"../../node_modules/react-native/Libraries/Components/Clipboard/Clipboard.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeClipboard = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../src/private/specs_DEPRECATED/modules/NativeClipboard"));
+  Object.keys(_NativeClipboard).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeClipboard[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeClipboard[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeClipboard.default;
+},573,[574],"../../node_modules/react-native/Libraries/Components/Clipboard/NativeClipboard.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.getEnforcing('Clipboard');
+},574,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeClipboard.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _NativeDeviceInfo = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativeDeviceInfo"));
+  var _default = exports.default = _NativeDeviceInfo.default;
+},575,[1,29],"../../node_modules/react-native/Libraries/Utilities/DeviceInfo.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _NativeDevMenu = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./specs/NativeDevMenu"));
+  var DevMenu = {
+    show: function show() {
+      if (__DEV__) {
+        _NativeDevMenu.default.show == null || _NativeDevMenu.default.show();
+      }
+    }
+  };
+  var _default = exports.default = DevMenu;
+},576,[1,577],"../../node_modules/react-native/src/private/devsupport/devmenu/DevMenu.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.getEnforcing('DevMenu');
+},577,[31],"../../node_modules/react-native/src/private/devsupport/devmenu/specs/NativeDevMenu.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.DynamicColorIOS = void 0;
+  var DynamicColorIOS = exports.DynamicColorIOS = function DynamicColorIOS(tuple) {
+    return (0, _$$_REQUIRE(_dependencyMap[0], "./PlatformColorValueTypes.ios").DynamicColorIOSPrivate)({
+      light: tuple.light,
+      dark: tuple.dark,
+      highContrastLight: tuple.highContrastLight,
+      highContrastDark: tuple.highContrastDark
+    });
+  };
+},578,[60],"../../node_modules/react-native/Libraries/StyleSheet/PlatformColorValueTypesIOS.ios.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var currentCentroidXOfTouchesChangedAfter = _$$_REQUIRE(_dependencyMap[0], "./TouchHistoryMath").default.currentCentroidXOfTouchesChangedAfter;
+  var currentCentroidYOfTouchesChangedAfter = _$$_REQUIRE(_dependencyMap[0], "./TouchHistoryMath").default.currentCentroidYOfTouchesChangedAfter;
+  var previousCentroidXOfTouchesChangedAfter = _$$_REQUIRE(_dependencyMap[0], "./TouchHistoryMath").default.previousCentroidXOfTouchesChangedAfter;
+  var previousCentroidYOfTouchesChangedAfter = _$$_REQUIRE(_dependencyMap[0], "./TouchHistoryMath").default.previousCentroidYOfTouchesChangedAfter;
+  var currentCentroidX = _$$_REQUIRE(_dependencyMap[0], "./TouchHistoryMath").default.currentCentroidX;
+  var currentCentroidY = _$$_REQUIRE(_dependencyMap[0], "./TouchHistoryMath").default.currentCentroidY;
+  var PanResponder = {
+    _initializeGestureState: function _initializeGestureState(gestureState) {
+      gestureState.moveX = 0;
+      gestureState.moveY = 0;
+      gestureState.x0 = 0;
+      gestureState.y0 = 0;
+      gestureState.dx = 0;
+      gestureState.dy = 0;
+      gestureState.vx = 0;
+      gestureState.vy = 0;
+      gestureState.numberActiveTouches = 0;
+      gestureState._accountsForMovesUpTo = 0;
+    },
+    _updateGestureStateOnMove: function _updateGestureStateOnMove(gestureState, touchHistory) {
+      gestureState.numberActiveTouches = touchHistory.numberActiveTouches;
+      gestureState.moveX = currentCentroidXOfTouchesChangedAfter(touchHistory, gestureState._accountsForMovesUpTo);
+      gestureState.moveY = currentCentroidYOfTouchesChangedAfter(touchHistory, gestureState._accountsForMovesUpTo);
+      var movedAfter = gestureState._accountsForMovesUpTo;
+      var prevX = previousCentroidXOfTouchesChangedAfter(touchHistory, movedAfter);
+      var x = currentCentroidXOfTouchesChangedAfter(touchHistory, movedAfter);
+      var prevY = previousCentroidYOfTouchesChangedAfter(touchHistory, movedAfter);
+      var y = currentCentroidYOfTouchesChangedAfter(touchHistory, movedAfter);
+      var nextDX = gestureState.dx + (x - prevX);
+      var nextDY = gestureState.dy + (y - prevY);
+      var dt = touchHistory.mostRecentTimeStamp - gestureState._accountsForMovesUpTo;
+      gestureState.vx = (nextDX - gestureState.dx) / dt;
+      gestureState.vy = (nextDY - gestureState.dy) / dt;
+      gestureState.dx = nextDX;
+      gestureState.dy = nextDY;
+      gestureState._accountsForMovesUpTo = touchHistory.mostRecentTimeStamp;
+    },
+    create: function create(config) {
+      var interactionState = {
+        handle: null
+      };
+      var gestureState = {
+        stateID: Math.random(),
+        moveX: 0,
+        moveY: 0,
+        x0: 0,
+        y0: 0,
+        dx: 0,
+        dy: 0,
+        vx: 0,
+        vy: 0,
+        numberActiveTouches: 0,
+        _accountsForMovesUpTo: 0
+      };
+      var panHandlers = {
+        onStartShouldSetResponder: function onStartShouldSetResponder(event) {
+          return config.onStartShouldSetPanResponder == null ? false : config.onStartShouldSetPanResponder(event, gestureState);
+        },
+        onMoveShouldSetResponder: function onMoveShouldSetResponder(event) {
+          return config.onMoveShouldSetPanResponder == null ? false : config.onMoveShouldSetPanResponder(event, gestureState);
+        },
+        onStartShouldSetResponderCapture: function onStartShouldSetResponderCapture(event) {
+          if (event.nativeEvent.touches.length === 1) {
+            PanResponder._initializeGestureState(gestureState);
+          }
+          gestureState.numberActiveTouches = event.touchHistory.numberActiveTouches;
+          return config.onStartShouldSetPanResponderCapture != null ? config.onStartShouldSetPanResponderCapture(event, gestureState) : false;
+        },
+        onMoveShouldSetResponderCapture: function onMoveShouldSetResponderCapture(event) {
+          var touchHistory = event.touchHistory;
+          if (gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp) {
+            return false;
+          }
+          PanResponder._updateGestureStateOnMove(gestureState, touchHistory);
+          return config.onMoveShouldSetPanResponderCapture ? config.onMoveShouldSetPanResponderCapture(event, gestureState) : false;
+        },
+        onResponderGrant: function onResponderGrant(event) {
+          if (!interactionState.handle) {
+            interactionState.handle = _$$_REQUIRE(_dependencyMap[1], "./InteractionManager").default.createInteractionHandle();
+          }
+          gestureState.x0 = currentCentroidX(event.touchHistory);
+          gestureState.y0 = currentCentroidY(event.touchHistory);
+          gestureState.dx = 0;
+          gestureState.dy = 0;
+          if (config.onPanResponderGrant) {
+            config.onPanResponderGrant(event, gestureState);
+          }
+          return config.onShouldBlockNativeResponder == null ? true : config.onShouldBlockNativeResponder(event, gestureState);
+        },
+        onResponderReject: function onResponderReject(event) {
+          clearInteractionHandle(interactionState, config.onPanResponderReject, event, gestureState);
+        },
+        onResponderRelease: function onResponderRelease(event) {
+          clearInteractionHandle(interactionState, config.onPanResponderRelease, event, gestureState);
+          PanResponder._initializeGestureState(gestureState);
+        },
+        onResponderStart: function onResponderStart(event) {
+          var touchHistory = event.touchHistory;
+          gestureState.numberActiveTouches = touchHistory.numberActiveTouches;
+          if (config.onPanResponderStart) {
+            config.onPanResponderStart(event, gestureState);
+          }
+        },
+        onResponderMove: function onResponderMove(event) {
+          var touchHistory = event.touchHistory;
+          if (gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp) {
+            return;
+          }
+          PanResponder._updateGestureStateOnMove(gestureState, touchHistory);
+          if (config.onPanResponderMove) {
+            config.onPanResponderMove(event, gestureState);
+          }
+        },
+        onResponderEnd: function onResponderEnd(event) {
+          var touchHistory = event.touchHistory;
+          gestureState.numberActiveTouches = touchHistory.numberActiveTouches;
+          clearInteractionHandle(interactionState, config.onPanResponderEnd, event, gestureState);
+        },
+        onResponderTerminate: function onResponderTerminate(event) {
+          clearInteractionHandle(interactionState, config.onPanResponderTerminate, event, gestureState);
+          PanResponder._initializeGestureState(gestureState);
+        },
+        onResponderTerminationRequest: function onResponderTerminationRequest(event) {
+          return config.onPanResponderTerminationRequest == null ? true : config.onPanResponderTerminationRequest(event, gestureState);
+        }
+      };
+      return {
+        panHandlers: panHandlers,
+        getInteractionHandle: function getInteractionHandle() {
+          return interactionState.handle;
+        }
+      };
+    }
+  };
+  function clearInteractionHandle(interactionState, callback, event, gestureState) {
+    if (interactionState.handle) {
+      _$$_REQUIRE(_dependencyMap[1], "./InteractionManager").default.clearInteractionHandle(interactionState.handle);
+      interactionState.handle = null;
+    }
+    if (callback) {
+      callback(event, gestureState);
+    }
+  }
+  var _default = exports.default = PanResponder;
+},579,[580,407],"../../node_modules/react-native/Libraries/Interaction/PanResponder.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TouchHistoryMath = {
+    centroidDimension: function centroidDimension(touchHistory, touchesChangedAfter, isXAxis, ofCurrent) {
+      var touchBank = touchHistory.touchBank;
+      var total = 0;
+      var count = 0;
+      var oneTouchData = touchHistory.numberActiveTouches === 1 ? touchHistory.touchBank[touchHistory.indexOfSingleActiveTouch] : null;
+      if (oneTouchData !== null) {
+        if (oneTouchData.touchActive && oneTouchData.currentTimeStamp > touchesChangedAfter) {
+          total += ofCurrent && isXAxis ? oneTouchData.currentPageX : ofCurrent && !isXAxis ? oneTouchData.currentPageY : !ofCurrent && isXAxis ? oneTouchData.previousPageX : oneTouchData.previousPageY;
+          count = 1;
+        }
+      } else {
+        for (var i = 0; i < touchBank.length; i++) {
+          var touchTrack = touchBank[i];
+          if (touchTrack !== null && touchTrack !== undefined && touchTrack.touchActive && touchTrack.currentTimeStamp >= touchesChangedAfter) {
+            var toAdd = void 0;
+            if (ofCurrent && isXAxis) {
+              toAdd = touchTrack.currentPageX;
+            } else if (ofCurrent && !isXAxis) {
+              toAdd = touchTrack.currentPageY;
+            } else if (!ofCurrent && isXAxis) {
+              toAdd = touchTrack.previousPageX;
+            } else {
+              toAdd = touchTrack.previousPageY;
+            }
+            total += toAdd;
+            count++;
+          }
+        }
+      }
+      return count > 0 ? total / count : TouchHistoryMath.noCentroid;
+    },
+    currentCentroidXOfTouchesChangedAfter: function currentCentroidXOfTouchesChangedAfter(touchHistory, touchesChangedAfter) {
+      return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, true, true);
+    },
+    currentCentroidYOfTouchesChangedAfter: function currentCentroidYOfTouchesChangedAfter(touchHistory, touchesChangedAfter) {
+      return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, false, true);
+    },
+    previousCentroidXOfTouchesChangedAfter: function previousCentroidXOfTouchesChangedAfter(touchHistory, touchesChangedAfter) {
+      return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, true, false);
+    },
+    previousCentroidYOfTouchesChangedAfter: function previousCentroidYOfTouchesChangedAfter(touchHistory, touchesChangedAfter) {
+      return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, false, false);
+    },
+    currentCentroidX: function currentCentroidX(touchHistory) {
+      return TouchHistoryMath.centroidDimension(touchHistory, 0, true, true);
+    },
+    currentCentroidY: function currentCentroidY(touchHistory) {
+      return TouchHistoryMath.centroidDimension(touchHistory, 0, false, true);
+    },
+    noCentroid: -1
+  };
+  var _default = exports.default = TouchHistoryMath;
+},580,[],"../../node_modules/react-native/Libraries/Interaction/TouchHistoryMath.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _asyncToGenerator2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/asyncToGenerator"));
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+  var _NativeDialogManagerAndroid = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../NativeModules/specs/NativeDialogManagerAndroid"));
+  var _NativePermissionsAndroid = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./NativePermissionsAndroid"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "invariant"));
+  var PERMISSION_REQUEST_RESULT = Object.freeze({
+    GRANTED: 'granted',
+    DENIED: 'denied',
+    NEVER_ASK_AGAIN: 'never_ask_again'
+  });
+  var PERMISSIONS = Object.freeze({
+    READ_CALENDAR: 'android.permission.READ_CALENDAR',
+    WRITE_CALENDAR: 'android.permission.WRITE_CALENDAR',
+    CAMERA: 'android.permission.CAMERA',
+    READ_CONTACTS: 'android.permission.READ_CONTACTS',
+    WRITE_CONTACTS: 'android.permission.WRITE_CONTACTS',
+    GET_ACCOUNTS: 'android.permission.GET_ACCOUNTS',
+    ACCESS_FINE_LOCATION: 'android.permission.ACCESS_FINE_LOCATION',
+    ACCESS_COARSE_LOCATION: 'android.permission.ACCESS_COARSE_LOCATION',
+    ACCESS_BACKGROUND_LOCATION: 'android.permission.ACCESS_BACKGROUND_LOCATION',
+    RECORD_AUDIO: 'android.permission.RECORD_AUDIO',
+    READ_PHONE_STATE: 'android.permission.READ_PHONE_STATE',
+    CALL_PHONE: 'android.permission.CALL_PHONE',
+    READ_CALL_LOG: 'android.permission.READ_CALL_LOG',
+    WRITE_CALL_LOG: 'android.permission.WRITE_CALL_LOG',
+    ADD_VOICEMAIL: 'com.android.voicemail.permission.ADD_VOICEMAIL',
+    READ_VOICEMAIL: 'com.android.voicemail.permission.READ_VOICEMAIL',
+    WRITE_VOICEMAIL: 'com.android.voicemail.permission.WRITE_VOICEMAIL',
+    USE_SIP: 'android.permission.USE_SIP',
+    PROCESS_OUTGOING_CALLS: 'android.permission.PROCESS_OUTGOING_CALLS',
+    BODY_SENSORS: 'android.permission.BODY_SENSORS',
+    BODY_SENSORS_BACKGROUND: 'android.permission.BODY_SENSORS_BACKGROUND',
+    SEND_SMS: 'android.permission.SEND_SMS',
+    RECEIVE_SMS: 'android.permission.RECEIVE_SMS',
+    READ_SMS: 'android.permission.READ_SMS',
+    RECEIVE_WAP_PUSH: 'android.permission.RECEIVE_WAP_PUSH',
+    RECEIVE_MMS: 'android.permission.RECEIVE_MMS',
+    READ_EXTERNAL_STORAGE: 'android.permission.READ_EXTERNAL_STORAGE',
+    READ_MEDIA_IMAGES: 'android.permission.READ_MEDIA_IMAGES',
+    READ_MEDIA_VIDEO: 'android.permission.READ_MEDIA_VIDEO',
+    READ_MEDIA_AUDIO: 'android.permission.READ_MEDIA_AUDIO',
+    READ_MEDIA_VISUAL_USER_SELECTED: 'android.permission.READ_MEDIA_VISUAL_USER_SELECTED',
+    WRITE_EXTERNAL_STORAGE: 'android.permission.WRITE_EXTERNAL_STORAGE',
+    BLUETOOTH_CONNECT: 'android.permission.BLUETOOTH_CONNECT',
+    BLUETOOTH_SCAN: 'android.permission.BLUETOOTH_SCAN',
+    BLUETOOTH_ADVERTISE: 'android.permission.BLUETOOTH_ADVERTISE',
+    ACCESS_MEDIA_LOCATION: 'android.permission.ACCESS_MEDIA_LOCATION',
+    ACCEPT_HANDOVER: 'android.permission.ACCEPT_HANDOVER',
+    ACTIVITY_RECOGNITION: 'android.permission.ACTIVITY_RECOGNITION',
+    ANSWER_PHONE_CALLS: 'android.permission.ANSWER_PHONE_CALLS',
+    READ_PHONE_NUMBERS: 'android.permission.READ_PHONE_NUMBERS',
+    UWB_RANGING: 'android.permission.UWB_RANGING',
+    POST_NOTIFICATIONS: 'android.permission.POST_NOTIFICATIONS',
+    NEARBY_WIFI_DEVICES: 'android.permission.NEARBY_WIFI_DEVICES'
+  });
+  var PermissionsAndroid = /*#__PURE__*/function () {
+    function PermissionsAndroid() {
+      (0, _classCallCheck2.default)(this, PermissionsAndroid);
+      this.PERMISSIONS = PERMISSIONS;
+      this.RESULTS = PERMISSION_REQUEST_RESULT;
+    }
+    return (0, _createClass2.default)(PermissionsAndroid, [{
+      key: "checkPermission",
+      value: function checkPermission(permission) {
+        console.warn('"PermissionsAndroid.checkPermission" is deprecated. Use "PermissionsAndroid.check" instead');
+        if ("ios" !== 'android') {
+          console.warn('"PermissionsAndroid" module works only for Android platform.');
+          return Promise.resolve(false);
+        }
+        (0, _invariant.default)(_NativePermissionsAndroid.default, 'PermissionsAndroid is not installed correctly.');
+        return _NativePermissionsAndroid.default.checkPermission(permission);
+      }
+    }, {
+      key: "check",
+      value: function check(permission) {
+        if ("ios" !== 'android') {
+          console.warn('"PermissionsAndroid" module works only for Android platform.');
+          return Promise.resolve(false);
+        }
+        (0, _invariant.default)(_NativePermissionsAndroid.default, 'PermissionsAndroid is not installed correctly.');
+        return _NativePermissionsAndroid.default.checkPermission(permission);
+      }
+    }, {
+      key: "requestPermission",
+      value: function () {
+        var _requestPermission = (0, _asyncToGenerator2.default)(function* (permission, rationale) {
+          console.warn('"PermissionsAndroid.requestPermission" is deprecated. Use "PermissionsAndroid.request" instead');
+          if ("ios" !== 'android') {
+            console.warn('"PermissionsAndroid" module works only for Android platform.');
+            return Promise.resolve(false);
+          }
+          var response = yield this.request(permission, rationale);
+          return response === this.RESULTS.GRANTED;
+        });
+        function requestPermission(_x, _x2) {
+          return _requestPermission.apply(this, arguments);
+        }
+        return requestPermission;
+      }()
+    }, {
+      key: "request",
+      value: function () {
+        var _request = (0, _asyncToGenerator2.default)(function* (permission, rationale) {
+          if ("ios" !== 'android') {
+            console.warn('"PermissionsAndroid" module works only for Android platform.');
+            return Promise.resolve(this.RESULTS.DENIED);
+          }
+          (0, _invariant.default)(_NativePermissionsAndroid.default, 'PermissionsAndroid is not installed correctly.');
+          if (rationale) {
+            var shouldShowRationale = yield _NativePermissionsAndroid.default.shouldShowRequestPermissionRationale(permission);
+            if (shouldShowRationale && !!_NativeDialogManagerAndroid.default) {
+              return new Promise(function (resolve, reject) {
+                var options = Object.assign({}, rationale);
+                _NativeDialogManagerAndroid.default.showAlert(options, function () {
+                  return reject(new Error('Error showing rationale'));
+                }, function () {
+                  return resolve(_NativePermissionsAndroid.default.requestPermission(permission));
+                });
+              });
+            }
+          }
+          return _NativePermissionsAndroid.default.requestPermission(permission);
+        });
+        function request(_x3, _x4) {
+          return _request.apply(this, arguments);
+        }
+        return request;
+      }()
+    }, {
+      key: "requestMultiple",
+      value: function requestMultiple(permissions) {
+        if ("ios" !== 'android') {
+          console.warn('"PermissionsAndroid" module works only for Android platform.');
+          return Promise.resolve({});
+        }
+        (0, _invariant.default)(_NativePermissionsAndroid.default, 'PermissionsAndroid is not installed correctly.');
+        return _NativePermissionsAndroid.default.requestMultiplePermissions(permissions);
+      }
+    }]);
+  }();
+  var PermissionsAndroidInstance = new PermissionsAndroid();
+  var _default = exports.default = PermissionsAndroidInstance;
+},581,[1,167,11,12,272,582,32],"../../node_modules/react-native/Libraries/PermissionsAndroid/PermissionsAndroid.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativePermissionsAndroid = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativePermissionsAndroid"));
+  Object.keys(_NativePermissionsAndroid).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativePermissionsAndroid[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativePermissionsAndroid[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativePermissionsAndroid.default;
+},582,[583],"../../node_modules/react-native/Libraries/PermissionsAndroid/NativePermissionsAndroid.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.get('PermissionsAndroid');
+},583,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativePermissionsAndroid.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _NativeEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../EventEmitter/NativeEventEmitter"));
+  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../Utilities/Platform"));
+  var _NativePushNotificationManagerIOS = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./NativePushNotificationManagerIOS"));
+  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "invariant"));
+  var PushNotificationEmitter = new _NativeEventEmitter.default(_Platform.default.OS !== 'ios' ? null : _NativePushNotificationManagerIOS.default);
+  var _notifHandlers = new Map();
+  var DEVICE_NOTIF_EVENT = 'remoteNotificationReceived';
+  var NOTIF_REGISTER_EVENT = 'remoteNotificationsRegistered';
+  var NOTIF_REGISTRATION_ERROR_EVENT = 'remoteNotificationRegistrationError';
+  var DEVICE_LOCAL_NOTIF_EVENT = 'localNotificationReceived';
+  var PushNotificationIOS = /*#__PURE__*/function () {
+    function PushNotificationIOS(nativeNotif) {
+      var _this = this;
+      (0, _classCallCheck2.default)(this, PushNotificationIOS);
+      this._data = {};
+      this._remoteNotificationCompleteCallbackCalled = false;
+      this._isRemote = nativeNotif.remote;
+      if (this._isRemote) {
+        this._notificationId = nativeNotif.notificationId;
+      }
+      if (nativeNotif.remote) {
+        Object.keys(nativeNotif).forEach(function (notifKey) {
+          var notifVal = nativeNotif[notifKey];
+          if (notifKey === 'aps') {
+            _this._alert = notifVal.alert;
+            _this._sound = notifVal.sound;
+            _this._badgeCount = notifVal.badge;
+            _this._category = notifVal.category;
+            _this._contentAvailable = notifVal['content-available'];
+            _this._threadID = notifVal['thread-id'];
+          } else {
+            _this._data[notifKey] = notifVal;
+          }
+        });
+      } else {
+        this._badgeCount = nativeNotif.applicationIconBadgeNumber;
+        this._sound = nativeNotif.soundName;
+        this._alert = nativeNotif.alertBody;
+        this._data = nativeNotif.userInfo;
+        this._category = nativeNotif.category;
+      }
+    }
+    return (0, _createClass2.default)(PushNotificationIOS, [{
+      key: "finish",
+      value: function finish(fetchResult) {
+        if (!this._isRemote || !this._notificationId || this._remoteNotificationCompleteCallbackCalled) {
+          return;
+        }
+        this._remoteNotificationCompleteCallbackCalled = true;
+        (0, _invariant.default)(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');
+        _NativePushNotificationManagerIOS.default.onFinishRemoteNotification(this._notificationId, fetchResult);
+      }
+    }, {
+      key: "getMessage",
+      value: function getMessage() {
+        return this._alert;
+      }
+    }, {
+      key: "getSound",
+      value: function getSound() {
+        return this._sound;
+      }
+    }, {
+      key: "getCategory",
+      value: function getCategory() {
+        return this._category;
+      }
+    }, {
+      key: "getAlert",
+      value: function getAlert() {
+        return this._alert;
+      }
+    }, {
+      key: "getContentAvailable",
+      value: function getContentAvailable() {
+        return this._contentAvailable;
+      }
+    }, {
+      key: "getBadgeCount",
+      value: function getBadgeCount() {
+        return this._badgeCount;
+      }
+    }, {
+      key: "getData",
+      value: function getData() {
+        return this._data;
+      }
+    }, {
+      key: "getThreadID",
+      value: function getThreadID() {
+        return this._threadID;
+      }
+    }], [{
+      key: "presentLocalNotification",
+      value: function presentLocalNotification(details) {
+        (0, _invariant.default)(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');
+        _NativePushNotificationManagerIOS.default.presentLocalNotification(details);
+      }
+    }, {
+      key: "scheduleLocalNotification",
+      value: function scheduleLocalNotification(details) {
+        (0, _invariant.default)(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');
+        _NativePushNotificationManagerIOS.default.scheduleLocalNotification(details);
+      }
+    }, {
+      key: "cancelAllLocalNotifications",
+      value: function cancelAllLocalNotifications() {
+        (0, _invariant.default)(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');
+        _NativePushNotificationManagerIOS.default.cancelAllLocalNotifications();
+      }
+    }, {
+      key: "removeAllDeliveredNotifications",
+      value: function removeAllDeliveredNotifications() {
+        (0, _invariant.default)(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');
+        _NativePushNotificationManagerIOS.default.removeAllDeliveredNotifications();
+      }
+    }, {
+      key: "getDeliveredNotifications",
+      value: function getDeliveredNotifications(callback) {
+        (0, _invariant.default)(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');
+        _NativePushNotificationManagerIOS.default.getDeliveredNotifications(callback);
+      }
+    }, {
+      key: "removeDeliveredNotifications",
+      value: function removeDeliveredNotifications(identifiers) {
+        (0, _invariant.default)(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');
+        _NativePushNotificationManagerIOS.default.removeDeliveredNotifications(identifiers);
+      }
+    }, {
+      key: "setApplicationIconBadgeNumber",
+      value: function setApplicationIconBadgeNumber(number) {
+        (0, _invariant.default)(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');
+        _NativePushNotificationManagerIOS.default.setApplicationIconBadgeNumber(number);
+      }
+    }, {
+      key: "getApplicationIconBadgeNumber",
+      value: function getApplicationIconBadgeNumber(callback) {
+        (0, _invariant.default)(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');
+        _NativePushNotificationManagerIOS.default.getApplicationIconBadgeNumber(callback);
+      }
+    }, {
+      key: "cancelLocalNotifications",
+      value: function cancelLocalNotifications(userInfo) {
+        (0, _invariant.default)(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');
+        _NativePushNotificationManagerIOS.default.cancelLocalNotifications(userInfo);
+      }
+    }, {
+      key: "getScheduledLocalNotifications",
+      value: function getScheduledLocalNotifications(callback) {
+        (0, _invariant.default)(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');
+        _NativePushNotificationManagerIOS.default.getScheduledLocalNotifications(callback);
+      }
+    }, {
+      key: "addEventListener",
+      value: function addEventListener(type, handler) {
+        (0, _invariant.default)(type === 'notification' || type === 'register' || type === 'registrationError' || type === 'localNotification', 'PushNotificationIOS only supports `notification`, `register`, `registrationError`, and `localNotification` events');
+        var listener;
+        if (type === 'notification') {
+          listener = PushNotificationEmitter.addListener(DEVICE_NOTIF_EVENT, function (notifData) {
+            handler(new PushNotificationIOS(notifData));
+          });
+        } else if (type === 'localNotification') {
+          listener = PushNotificationEmitter.addListener(DEVICE_LOCAL_NOTIF_EVENT, function (notifData) {
+            handler(new PushNotificationIOS(notifData));
+          });
+        } else if (type === 'register') {
+          listener = PushNotificationEmitter.addListener(NOTIF_REGISTER_EVENT, function (registrationInfo) {
+            handler(registrationInfo.deviceToken);
+          });
+        } else if (type === 'registrationError') {
+          listener = PushNotificationEmitter.addListener(NOTIF_REGISTRATION_ERROR_EVENT, function (errorInfo) {
+            handler(errorInfo);
+          });
+        }
+        _notifHandlers.set(type, listener);
+      }
+    }, {
+      key: "removeEventListener",
+      value: function removeEventListener(type) {
+        (0, _invariant.default)(type === 'notification' || type === 'register' || type === 'registrationError' || type === 'localNotification', 'PushNotificationIOS only supports `notification`, `register`, `registrationError`, and `localNotification` events');
+        var listener = _notifHandlers.get(type);
+        if (!listener) {
+          return;
+        }
+        listener.remove();
+        _notifHandlers.delete(type);
+      }
+    }, {
+      key: "requestPermissions",
+      value: function requestPermissions(permissions) {
+        var requestedPermissions = {
+          alert: true,
+          badge: true,
+          sound: true
+        };
+        if (permissions) {
+          requestedPermissions = {
+            alert: !!permissions.alert,
+            badge: !!permissions.badge,
+            sound: !!permissions.sound
+          };
+        }
+        (0, _invariant.default)(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');
+        return _NativePushNotificationManagerIOS.default.requestPermissions(requestedPermissions);
+      }
+    }, {
+      key: "abandonPermissions",
+      value: function abandonPermissions() {
+        (0, _invariant.default)(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');
+        _NativePushNotificationManagerIOS.default.abandonPermissions();
+      }
+    }, {
+      key: "checkPermissions",
+      value: function checkPermissions(callback) {
+        (0, _invariant.default)(typeof callback === 'function', 'Must provide a valid callback');
+        (0, _invariant.default)(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');
+        _NativePushNotificationManagerIOS.default.checkPermissions(callback);
+      }
+    }, {
+      key: "getInitialNotification",
+      value: function getInitialNotification() {
+        (0, _invariant.default)(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');
+        return _NativePushNotificationManagerIOS.default.getInitialNotification().then(function (notification) {
+          return notification && new PushNotificationIOS(notification);
+        });
+      }
+    }, {
+      key: "getAuthorizationStatus",
+      value: function getAuthorizationStatus(callback) {
+        (0, _invariant.default)(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');
+        _NativePushNotificationManagerIOS.default.getAuthorizationStatus(callback);
+      }
+    }]);
+  }();
+  PushNotificationIOS.FetchResult = {
+    NewData: 'UIBackgroundFetchResultNewData',
+    NoData: 'UIBackgroundFetchResultNoData',
+    ResultFailed: 'UIBackgroundFetchResultFailed'
+  };
+  var _default = exports.default = PushNotificationIOS;
+},584,[1,11,12,221,68,585,32],"../../node_modules/react-native/Libraries/PushNotificationIOS/PushNotificationIOS.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativePushNotificationManagerIOS = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativePushNotificationManagerIOS"));
+  Object.keys(_NativePushNotificationManagerIOS).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativePushNotificationManagerIOS[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativePushNotificationManagerIOS[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativePushNotificationManagerIOS.default;
+},585,[586],"../../node_modules/react-native/Libraries/PushNotificationIOS/NativePushNotificationManagerIOS.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.get('PushNotificationManager');
+},586,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativePushNotificationManagerIOS.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+  var _NativeActionSheetManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../ActionSheetIOS/NativeActionSheetManager"));
+  var _NativeShareModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./NativeShareModule"));
+  var Share = /*#__PURE__*/function () {
+    function Share() {
+      (0, _classCallCheck2.default)(this, Share);
+    }
+    return (0, _createClass2.default)(Share, null, [{
+      key: "share",
+      value: function share(content) {
+        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+        _$$_REQUIRE(_dependencyMap[5], "invariant")(typeof content === 'object' && content !== null, 'Content to share must be a valid object');
+        _$$_REQUIRE(_dependencyMap[5], "invariant")(typeof content.url === 'string' || typeof content.message === 'string', 'At least one of URL or message is required');
+        _$$_REQUIRE(_dependencyMap[5], "invariant")(typeof options === 'object' && options !== null, 'Options must be a valid object');
+        if ("ios" === 'android') {
+          _$$_REQUIRE(_dependencyMap[5], "invariant")(_NativeShareModule.default, 'ShareModule should be registered on Android.');
+          _$$_REQUIRE(_dependencyMap[5], "invariant")(content.title == null || typeof content.title === 'string', 'Invalid title: title should be a string.');
+          var newContent = {
+            title: content.title,
+            message: typeof content.message === 'string' ? content.message : undefined
+          };
+          return _NativeShareModule.default.share(newContent, options.dialogTitle).then(function (result) {
+            return Object.assign({
+              activityType: null
+            }, result);
+          });
+        } else if ("ios" === 'ios') {
+          return new Promise(function (resolve, reject) {
+            var tintColor = _$$_REQUIRE(_dependencyMap[6], "../StyleSheet/processColor").default(options.tintColor);
+            _$$_REQUIRE(_dependencyMap[5], "invariant")(tintColor == null || typeof tintColor === 'number', 'Unexpected color given for options.tintColor');
+            _$$_REQUIRE(_dependencyMap[5], "invariant")(_NativeActionSheetManager.default, 'NativeActionSheetManager is not registered on iOS, but it should be.');
+            _NativeActionSheetManager.default.showShareActionSheetWithOptions({
+              message: typeof content.message === 'string' ? content.message : undefined,
+              url: typeof content.url === 'string' ? content.url : undefined,
+              subject: options.subject,
+              tintColor: typeof tintColor === 'number' ? tintColor : undefined,
+              anchor: typeof options.anchor === 'number' ? options.anchor : undefined,
+              excludedActivityTypes: options.excludedActivityTypes
+            }, function (error) {
+              return reject(error);
+            }, function (success, activityType) {
+              if (success) {
+                resolve({
+                  action: 'sharedAction',
+                  activityType: activityType
+                });
+              } else {
+                resolve({
+                  action: 'dismissedAction',
+                  activityType: null
+                });
+              }
+            });
+          });
+        } else {
+          return Promise.reject(new Error('Unsupported platform'));
+        }
+      }
+    }]);
+  }();
+  Share.sharedAction = 'sharedAction';
+  Share.dismissedAction = 'dismissedAction';
+  var _default = exports.default = Share;
+},587,[1,11,12,570,588,32,57],"../../node_modules/react-native/Libraries/Share/Share.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeShareModule = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativeShareModule"));
+  Object.keys(_NativeShareModule).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeShareModule[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeShareModule[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeShareModule.default;
+},588,[589],"../../node_modules/react-native/Libraries/Share/NativeShareModule.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.get('ShareModule');
+},589,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeShareModule.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _ToastAndroidFallback = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./ToastAndroidFallback"));
+  var _default = exports.default = _ToastAndroidFallback.default;
+},590,[1,591],"../../node_modules/react-native/Libraries/Components/ToastAndroid/ToastAndroid.ios.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var ToastAndroid = {
+    SHORT: 0,
+    LONG: 0,
+    TOP: 0,
+    BOTTOM: 0,
+    CENTER: 0,
+    show: function show(message, duration) {
+      console.warn('ToastAndroid is not supported on this platform.');
+    },
+    showWithGravity: function showWithGravity(message, duration, gravity) {
+      console.warn('ToastAndroid is not supported on this platform.');
+    },
+    showWithGravityAndOffset: function showWithGravityAndOffset(message, duration, gravity, xOffset, yOffset) {
+      console.warn('ToastAndroid is not supported on this platform.');
+    }
+  };
+  var _default = exports.default = ToastAndroid;
+},591,[],"../../node_modules/react-native/Libraries/Components/ToastAndroid/ToastAndroidFallback.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = useAnimatedValue;
+  var _Animated = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./Animated"));
+  var _react = _$$_REQUIRE(_dependencyMap[2], "react");
+  function useAnimatedValue(initialValue, config) {
+    var ref = (0, _react.useRef)(null);
+    if (ref.current == null) {
+      ref.current = new _Animated.default.Value(initialValue, config);
+    }
+    return ref.current;
+  }
+},592,[1,442,73],"../../node_modules/react-native/Libraries/Animated/useAnimatedValue.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = useColorScheme;
+  var _react = _$$_REQUIRE(_dependencyMap[0], "react");
+  var subscribe = function subscribe(onStoreChange) {
+    var appearanceSubscription = (0, _$$_REQUIRE(_dependencyMap[1], "./Appearance").addChangeListener)(onStoreChange);
+    return function () {
+      return appearanceSubscription.remove();
+    };
+  };
+  function useColorScheme() {
+    return (0, _react.useSyncExternalStore)(subscribe, _$$_REQUIRE(_dependencyMap[1], "./Appearance").getColorScheme);
+  }
+},593,[73,283],"../../node_modules/react-native/Libraries/Utilities/useColorScheme.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var _NativeVibration = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativeVibration"));
+  var _vibrating = false;
+  var _id = 0;
+  var _default_vibration_length = 400;
+  function vibrateByPattern(pattern) {
+    var repeat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    if (_vibrating) {
+      return;
+    }
+    _vibrating = true;
+    if (pattern[0] === 0) {
+      _NativeVibration.default.vibrate(_default_vibration_length);
+      pattern = pattern.slice(1);
+    }
+    if (pattern.length === 0) {
+      _vibrating = false;
+      return;
+    }
+    setTimeout(function () {
+      return vibrateScheduler(++_id, pattern, repeat, 1);
+    }, pattern[0]);
+  }
+  function vibrateScheduler(id, pattern, repeat, nextIndex) {
+    if (!_vibrating || id !== _id) {
+      return;
+    }
+    _NativeVibration.default.vibrate(_default_vibration_length);
+    if (nextIndex >= pattern.length) {
+      if (repeat) {
+        nextIndex = 0;
+      } else {
+        _vibrating = false;
+        return;
+      }
+    }
+    setTimeout(function () {
+      return vibrateScheduler(id, pattern, repeat, nextIndex + 1);
+    }, pattern[nextIndex]);
+  }
+  var Vibration = {
+    vibrate: function vibrate() {
+      var pattern = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _default_vibration_length;
+      var repeat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      if ("ios" === 'android') {
+        if (typeof pattern === 'number') {
+          _NativeVibration.default.vibrate(pattern);
+        } else if (Array.isArray(pattern)) {
+          _NativeVibration.default.vibrateByPattern(pattern, repeat ? 0 : -1);
+        } else {
+          throw new Error('Vibration pattern should be a number or array');
+        }
+      } else {
+        if (_vibrating) {
+          return;
+        }
+        if (typeof pattern === 'number') {
+          _NativeVibration.default.vibrate(pattern);
+        } else if (Array.isArray(pattern)) {
+          vibrateByPattern(pattern, repeat);
+        } else {
+          throw new Error('Vibration pattern should be a number or array');
+        }
+      }
+    },
+    cancel: function cancel() {
+      if ("ios" === 'ios') {
+        _vibrating = false;
+      } else {
+        _NativeVibration.default.cancel();
+      }
+    }
+  };
+  var _default = exports.default = Vibration;
+},594,[1,595],"../../node_modules/react-native/Libraries/Vibration/Vibration.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {};
+  exports.default = void 0;
+  var _NativeVibration = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../src/private/specs_DEPRECATED/modules/NativeVibration"));
+  Object.keys(_NativeVibration).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _NativeVibration[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function get() {
+        return _NativeVibration[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = _NativeVibration.default;
+},595,[596],"../../node_modules/react-native/Libraries/Vibration/NativeVibration.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "../../../../Libraries/TurboModule/TurboModuleRegistry"));
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var _default = exports.default = TurboModuleRegistry.getEnforcing('Vibration');
+},596,[31],"../../node_modules/react-native/src/private/specs_DEPRECATED/modules/NativeVibration.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = SandboxApp;
+  var _toConsumableArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/toConsumableArray"));
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/slicedToArray"));
+  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[3], "react"));
+  var _reactNative = _$$_REQUIRE(_dependencyMap[4], "react-native");
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[5], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/apps/origin-pooling/SandboxApp.tsx";
+  /**
+   * SandboxApp — runs INSIDE each sandbox (library approach).
+   *
+   * Uses useSurfaceMessaging from @callstack/react-native-sandbox
+   * for per-surface routing.
+   */
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function SandboxApp(_ref) {
+    var _this = this;
+    var __sandboxDelegateId = _ref.__sandboxDelegateId;
+    var _useSurfaceMessaging = (0, _$$_REQUIRE(_dependencyMap[6], "@callstack/react-native-sandbox").useSurfaceMessaging)(__sandboxDelegateId),
+      postMessage = _useSurfaceMessaging.postMessage,
+      setOnMessage = _useSurfaceMessaging.setOnMessage;
+    var _useState = (0, _react.useState)([]),
+      _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+      log = _useState2[0],
+      setLog = _useState2[1];
+    var instanceId = (0, _react.useRef)(Math.random().toString(36).slice(2, 6)).current;
+    var seq = (0, _react.useRef)(0);
+    var logRef = (0, _react.useRef)(null);
+    var addLog = function addLog(dir, text) {
+      return setLog(function (prev) {
+        return [].concat((0, _toConsumableArray2.default)(prev.slice(-19)), [{
+          dir: dir,
+          text: text,
+          ts: Date.now()
+        }]);
+      });
+    };
+    (0, _react.useEffect)(function () {
+      postMessage({
+        type: 'rendered',
+        instanceId: instanceId
+      });
+      addLog('out', `rendered (${instanceId})`);
+    }, [instanceId, postMessage]);
+    (0, _react.useEffect)(function () {
+      var unsubscribe = setOnMessage(function (msg) {
+        var _data$instanceId;
+        var data = msg;
+        addLog('in', `from ${(_data$instanceId = data.instanceId) != null ? _data$instanceId : '?'}: ${data.type}`);
+      });
+      return unsubscribe;
+    }, [setOnMessage]);
+    var sendHeartbeat = function sendHeartbeat() {
+      var s = ++seq.current;
+      postMessage({
+        type: 'heartbeat',
+        instanceId: instanceId,
+        seq: s
+      });
+      addLog('out', `heartbeat seq=${s}`);
+    };
+    var pingAlpha = function pingAlpha() {
+      postMessage({
+        type: 'ping',
+        instanceId: instanceId
+      }, 'alpha');
+      addLog('out', 'ping → alpha');
+    };
+    var pingBeta = function pingBeta() {
+      postMessage({
+        type: 'ping',
+        instanceId: instanceId
+      }, 'beta');
+      addLog('out', 'ping → beta');
+    };
+    var triggerError = function triggerError() {
+      addLog('out', 'throwing uncaught error…');
+      setTimeout(function () {
+        throw new Error(`Boom from ${instanceId}`);
+      }, 0);
+    };
+    return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, {
+      style: styles.root,
+      children: [/*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.Text, {
+        style: styles.title,
+        children: ["ID: ", instanceId]
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Text, {
+        style: styles.approach,
+        children: "Library (useSurfaceMessaging)"
+      }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, {
+        style: styles.buttons,
+        children: [/*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, {
+          style: styles.btnRow,
+          children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.TouchableOpacity, {
+            style: styles.btnGreen,
+            onPress: sendHeartbeat,
+            children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Text, {
+              style: styles.btnText,
+              children: "Heartbeat"
+            })
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.TouchableOpacity, {
+            style: styles.btnRed,
+            onPress: triggerError,
+            children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Text, {
+              style: styles.btnText,
+              children: "Error"
+            })
+          })]
+        }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, {
+          style: styles.btnRow,
+          children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.TouchableOpacity, {
+            style: styles.btnPurple,
+            onPress: pingAlpha,
+            children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Text, {
+              style: styles.btnText,
+              children: "Ping alpha"
+            })
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.TouchableOpacity, {
+            style: styles.btnOrange,
+            onPress: pingBeta,
+            children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Text, {
+              style: styles.btnText,
+              children: "Ping beta"
+            })
+          })]
+        })]
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.ScrollView, {
+        ref: logRef,
+        style: styles.log,
+        onContentSizeChange: function onContentSizeChange() {
+          var _logRef$current;
+          return (_logRef$current = logRef.current) == null ? void 0 : _logRef$current.scrollToEnd();
+        },
+        children: log.map(function (e, i) {
+          return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.Text, {
+            style: styles.logLine,
+            children: [e.dir === 'in' ? '← ' : '→ ', e.text]
+          }, i);
+        })
+      })]
+    });
+  }
+  var styles = _reactNative.StyleSheet.create({
+    root: {
+      flex: 1,
+      padding: 6,
+      backgroundColor: '#1a1a2e'
+    },
+    title: {
+      color: '#d3e945',
+      fontWeight: '700',
+      fontSize: 13
+    },
+    approach: {
+      color: '#888',
+      fontSize: 9,
+      marginBottom: 4
+    },
+    buttons: {
+      gap: 4,
+      marginBottom: 4
+    },
+    btnRow: {
+      flexDirection: 'row',
+      gap: 4
+    },
+    btnGreen: {
+      backgroundColor: '#16c79a',
+      borderRadius: 4,
+      paddingHorizontal: 6,
+      paddingVertical: 2,
+      flex: 1
+    },
+    btnPurple: {
+      backgroundColor: '#8232ff',
+      borderRadius: 4,
+      paddingHorizontal: 6,
+      paddingVertical: 2,
+      flex: 1
+    },
+    btnOrange: {
+      backgroundColor: '#e67e22',
+      borderRadius: 4,
+      paddingHorizontal: 6,
+      paddingVertical: 2,
+      flex: 1
+    },
+    btnRed: {
+      backgroundColor: '#e94560',
+      borderRadius: 4,
+      paddingHorizontal: 6,
+      paddingVertical: 2,
+      flex: 1
+    },
+    btnText: {
+      color: '#fff',
+      fontSize: 10,
+      fontWeight: '600'
+    },
+    log: {
+      flex: 1
+    },
+    logLine: {
+      color: '#16c79a',
+      fontSize: 10,
+      fontFamily: 'monospace'
+    }
+  });
+},597,[1,42,34,73,2,171,598],"SandboxApp.tsx");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = void 0;
+  Object.defineProperty(exports, "useSurfaceMessaging", {
+    enumerable: true,
+    get: function get() {
+      return _$$_REQUIRE(_dependencyMap[1], "./useSurfaceMessaging").useSurfaceMessaging;
+    }
+  });
+  var _toConsumableArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/toConsumableArray"));
+  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/objectWithoutProperties"));
+  var _react = _$$_REQUIRE(_dependencyMap[4], "react");
+  var _reactNative = _$$_REQUIRE(_dependencyMap[5], "react-native");
+  var _NativeSandboxReactNativeView = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[6], "../specs/NativeSandboxReactNativeView"));
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[7], "react/jsx-runtime");
+  var _excluded = ["origin", "jsBundleSource", "allowedTurboModules", "style", "componentName", "moduleName", "onMessage", "onError", "idleTTL"];
+  var _this = this,
+    _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/packages/react-native-sandbox/src/index.tsx";
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  var SANDBOX_TURBOMODULES_WHITELIST = ['NativeDOMCxx', 'NativeMicrotasksCxx', 'NativePerformanceCxx', 'RedBox', 'DevMenu', 'DevLoadingView', 'EventDispatcher', 'ImageLoader', 'ExceptionsManager', 'PlatformConstants', 'DevSettings', 'SettingsManager', 'AppState', 'SourceCode', 'WebSocketModule', 'Networking', 'DeviceInfo', 'AccessibilityManager', 'LinkingManager', 'BlobModule', 'LogBox', 'Appearance', 'ReactDevToolsRuntimeSettingsModule', 'NativeReactNativeFeatureFlagsCxx', 'NativeAnimatedTurboModule', 'NativeAnimatedModule', 'KeyboardObserver', 'I18nManager', 'FrameRateLogger', 'StatusBarManager', 'FileReaderModule'];
+
+  /**
+   * Generic object type for props that can contain any key-value pairs.
+   * Used for initialProperties and launchOptions to allow flexible configuration.
+   */
+
+  var sandboxCounter = 0;
+  var generateSandboxId = function generateSandboxId() {
+    return `sandbox:${++sandboxCounter}`;
+  };
+
+  /**
+   * Ref interface for SandboxReactNativeView component.
+   * Provides methods to interact with the sandbox from the parent component.
+   *
+   * @example
+   * ```tsx
+   * const sandboxRef = useRef<SandboxReactNativeViewRef>(null);
+   *
+   * // Send a message to the sandbox
+   * sandboxRef.current?.postMessage({
+   *   type: 'update',
+   *   payload: { theme: 'light' }
+   * });
+   * ```
+   */
+
+  /**
+   * SandboxReactNativeView component for running isolated React Native instances.
+   *
+   * This component creates a secure sandbox environment where you can run multiple
+   * React Native apps side-by-side with controlled access to TurboModules and
+   * bidirectional communication capabilities.
+   *
+   * Key features:
+   * - Security isolation through TurboModule whitelisting
+   * - Bidirectional communication via postMessage
+   * - Error handling and monitoring
+   * - Support for custom launch configurations
+   *
+   * @example
+   * Basic usage:
+   * ```tsx
+   * function App() {
+   *   const sandboxRef = useRef<SandboxReactNativeViewRef>(null);
+   *
+   *   const handleMessage = (data: unknown) => {
+   *     console.log('Message from sandbox:', data);
+   *   };
+   *
+   *   const sendMessage = () => {
+   *     sandboxRef.current?.postMessage({ action: 'refresh' });
+   *   };
+   *
+   *   return (
+   *     <SandboxReactNativeView
+   *       ref={sandboxRef}
+   *       componentName="MyDynamicApp"
+   *       jsBundleSource="https://example.com/app.bundle.js"
+   *       initialProperties={{ userId: '123', theme: 'dark' }}
+   *       onMessage={handleMessage}
+   *       onError={(error) => console.error('Sandbox error:', error)}
+   *       style={{ flex: 1 }}
+   *     />
+   *   );
+   * }
+   * ```
+   *
+   * @example
+   * Advanced usage with custom TurboModules:
+   * ```tsx
+   * <SandboxReactNativeView
+   *   componentName="SecureApp"
+   *   allowedTurboModules={['MyCustomModule', 'CryptoModule']}
+   *   launchOptions={{ debugMode: false, securityLevel: 'high' }}
+   *   onMessage={(data) => {
+   *     // Handle different message types
+   *     if (data?.type === 'auth') {
+   *       handleAuthentication(data.payload);
+   *     }
+   *   }}
+   * />
+   * ```
+   */
+  var SandboxReactNativeView = (0, _react.forwardRef)(function (_ref, ref) {
+    var origin = _ref.origin,
+      jsBundleSource = _ref.jsBundleSource,
+      allowedTurboModules = _ref.allowedTurboModules,
+      style = _ref.style,
+      componentName = _ref.componentName,
+      moduleName = _ref.moduleName,
+      onMessage = _ref.onMessage,
+      onError = _ref.onError,
+      idleTTLProp = _ref.idleTTL,
+      rest = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+    var nativeRef = (0, _react.useRef)(null);
+
+    // Use provided origin or assign a unique ID
+    var sandboxOrigin = (0, _react.useMemo)(function () {
+      return origin || generateSandboxId();
+    }, [origin]);
+    var idleTTL = typeof idleTTLProp === 'function' ? idleTTLProp() : idleTTLProp;
+    var postMessage = (0, _react.useCallback)(function (message) {
+      if (nativeRef.current) {
+        _NativeSandboxReactNativeView.Commands.postMessage(nativeRef.current, JSON.stringify(message));
+      }
+    }, []);
+    var _onError = (0, _react.useCallback)(function (e) {
+      // @ts-ignore
+      onError == null || onError(e.nativeEvent);
+    }, [onError]);
+    var _onMessage = (0, _react.useCallback)(function (e) {
+      // @ts-ignore
+      onMessage == null || onMessage(e.nativeEvent.data);
+    }, [onMessage]);
+    (0, _react.useImperativeHandle)(ref, function () {
+      return {
+        postMessage: postMessage
+      };
+    }, [postMessage]);
+    var _renderOverlay = (0, _react.useCallback)(function () {
+      // TODO implement some loading/error/handling screen
+      return null;
+    }, []);
+    var _style = (0, _react.useMemo)(function () {
+      return Object.assign({}, _reactNative.StyleSheet.absoluteFillObject);
+    }, []);
+    var _allowedTurboModules = (0, _react.useMemo)(function () {
+      return (0, _toConsumableArray2.default)(new Set([].concat((0, _toConsumableArray2.default)(allowedTurboModules != null ? allowedTurboModules : []), SANDBOX_TURBOMODULES_WHITELIST)));
+    }, [allowedTurboModules]);
+
+    // Handle backward compatibility for moduleName -> componentName
+    var resolvedComponentName = (0, _react.useMemo)(function () {
+      if (componentName && moduleName) {
+        console.warn('Both componentName and moduleName are provided. Using componentName and ignoring moduleName. ' + 'Please migrate to using componentName only as moduleName is deprecated.');
+        return componentName;
+      }
+      if (moduleName) {
+        console.warn('moduleName is deprecated. Please use componentName instead. moduleName will be removed in a future version.');
+        return moduleName;
+      }
+      if (!componentName) {
+        throw new Error('Either componentName or moduleName must be provided');
+      }
+      return componentName;
+    }, [componentName, moduleName]);
+    var _jsBundleSource = (0, _react.useMemo)(function () {
+      if (jsBundleSource) {
+        return jsBundleSource;
+      }
+      return 'index';
+    }, [jsBundleSource]);
+    return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, {
+      style: style,
+      children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_NativeSandboxReactNativeView.default, Object.assign({
+        ref: nativeRef // @ts-ignore
+        ,
+        origin: sandboxOrigin,
+        componentName: resolvedComponentName,
+        jsBundleSource: _jsBundleSource,
+        hasOnMessageHandler: !!onMessage,
+        hasOnErrorHandler: !!onError,
+        onError: onError ? _onError : undefined,
+        onMessage: onMessage ? _onMessage : undefined,
+        allowedTurboModules: _allowedTurboModules,
+        idleTTL: idleTTL,
+        style: _style
+      }, rest)), _renderOverlay()]
+    });
+  });
+  SandboxReactNativeView.displayName = 'SandboxReactNativeView';
+  var _default = exports.default = SandboxReactNativeView;
+},598,[1,599,42,4,73,2,600,171],"../../packages/react-native-sandbox/src/index.tsx");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.useSurfaceMessaging = useSurfaceMessaging;
+  var _react = _$$_REQUIRE(_dependencyMap[0], "react");
+  /**
+   * Hook for sandbox components to send and receive messages scoped to their
+   * own surface when sharing an origin (and therefore a Hermes VM) with other
+   * sandboxes.
+   *
+   * Without this hook:
+   * - `globalThis.postMessage(msg)` broadcasts to ALL host views sharing the origin.
+   * - `globalThis.setOnMessage(cb)` is last-writer-wins (only one listener).
+   *
+   * With this hook:
+   * - `postMessage` attaches a routing hint so the message is delivered only to
+   *   the calling surface's parent view.
+   * - `setOnMessage` registers a per-surface listener so every surface receives
+   *   incoming sandbox-to-sandbox messages independently.
+   *
+   * Usage:
+   * ```tsx
+   * function MyWidget({__sandboxDelegateId}: Props) {
+   *   const {postMessage, setOnMessage} = useSurfaceMessaging(__sandboxDelegateId);
+   *
+   *   useEffect(() => {
+   *     const unsubscribe = setOnMessage((msg) => console.log('received', msg));
+   *     return unsubscribe;
+   *   }, [setOnMessage]);
+   *
+   *   postMessage({type: 'hello'});
+   * }
+   * ```
+   *
+   * @param delegateId - The `__sandboxDelegateId` prop injected by the native
+   *   side into initialProperties. If undefined, falls back to broadcast/shared.
+   */
+  function useSurfaceMessaging(delegateId) {
+    var postMessage = (0, _react.useCallback)(function (msg, targetOrigin) {
+      if (targetOrigin) {
+        // Cross-origin: forward directly without adding delegate routing hint.
+        // The native side routes by origin, not by delegate ID.
+        globalThis.postMessage(typeof msg === 'object' && msg !== null ? msg : {
+          data: msg
+        }, targetOrigin);
+        return;
+      }
+      // Per-surface: attach routing hint for the host view
+      var payload = typeof msg === 'object' && msg !== null ? Object.assign({}, msg) : {
+        data: msg
+      };
+      if (delegateId) {
+        ;
+        payload.__sandboxDelegateId = delegateId;
+      }
+      globalThis.postMessage(payload);
+    }, [delegateId]);
+    var setOnMessage = (0, _react.useCallback)(function (cb) {
+      globalThis.setOnMessage(cb, delegateId);
+      // Return a cleanup function that unregisters the per-surface listener
+      return function () {
+        globalThis.setOnMessage(function () {}, delegateId);
+      };
+    }, [delegateId]);
+    return {
+      postMessage: postMessage,
+      setOnMessage: setOnMessage
+    };
+  }
+},599,[73],"../../packages/react-native-sandbox/src/useSurfaceMessaging.ts");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = exports.__INTERNAL_VIEW_CONFIG = exports.Commands = void 0;
+  var _reactNative = _$$_REQUIRE(_dependencyMap[0], "react-native");
+
+  /**
+   * Error event structure passed from the native sandbox to JavaScript.
+   * Contains detailed information about errors that occur within the sandbox.
+   */
+
+  /**
+   * Message event structure for communication from sandbox to parent.
+   * Wraps arbitrary data sent from the sandboxed React Native instance.
+   */
+
+  /**
+   * Native props interface for the SandboxReactNativeView component.
+   * Extends ViewProps and defines all properties that can be passed to the native view.
+   */
+
+  /**
+   * The native SandboxReactNativeView component generated by React Native's codegen.
+   * This is the actual native view implementation that provides the sandbox functionality.
+   */
+  var nativeComponentName = 'SandboxReactNativeView';
+  var __INTERNAL_VIEW_CONFIG = exports.__INTERNAL_VIEW_CONFIG = {
+    uiViewClassName: "SandboxReactNativeView",
+    directEventTypes: {
+      topMessage: {
+        registrationName: "onMessage"
+      },
+      topError: {
+        registrationName: "onError"
+      }
+    },
+    validAttributes: Object.assign({
+      origin: true,
+      componentName: true,
+      jsBundleSource: true,
+      initialProperties: true,
+      launchOptions: true,
+      allowedTurboModules: true,
+      turboModuleSubstitutions: true,
+      allowedOrigins: true,
+      idleTTL: true,
+      hasOnMessageHandler: true,
+      hasOnErrorHandler: true
+    }, _$$_REQUIRE(_dependencyMap[1], "react-native/Libraries/NativeComponent/ViewConfigIgnore").ConditionallyIgnoredEventHandlers({
+      onMessage: true,
+      onError: true
+    }))
+  };
+  var _default = exports.default = _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/NativeComponent/NativeComponentRegistry").get(nativeComponentName, function () {
+    return __INTERNAL_VIEW_CONFIG;
+  });
+  var Commands = exports.Commands = {
+    postMessage: function postMessage(ref, message) {
+      _$$_REQUIRE(_dependencyMap[3], "react-native/Libraries/ReactNative/RendererProxy").dispatchCommand(ref, "postMessage", [message]);
+    }
+  };
+},600,[2,104,77,106],"../../packages/react-native-sandbox/specs/NativeSandboxReactNativeView.ts");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = SandboxAppConvention;
+  var _toConsumableArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/toConsumableArray"));
+  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/slicedToArray"));
+  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[3], "react"));
+  var _reactNative = _$$_REQUIRE(_dependencyMap[4], "react-native");
+  var _jsxRuntime = _$$_REQUIRE(_dependencyMap[5], "react/jsx-runtime");
+  var _jsxFileName = "/Users/rkarn/ryan-karn-2-react-native-sandbox/react-native-sandbox/apps/origin-pooling/SandboxAppConvention.tsx";
+  /**
+   * SandboxAppConvention — convention-based approach (no library dependency).
+   *
+   * Uses the __sandboxDelegateId prop directly with globalThis.postMessage
+   * and globalThis.setOnMessage for per-surface routing. No import from
+   * @callstack/react-native-sandbox needed.
+   */
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+  function SandboxAppConvention(_ref) {
+    var _this = this;
+    var __sandboxDelegateId = _ref.__sandboxDelegateId;
+    var _useState = (0, _react.useState)([]),
+      _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+      log = _useState2[0],
+      setLog = _useState2[1];
+    var instanceId = (0, _react.useRef)(Math.random().toString(36).slice(2, 6)).current;
+    var seq = (0, _react.useRef)(0);
+    var logRef = (0, _react.useRef)(null);
+    var addLog = function addLog(dir, text) {
+      return setLog(function (prev) {
+        return [].concat((0, _toConsumableArray2.default)(prev.slice(-19)), [{
+          dir: dir,
+          text: text,
+          ts: Date.now()
+        }]);
+      });
+    };
+
+    // Convention: spread __sandboxDelegateId into the payload for per-surface routing
+    var send = _react.default.useCallback(function (msg, targetOrigin) {
+      var payload = !targetOrigin && __sandboxDelegateId ? Object.assign({}, msg, {
+        __sandboxDelegateId: __sandboxDelegateId
+      }) : msg;
+      globalThis.postMessage(payload, targetOrigin);
+    }, [__sandboxDelegateId]);
+    (0, _react.useEffect)(function () {
+      send({
+        type: 'rendered',
+        instanceId: instanceId
+      });
+      addLog('out', `rendered (${instanceId})`);
+    }, [instanceId, send]);
+
+    // Convention: pass delegateId as 2nd arg for per-surface listener
+    (0, _react.useEffect)(function () {
+      globalThis.setOnMessage(function (msg) {
+        var _data$instanceId;
+        var data = msg;
+        addLog('in', `from ${(_data$instanceId = data.instanceId) != null ? _data$instanceId : '?'}: ${data.type}`);
+      }, __sandboxDelegateId);
+      return function () {
+        globalThis.setOnMessage(function () {}, __sandboxDelegateId);
+      };
+    }, [__sandboxDelegateId]);
+    var sendHeartbeat = function sendHeartbeat() {
+      var s = ++seq.current;
+      send({
+        type: 'heartbeat',
+        instanceId: instanceId,
+        seq: s
+      });
+      addLog('out', `heartbeat seq=${s}`);
+    };
+    var pingAlpha = function pingAlpha() {
+      send({
+        type: 'ping',
+        instanceId: instanceId
+      }, 'alpha');
+      addLog('out', 'ping → alpha');
+    };
+    var pingBeta = function pingBeta() {
+      send({
+        type: 'ping',
+        instanceId: instanceId
+      }, 'beta');
+      addLog('out', 'ping → beta');
+    };
+    var triggerError = function triggerError() {
+      addLog('out', 'throwing uncaught error…');
+      setTimeout(function () {
+        throw new Error(`Boom from ${instanceId}`);
+      }, 0);
+    };
+    return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, {
+      style: styles.root,
+      children: [/*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.Text, {
+        style: styles.title,
+        children: ["ID: ", instanceId]
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Text, {
+        style: styles.approach,
+        children: "Convention (no import)"
+      }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, {
+        style: styles.buttons,
+        children: [/*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, {
+          style: styles.btnRow,
+          children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.TouchableOpacity, {
+            style: styles.btnGreen,
+            onPress: sendHeartbeat,
+            children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Text, {
+              style: styles.btnText,
+              children: "Heartbeat"
+            })
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.TouchableOpacity, {
+            style: styles.btnRed,
+            onPress: triggerError,
+            children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Text, {
+              style: styles.btnText,
+              children: "Error"
+            })
+          })]
+        }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.View, {
+          style: styles.btnRow,
+          children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.TouchableOpacity, {
+            style: styles.btnPurple,
+            onPress: pingAlpha,
+            children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Text, {
+              style: styles.btnText,
+              children: "Ping alpha"
+            })
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.TouchableOpacity, {
+            style: styles.btnOrange,
+            onPress: pingBeta,
+            children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Text, {
+              style: styles.btnText,
+              children: "Ping beta"
+            })
+          })]
+        })]
+      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.ScrollView, {
+        ref: logRef,
+        style: styles.log,
+        onContentSizeChange: function onContentSizeChange() {
+          var _logRef$current;
+          return (_logRef$current = logRef.current) == null ? void 0 : _logRef$current.scrollToEnd();
+        },
+        children: log.map(function (e, i) {
+          return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_reactNative.Text, {
+            style: styles.logLine,
+            children: [e.dir === 'in' ? '← ' : '→ ', e.text]
+          }, i);
+        })
+      })]
+    });
+  }
+  var styles = _reactNative.StyleSheet.create({
+    root: {
+      flex: 1,
+      padding: 6,
+      backgroundColor: '#1a1a2e'
+    },
+    title: {
+      color: '#d3e945',
+      fontWeight: '700',
+      fontSize: 13
+    },
+    approach: {
+      color: '#888',
+      fontSize: 9,
+      marginBottom: 4
+    },
+    buttons: {
+      gap: 4,
+      marginBottom: 4
+    },
+    btnRow: {
+      flexDirection: 'row',
+      gap: 4
+    },
+    btnGreen: {
+      backgroundColor: '#16c79a',
+      borderRadius: 4,
+      paddingHorizontal: 6,
+      paddingVertical: 2,
+      flex: 1
+    },
+    btnPurple: {
+      backgroundColor: '#8232ff',
+      borderRadius: 4,
+      paddingHorizontal: 6,
+      paddingVertical: 2,
+      flex: 1
+    },
+    btnOrange: {
+      backgroundColor: '#e67e22',
+      borderRadius: 4,
+      paddingHorizontal: 6,
+      paddingVertical: 2,
+      flex: 1
+    },
+    btnRed: {
+      backgroundColor: '#e94560',
+      borderRadius: 4,
+      paddingHorizontal: 6,
+      paddingVertical: 2,
+      flex: 1
+    },
+    btnText: {
+      color: '#fff',
+      fontSize: 10,
+      fontWeight: '600'
+    },
+    log: {
+      flex: 1
+    },
+    logLine: {
+      color: '#16c79a',
+      fontSize: 10,
+      fontFamily: 'monospace'
+    }
+  });
+},601,[1,42,34,73,2,171],"SandboxAppConvention.tsx");
+__r(111);
+__r(0);
\ No newline at end of file
diff --git a/apps/origin-pooling/sandbox.js b/apps/origin-pooling/sandbox.js
index 8c38710..f28b6d2 100644
--- a/apps/origin-pooling/sandbox.js
+++ b/apps/origin-pooling/sandbox.js
@@ -1,5 +1,10 @@
 import {AppRegistry} from 'react-native'
 
 import SandboxApp from './SandboxApp'
+import SandboxAppConvention from './SandboxAppConvention'
 
 AppRegistry.registerComponent('SandboxApp', () => SandboxApp)
+AppRegistry.registerComponent(
+  'SandboxAppConvention',
+  () => SandboxAppConvention
+)
diff --git a/apps/p2p-counter/App.tsx b/apps/p2p-counter/App.tsx
index ed973ec..c4401be 100644
--- a/apps/p2p-counter/App.tsx
+++ b/apps/p2p-counter/App.tsx
@@ -9,6 +9,9 @@ interface CounterSandboxProps {
   sourceName: string
   backgroundColor: string
   targetOrigin: string
+  // allowedOrigins uses receiver-side semantics: origins permitted to send TO this sandbox
+  allowedOrigins: string[]
+  // The toggle and label describe the outbound direction from this sandbox's perspective
   isCommunicationEnabled: boolean
   onCommunicationToggle: (enabled: boolean) => void
   communicationLabel: string
@@ -18,6 +21,7 @@ function CounterSandboxView({
   sourceName,
   backgroundColor,
   targetOrigin,
+  allowedOrigins,
   isCommunicationEnabled,
   onCommunicationToggle,
   communicationLabel,
@@ -66,7 +70,7 @@ function CounterSandboxView({
           backgroundColor,
           targetOrigin: targetOrigin,
         }}
-        allowedOrigins={isCommunicationEnabled ? [targetOrigin] : []}
+        allowedOrigins={allowedOrigins}
         onMessage={handleMessage}
         onError={handleError}
       />
@@ -85,10 +89,17 @@ export default function App() {
       </View>
 
       <View style={styles.sandboxContainer}>
+        {/*
+         * allowedOrigins uses receiver-side semantics: each sandbox declares which
+         * origins may send TO it. So sandbox A gets allowedOrigins=["B"] when the
+         * B→A toggle is on, and sandbox B gets allowedOrigins=["A"] when A→B is on.
+         * The toggle and its label live on the sandbox that initiates the direction.
+         */}
         <CounterSandboxView
           sourceName="A"
           backgroundColor="#CCFFCC"
           targetOrigin="B"
+          allowedOrigins={allowBtoA ? ['B'] : []}
           isCommunicationEnabled={allowAtoB}
           onCommunicationToggle={setAllowAtoB}
           communicationLabel="A → B"
@@ -97,6 +108,7 @@ export default function App() {
           sourceName="B"
           backgroundColor="#CCCCFF"
           targetOrigin="A"
+          allowedOrigins={allowAtoB ? ['A'] : []}
           isCommunicationEnabled={allowBtoA}
           onCommunicationToggle={setAllowBtoA}
           communicationLabel="B → A"
diff --git a/apps/p2p-counter/ios/P2PCounter.xcodeproj/xcshareddata/xcschemes/MultiInstancePOC.xcscheme b/apps/p2p-counter/ios/P2PCounter.xcodeproj/xcshareddata/xcschemes/P2PCounter.xcscheme
similarity index 79%
rename from apps/p2p-counter/ios/P2PCounter.xcodeproj/xcshareddata/xcschemes/MultiInstancePOC.xcscheme
rename to apps/p2p-counter/ios/P2PCounter.xcodeproj/xcshareddata/xcschemes/P2PCounter.xcscheme
index a823713..659478f 100644
--- a/apps/p2p-counter/ios/P2PCounter.xcodeproj/xcshareddata/xcschemes/MultiInstancePOC.xcscheme
+++ b/apps/p2p-counter/ios/P2PCounter.xcodeproj/xcshareddata/xcschemes/P2PCounter.xcscheme
@@ -15,9 +15,9 @@
             <BuildableReference
                BuildableIdentifier = "primary"
                BlueprintIdentifier = "13B07F861A680F5B00A75B9A"
-               BuildableName = "MultiInstancePOC.app"
-               BlueprintName = "MultiInstancePOC"
-               ReferencedContainer = "container:MultiInstancePOC.xcodeproj">
+               BuildableName = "P2PCounter.app"
+               BlueprintName = "P2PCounter"
+               ReferencedContainer = "container:P2PCounter.xcodeproj">
             </BuildableReference>
          </BuildActionEntry>
       </BuildActionEntries>
@@ -34,7 +34,6 @@
       buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      customLLDBInitFile = "/Users/aliaksandr.babrykovich/Projects/multi-instance-poc/ios/.lldbinit"
       launchStyle = "0"
       useCustomWorkingDirectory = "NO"
       ignoresPersistentStateOnLaunch = "NO"
@@ -46,9 +45,9 @@
          <BuildableReference
             BuildableIdentifier = "primary"
             BlueprintIdentifier = "13B07F861A680F5B00A75B9A"
-            BuildableName = "MultiInstancePOC.app"
-            BlueprintName = "MultiInstancePOC"
-            ReferencedContainer = "container:MultiInstancePOC.xcodeproj">
+            BuildableName = "P2PCounter.app"
+            BlueprintName = "P2PCounter"
+            ReferencedContainer = "container:P2PCounter.xcodeproj">
          </BuildableReference>
       </BuildableProductRunnable>
    </LaunchAction>
@@ -63,9 +62,9 @@
          <BuildableReference
             BuildableIdentifier = "primary"
             BlueprintIdentifier = "13B07F861A680F5B00A75B9A"
-            BuildableName = "MultiInstancePOC.app"
-            BlueprintName = "MultiInstancePOC"
-            ReferencedContainer = "container:MultiInstancePOC.xcodeproj">
+            BuildableName = "P2PCounter.app"
+            BlueprintName = "P2PCounter"
+            ReferencedContainer = "container:P2PCounter.xcodeproj">
          </BuildableReference>
       </BuildableProductRunnable>
    </ProfileAction>
diff --git a/apps/p2p-counter/ios/Podfile.lock b/apps/p2p-counter/ios/Podfile.lock
index 2ef3a57..b0b4f74 100644
--- a/apps/p2p-counter/ios/Podfile.lock
+++ b/apps/p2p-counter/ios/Podfile.lock
@@ -2051,7 +2051,7 @@ PODS:
     - React-timing
     - React-utils
     - SocketRocket
-  - React-Sandbox (0.4.0):
+  - React-Sandbox (0.6.1):
     - boost
     - DoubleConversion
     - fast_float
@@ -2493,7 +2493,7 @@ SPEC CHECKSUMS:
   React-runtimeexecutor: 17c70842d5e611130cb66f91e247bc4a609c3508
   React-RuntimeHermes: 3c88e6e1ea7ea0899dcffc77c10d61ea46688cfd
   React-runtimescheduler: 024500621c7c93d65371498abb4ee26d34f5d47d
-  React-Sandbox: e3cf3c955559ed9f0bf014b29dce1e94600cd790
+  React-Sandbox: 52c91938b8a96d84d633e13421b2ad41582f7ab7
   React-timing: c3c923df2b86194e1682e01167717481232f1dc7
   React-utils: 9154a037543147e1c24098f1a48fc8472602c092
   ReactAppDependencyProvider: afd905e84ee36e1678016ae04d7370c75ed539be
diff --git a/packages/react-native-sandbox/android/src/main/java/io/callstack/rnsandbox/SandboxJSIInstaller.kt b/packages/react-native-sandbox/android/src/main/java/io/callstack/rnsandbox/SandboxJSIInstaller.kt
index 4cbc318..1389441 100644
--- a/packages/react-native-sandbox/android/src/main/java/io/callstack/rnsandbox/SandboxJSIInstaller.kt
+++ b/packages/react-native-sandbox/android/src/main/java/io/callstack/rnsandbox/SandboxJSIInstaller.kt
@@ -53,4 +53,50 @@ object SandboxJSIInstaller {
      */
     @JvmStatic
     external fun nativeInstallErrorHandler(stateHandle: Long)
+
+    /**
+     * Registers an additional delegate for an origin in the C++ SandboxRegistry.
+     * Used when a second view shares an existing ReactHost (same origin) and
+     * needs its own delegate to receive messages and errors.
+     *
+     * @param origin The sandbox origin string
+     * @param delegate The delegate that handles messages/errors for this view
+     * @return An opaque handle that must be passed to nativeUnregisterDelegate on cleanup
+     */
+    @JvmStatic
+    external fun nativeRegisterDelegate(
+        origin: String,
+        delegate: SandboxReactNativeDelegate,
+    ): Long
+
+    /**
+     * Unregisters a delegate previously registered via nativeRegisterDelegate.
+     *
+     * @param handle The handle returned by nativeRegisterDelegate
+     */
+    @JvmStatic
+    external fun nativeUnregisterDelegate(handle: Long)
+
+    /**
+     * Unregisters the delegate associated with a JSI state handle from the
+     * C++ SandboxRegistry without destroying the state. Used when the first
+     * view for an origin is removed but other views still share the host.
+     *
+     * @param stateHandle Handle returned by nativeInstall
+     */
+    @JvmStatic
+    external fun nativeUnregisterStateDelegate(stateHandle: Long)
+
+    /**
+     * Updates the allowedOrigins for an origin in the C++ SandboxRegistry.
+     * Called when the allowedOrigins prop changes on a sandbox view.
+     *
+     * @param origin The sandbox origin string
+     * @param allowedOrigins Array of origin strings permitted to send messages to this origin
+     */
+    @JvmStatic
+    external fun nativeUpdateAllowedOrigins(
+        origin: String,
+        allowedOrigins: Array<String>,
+    )
 }
diff --git a/packages/react-native-sandbox/android/src/main/java/io/callstack/rnsandbox/SandboxReactNativeDelegate.kt b/packages/react-native-sandbox/android/src/main/java/io/callstack/rnsandbox/SandboxReactNativeDelegate.kt
index 6b0ce06..f061d4f 100644
--- a/packages/react-native-sandbox/android/src/main/java/io/callstack/rnsandbox/SandboxReactNativeDelegate.kt
+++ b/packages/react-native-sandbox/android/src/main/java/io/callstack/rnsandbox/SandboxReactNativeDelegate.kt
@@ -78,11 +78,26 @@ class SandboxReactNativeDelegate(
             val destroyGeneration: java.util.concurrent.atomic.AtomicLong =
                 java.util.concurrent.atomic
                     .AtomicLong(0),
+            var jsiStateHandle: Long = 0,
         )
+
+        private val nextDelegateId =
+            java.util.concurrent.atomic
+                .AtomicLong(0)
+        private val delegateById = java.util.concurrent.ConcurrentHashMap<String, SandboxReactNativeDelegate>()
+
+        /**
+         * Finds a delegate by its unique ID. Called from JNI when postMessage
+         * includes a __sandboxDelegateId for per-surface routing.
+         */
+        @JvmStatic
+        fun findByDelegateId(id: String): SandboxReactNativeDelegate? = delegateById[id]
     }
 
     @JvmField var origin: String = ""
 
+    @JvmField var delegateId: String = ""
+
     var jsBundleSource: String = ""
     var allowedTurboModules: Set<String> = emptySet()
     var turboModuleSubstitutions: Map<String, String> = emptyMap()
@@ -100,6 +115,8 @@ class SandboxReactNativeDelegate(
     private var sandboxReactContext: ReactContext? = null
     private var ownsReactHost = false
     private var instanceEventListener: ReactInstanceEventListener? = null
+    private var registryDelegateHandle: Long = 0
+    private val pendingHostMessages = mutableListOf<String>()
 
     @OptIn(UnstableReactNativeAPI::class)
     fun loadReactNativeView(
@@ -114,6 +131,10 @@ class SandboxReactNativeDelegate(
         val capturedBundleSource = jsBundleSource
         val capturedAllowedModules = allowedTurboModules
 
+        // Generate a unique delegate ID for per-surface message routing
+        delegateId = "delegate:${nextDelegateId.incrementAndGet()}"
+        delegateById[delegateId] = this
+
         try {
             val shared = if (origin.isNotEmpty()) sharedHosts[origin] else null
 
@@ -127,6 +148,19 @@ class SandboxReactNativeDelegate(
                 shared.idleTTLMs = maxOf(shared.idleTTLMs, idleTTLMs)
                 ownsReactHost = false
                 Log.d(TAG, "Reusing shared ReactHost for origin '$origin' (refCount=${shared.refCount})")
+
+                // Register this delegate in the C++ SandboxRegistry so that
+                // postMessage/onError broadcasts from the shared VM reach
+                // every view, not just the first one that created the host.
+                registryDelegateHandle = SandboxJSIInstaller.nativeRegisterDelegate(origin, this)
+
+                // Grab the JSI state handle from the first view so Host→JS
+                // messaging (ref.postMessage) works for this view too.
+                jsiStateHandle = shared.jsiStateHandle
+
+                // The ReactContext is already initialized; grab it directly
+                // so postMessage can call runOnJSQueueThread.
+                sandboxReactContext = host.currentReactContext
             } else {
                 sandboxContext = SandboxContextWrapper(context, origin)
 
@@ -199,16 +233,16 @@ class SandboxReactNativeDelegate(
             instanceEventListener = listener
             host.addReactInstanceEventListener(listener)
 
-            val surface = host.createSurface(sandboxContext, componentName, initialProperties)
+            val surface = host.createSurface(sandboxContext, componentName, initialProperties.withDelegateId())
             reactSurface = surface
 
-            surface.start()
-
             val activity = getActivity()
             if (activity != null) {
                 host.onHostResume(activity)
             }
 
+            surface.start()
+
             return surface.view
         } catch (e: Exception) {
             Log.e(TAG, "Failed to create React Native view: ${e.message}", e)
@@ -270,6 +304,11 @@ class SandboxReactNativeDelegate(
 
     fun onJSIBindingsInstalled(stateHandle: Long) {
         jsiStateHandle = stateHandle
+        // Store on the shared host so views that reuse this host can
+        // deliver Host→JS messages through the same JSI state.
+        if (origin.isNotEmpty()) {
+            sharedHosts[origin]?.jsiStateHandle = stateHandle
+        }
     }
 
     fun postMessage(message: String) {
@@ -285,21 +324,55 @@ class SandboxReactNativeDelegate(
 
     @Suppress("unused")
     fun emitOnMessageFromJS(messageJson: String) {
-        if (!hasOnMessageHandler) return
-
         UiThreadUtil.runOnUiThread {
             try {
+                val view = sandboxView
+                if (!hasOnMessageHandler || view == null || !view.isAttachedToWindow) {
+                    synchronized(pendingHostMessages) {
+                        pendingHostMessages.add(messageJson)
+                    }
+                    return@runOnUiThread
+                }
                 val data =
                     Arguments.createMap().apply {
                         putString("data", messageJson)
                     }
-                sandboxView?.emitOnMessage(data)
+                view.emitOnMessage(data)
             } catch (e: Exception) {
                 Log.e(TAG, "Error emitting onMessage: ${e.message}", e)
             }
         }
     }
 
+    /**
+     * Flush any messages that were buffered because the view wasn't ready
+     * when they arrived (warm start timing). Called from the view manager
+     * after the React Native child view is attached.
+     */
+    fun flushPendingHostMessages() {
+        if (!hasOnMessageHandler) return
+        val messages: List<String>
+        synchronized(pendingHostMessages) {
+            if (pendingHostMessages.isEmpty()) return
+            messages = pendingHostMessages.toList()
+            pendingHostMessages.clear()
+        }
+        UiThreadUtil.runOnUiThread {
+            val view = sandboxView ?: return@runOnUiThread
+            for (messageJson in messages) {
+                try {
+                    val data =
+                        Arguments.createMap().apply {
+                            putString("data", messageJson)
+                        }
+                    view.emitOnMessage(data)
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error flushing pending message: ${e.message}", e)
+                }
+            }
+        }
+    }
+
     @Suppress("unused")
     fun routeMessageFromJS(
         messageJson: String,
@@ -345,8 +418,43 @@ class SandboxReactNativeDelegate(
     }
 
     fun cleanup() {
+        if (delegateId.isNotEmpty()) {
+            delegateById.remove(delegateId)
+        }
+
+        synchronized(pendingHostMessages) {
+            pendingHostMessages.clear()
+        }
+
+        if (registryDelegateHandle != 0L) {
+            SandboxJSIInstaller.nativeUnregisterDelegate(registryDelegateHandle)
+            registryDelegateHandle = 0
+        }
+
+        // Only destroy the shared JSI state when this view owns the host AND
+        // it's the last user AND the host is actually being destroyed (no TTL).
+        // When TTL is active, the host stays alive and a new surface may reuse
+        // the JSI state, so we must not tear it down.
         if (jsiStateHandle != 0L) {
-            SandboxJSIInstaller.nativeDestroy(jsiStateHandle)
+            val isLastUser =
+                if (origin.isNotEmpty()) {
+                    val shared = sharedHosts[origin]
+                    shared == null || (shared.refCount <= 1 && ownsReactHost)
+                } else {
+                    true
+                }
+            val hostBeingKeptAlive =
+                if (origin.isNotEmpty()) {
+                    val shared = sharedHosts[origin]
+                    shared != null && shared.refCount <= 1 && shared.idleTTLMs > 0
+                } else {
+                    false
+                }
+            if (isLastUser && !hostBeingKeptAlive) {
+                SandboxJSIInstaller.nativeDestroy(jsiStateHandle)
+            } else if (ownsReactHost && !hostBeingKeptAlive) {
+                SandboxJSIInstaller.nativeUnregisterStateDelegate(jsiStateHandle)
+            }
             jsiStateHandle = 0
         }
         sandboxReactContext = null
@@ -378,6 +486,11 @@ class SandboxReactNativeDelegate(
                                 }
                                 val current = sharedHosts[capturedOrigin]
                                 if (current != null && current.refCount <= 0 && current.destroyGeneration.get() == gen) {
+                                    // Now actually destroy the JSI state that was kept alive
+                                    if (current.jsiStateHandle != 0L) {
+                                        SandboxJSIInstaller.nativeDestroy(current.jsiStateHandle)
+                                        current.jsiStateHandle = 0
+                                    }
                                     sharedHosts.remove(capturedOrigin)
                                     current.reactHost.onHostDestroy()
                                     current.reactHost.destroy("lazy sandbox cleanup", null)
@@ -403,6 +516,16 @@ class SandboxReactNativeDelegate(
         cleanup()
     }
 
+    /**
+     * Injects __sandboxDelegateId into the initialProperties Bundle so the
+     * sandbox JS can pass it back through useSurfaceMessaging for per-surface routing.
+     */
+    private fun Bundle?.withDelegateId(): Bundle {
+        val bundle = this ?: Bundle()
+        bundle.putString("__sandboxDelegateId", delegateId)
+        return bundle
+    }
+
     private class SandboxContextWrapper(
         base: Context,
         sandboxId: String,
diff --git a/packages/react-native-sandbox/android/src/main/java/io/callstack/rnsandbox/SandboxReactNativeViewManager.kt b/packages/react-native-sandbox/android/src/main/java/io/callstack/rnsandbox/SandboxReactNativeViewManager.kt
index 6a17d8a..c63255e 100644
--- a/packages/react-native-sandbox/android/src/main/java/io/callstack/rnsandbox/SandboxReactNativeViewManager.kt
+++ b/packages/react-native-sandbox/android/src/main/java/io/callstack/rnsandbox/SandboxReactNativeViewManager.kt
@@ -162,7 +162,14 @@ class SandboxReactNativeViewManager :
                 it.getString(i)?.let { name -> origins.add(name) }
             }
         }
-        view.delegate?.allowedOrigins = origins
+        val delegate = view.delegate ?: return
+        delegate.allowedOrigins = origins
+
+        // Update the C++ SandboxRegistry so isPermittedFrom checks work
+        val origin = delegate.origin
+        if (origin.isNotEmpty()) {
+            SandboxJSIInstaller.nativeUpdateAllowedOrigins(origin, origins.toTypedArray())
+        }
     }
 
     @ReactProp(name = "hasOnMessageHandler")
@@ -171,6 +178,9 @@ class SandboxReactNativeViewManager :
         value: Boolean,
     ) {
         view.delegate?.hasOnMessageHandler = value
+        if (value) {
+            view.delegate?.flushPendingHostMessages()
+        }
     }
 
     @ReactProp(name = "hasOnErrorHandler")
@@ -239,6 +249,20 @@ class SandboxReactNativeViewManager :
             ),
         )
         view.requestLayout()
+
+        // Ensure allowedOrigins are registered in the C++ SandboxRegistry.
+        // Props may arrive in any order, so this guarantees the registry
+        // has the correct allowedOrigins after the view is fully loaded.
+        if (delegate.origin.isNotEmpty() && delegate.allowedOrigins.isNotEmpty()) {
+            SandboxJSIInstaller.nativeUpdateAllowedOrigins(
+                delegate.origin,
+                delegate.allowedOrigins.toTypedArray(),
+            )
+        }
+
+        // Flush any messages that arrived from JS before the view was ready
+        // (warm start race condition).
+        view.delegate?.flushPendingHostMessages()
     }
 
     private fun dynamicToBundle(dynamic: Dynamic): Bundle? {
diff --git a/packages/react-native-sandbox/android/src/main/jni/SandboxJSIInstaller.cpp b/packages/react-native-sandbox/android/src/main/jni/SandboxJSIInstaller.cpp
index 43b4b4a..2cd6dd8 100644
--- a/packages/react-native-sandbox/android/src/main/jni/SandboxJSIInstaller.cpp
+++ b/packages/react-native-sandbox/android/src/main/jni/SandboxJSIInstaller.cpp
@@ -24,6 +24,11 @@ static JavaVM* gJavaVM = nullptr;
 struct SandboxJSIState {
   jsi::Runtime* runtime = nullptr;
   std::shared_ptr<jsi::Function> onMessageCallback;
+  // Per-surface message callbacks keyed by delegate ID.
+  // When a sandbox uses useSurfaceMessaging, its setOnMessage registers here
+  // so each surface gets its own listener even in a shared VM.
+  std::unordered_map<std::string, std::shared_ptr<jsi::Function>>
+      surfaceMessageCallbacks;
   std::vector<std::string> pendingMessages;
   std::mutex mutex;
   jobject delegateRef = nullptr;
@@ -89,6 +94,18 @@ class JNISandboxDelegate : public rnsandbox::ISandboxDelegate {
   bool routeMessage(const std::string& message, const std::string& targetId)
       override {
     auto& registry = rnsandbox::SandboxRegistry::getInstance();
+
+    // Enforce allowedOrigins access control
+    if (!origin_.empty() && !registry.isPermittedFrom(origin_, targetId)) {
+      postError(
+          "AccessDeniedError",
+          "Access denied: Sandbox '" + origin_ +
+              "' is not permitted to send messages to '" + targetId + "'",
+          "",
+          false);
+      return false;
+    }
+
     auto targets = registry.findAll(targetId);
     if (targets.empty())
       return false;
@@ -98,12 +115,59 @@ class JNISandboxDelegate : public rnsandbox::ISandboxDelegate {
     return true;
   }
 
-  void setOrigin(const std::string&) override {}
+  void setOrigin(const std::string& origin) override {
+    origin_ = origin;
+  }
   void setAllowedOrigins(const std::set<std::string>&) override {}
   void setAllowedTurboModules(const std::set<std::string>&) override {}
 
+  /**
+   * Calls the Kotlin delegate's emitOnMessageFromJS to route a message
+   * from the sandbox JS to the host native view. This is the JS→Host
+   * direction, as opposed to postMessage() which is Host→JS.
+   */
+  void emitOnMessageFromJS(const std::string& message) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    JNIEnv* env = getJNIEnv();
+    if (!env || !globalDelegateRef_)
+      return;
+    jclass cls = env->GetObjectClass(globalDelegateRef_);
+    jmethodID mid =
+        env->GetMethodID(cls, "emitOnMessageFromJS", "(Ljava/lang/String;)V");
+    jstring jMsg = env->NewStringUTF(message.c_str());
+    env->CallVoidMethod(globalDelegateRef_, mid, jMsg);
+    env->DeleteLocalRef(jMsg);
+    env->DeleteLocalRef(cls);
+  }
+
+  void postError(
+      const std::string& name,
+      const std::string& message,
+      const std::string& stack,
+      bool isFatal) override {
+    std::lock_guard<std::mutex> lock(mutex_);
+    JNIEnv* env = getJNIEnv();
+    if (!env || !globalDelegateRef_)
+      return;
+    jclass cls = env->GetObjectClass(globalDelegateRef_);
+    jmethodID mid = env->GetMethodID(
+        cls,
+        "emitOnErrorFromJS",
+        "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Z)V");
+    jstring jName = env->NewStringUTF(name.c_str());
+    jstring jMsg = env->NewStringUTF(message.c_str());
+    jstring jStack = env->NewStringUTF(stack.c_str());
+    env->CallVoidMethod(
+        globalDelegateRef_, mid, jName, jMsg, jStack, (jboolean)isFatal);
+    env->DeleteLocalRef(jName);
+    env->DeleteLocalRef(jMsg);
+    env->DeleteLocalRef(jStack);
+    env->DeleteLocalRef(cls);
+  }
+
  private:
   jobject globalDelegateRef_;
+  std::string origin_;
   std::mutex mutex_;
 };
 
@@ -167,43 +231,62 @@ static void setupErrorHandler(
         if (!jniEnv)
           return jsi::Value::undefined();
 
-        jclass cls = jniEnv->GetObjectClass(state->delegateRef);
-        jfieldID hasHandlerField =
-            jniEnv->GetFieldID(cls, "hasOnErrorHandler", "Z");
-        jboolean hasHandler =
-            jniEnv->GetBooleanField(state->delegateRef, hasHandlerField);
-
-        if (hasHandler) {
-          const jsi::Object& error = args[0].asObject(rt);
-          bool isFatal = args[1].getBool();
-          std::string name = safeGetStringProperty(rt, error, "name");
-          std::string message = safeGetStringProperty(rt, error, "message");
-          std::string stack = safeGetStringProperty(rt, error, "stack");
-
-          jmethodID emitMethod = jniEnv->GetMethodID(
-              cls,
-              "emitOnErrorFromJS",
-              "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Z)V");
-          jstring jName = jniEnv->NewStringUTF(name.c_str());
-          jstring jMsg = jniEnv->NewStringUTF(message.c_str());
-          jstring jStack = jniEnv->NewStringUTF(stack.c_str());
-          jniEnv->CallVoidMethod(
-              state->delegateRef,
-              emitMethod,
-              jName,
-              jMsg,
-              jStack,
-              (jboolean)isFatal);
-          jniEnv->DeleteLocalRef(jName);
-          jniEnv->DeleteLocalRef(jMsg);
-          jniEnv->DeleteLocalRef(jStack);
-        } else if (
-            originalHandler->isObject() &&
-            originalHandler->asObject(rt).isFunction(rt)) {
-          originalHandler->asObject(rt).asFunction(rt).call(rt, args, count);
+        const jsi::Object& error = args[0].asObject(rt);
+        bool isFatal = args[1].getBool();
+        std::string name = safeGetStringProperty(rt, error, "name");
+        std::string message = safeGetStringProperty(rt, error, "message");
+        std::string stack = safeGetStringProperty(rt, error, "stack");
+
+        bool handled = false;
+
+        // When an origin is set, broadcast the error to ALL delegates
+        // registered for this origin so every view sharing the VM can
+        // independently receive onError events.
+        if (!state->origin.empty()) {
+          auto& registry = rnsandbox::SandboxRegistry::getInstance();
+          auto delegates = registry.findAll(state->origin);
+          for (auto& delegate : delegates) {
+            // Each JNISandboxDelegate routes through the Kotlin delegate
+            // which checks hasOnErrorHandler before emitting.
+            delegate->postError(name, message, stack, isFatal);
+            handled = true;
+          }
+        }
+
+        if (!handled) {
+          jclass cls = jniEnv->GetObjectClass(state->delegateRef);
+          jfieldID hasHandlerField =
+              jniEnv->GetFieldID(cls, "hasOnErrorHandler", "Z");
+          jboolean hasHandler =
+              jniEnv->GetBooleanField(state->delegateRef, hasHandlerField);
+
+          if (hasHandler) {
+            jmethodID emitMethod = jniEnv->GetMethodID(
+                cls,
+                "emitOnErrorFromJS",
+                "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Z)V");
+            jstring jName = jniEnv->NewStringUTF(name.c_str());
+            jstring jMsg = jniEnv->NewStringUTF(message.c_str());
+            jstring jStack = jniEnv->NewStringUTF(stack.c_str());
+            jniEnv->CallVoidMethod(
+                state->delegateRef,
+                emitMethod,
+                jName,
+                jMsg,
+                jStack,
+                (jboolean)isFatal);
+            jniEnv->DeleteLocalRef(jName);
+            jniEnv->DeleteLocalRef(jMsg);
+            jniEnv->DeleteLocalRef(jStack);
+          } else if (
+              originalHandler->isObject() &&
+              originalHandler->asObject(rt).isFunction(rt)) {
+            originalHandler->asObject(rt).asFunction(rt).call(rt, args, count);
+          }
+
+          jniEnv->DeleteLocalRef(cls);
         }
 
-        jniEnv->DeleteLocalRef(cls);
         return jsi::Value::undefined();
       });
 
@@ -273,13 +356,114 @@ jlong installSandboxJSIBindings(
           std::string targetOrigin = args[1].getString(rt).utf8(rt);
 
           auto& registry = rnsandbox::SandboxRegistry::getInstance();
+
+          // Check if target exists before checking permissions
           auto targets = registry.findAll(targetOrigin);
-          if (!targets.empty()) {
-            for (auto& target : targets) {
-              target->postMessage(messageJson);
+          if (targets.empty()) {
+            // Target not found — broadcast routing error to all delegates
+            // for the sender's origin so every surface sees it.
+            if (!statePtr->origin.empty()) {
+              auto senderDelegates = registry.findAll(statePtr->origin);
+              std::string errMsg =
+                  "Target sandbox '" + targetOrigin + "' not found";
+              for (auto& d : senderDelegates) {
+                d->postError("SandboxRoutingError", errMsg, "", false);
+              }
+            } else if (statePtr->registryDelegate) {
+              std::string errMsg =
+                  "Target sandbox '" + targetOrigin + "' not found";
+              statePtr->registryDelegate->postError(
+                  "SandboxRoutingError", errMsg, "", false);
+            } else {
+              LOGW("postMessage: target '%s' not found", targetOrigin.c_str());
             }
+            return jsi::Value(false);
+          }
+
+          // Enforce allowedOrigins access control
+          if (!registry.isPermittedFrom(statePtr->origin, targetOrigin)) {
+            if (!statePtr->origin.empty()) {
+              auto senderDelegates = registry.findAll(statePtr->origin);
+              std::string errMsg = "Access denied: Sandbox '" +
+                  statePtr->origin +
+                  "' is not permitted to send messages to '" + targetOrigin +
+                  "'";
+              for (auto& d : senderDelegates) {
+                d->postError("AccessDeniedError", errMsg, "", false);
+              }
+            } else if (statePtr->registryDelegate) {
+              std::string errMsg = "Access denied: Sandbox '" +
+                  statePtr->origin +
+                  "' is not permitted to send messages to '" + targetOrigin +
+                  "'";
+              statePtr->registryDelegate->postError(
+                  "AccessDeniedError", errMsg, "", false);
+            }
+            return jsi::Value(false);
+          }
+
+          // All delegates for a given origin share the same JS runtime
+          // and setOnMessage callbacks, so deliver to JS only once.
+          targets.front()->postMessage(messageJson);
+        } else if (!statePtr->origin.empty()) {
+          // Per-surface routing: if the message contains __sandboxDelegateId,
+          // route only to that specific delegate instead of broadcasting.
+          std::string delegateId;
+          if (args[0].isObject()) {
+            jsi::Object msgObj = args[0].getObject(rt);
+            jsi::Value idVal = msgObj.getProperty(rt, "__sandboxDelegateId");
+            if (idVal.isString()) {
+              delegateId = idVal.getString(rt).utf8(rt);
+              // Create a shallow copy without __sandboxDelegateId to avoid
+              // mutating the caller's object (which may be frozen/sealed).
+              jsi::Object copy(rt);
+              jsi::Array names = msgObj.getPropertyNames(rt);
+              size_t len = names.size(rt);
+              for (size_t i = 0; i < len; ++i) {
+                jsi::String name = names.getValueAtIndex(rt, i).getString(rt);
+                if (name.utf8(rt) != "__sandboxDelegateId") {
+                  copy.setProperty(rt, name, msgObj.getProperty(rt, name));
+                }
+              }
+              messageJson = stringify.call(rt, copy).getString(rt).utf8(rt);
+            }
+          }
+
+          if (!delegateId.empty()) {
+            // Route to the specific delegate identified by delegateId
+            jclass delegateCls = jniEnv->FindClass(
+                "io/callstack/rnsandbox/SandboxReactNativeDelegate");
+            jmethodID findMethod = jniEnv->GetStaticMethodID(
+                delegateCls,
+                "findByDelegateId",
+                "(Ljava/lang/String;)"
+                "Lio/callstack/rnsandbox/SandboxReactNativeDelegate;");
+            jstring jDelegateId = jniEnv->NewStringUTF(delegateId.c_str());
+            jobject targetDelegate = jniEnv->CallStaticObjectMethod(
+                delegateCls, findMethod, jDelegateId);
+            if (targetDelegate) {
+              jclass cls = jniEnv->GetObjectClass(targetDelegate);
+              jmethodID mid = jniEnv->GetMethodID(
+                  cls, "emitOnMessageFromJS", "(Ljava/lang/String;)V");
+              jstring jMsg = jniEnv->NewStringUTF(messageJson.c_str());
+              jniEnv->CallVoidMethod(targetDelegate, mid, jMsg);
+              jniEnv->DeleteLocalRef(jMsg);
+              jniEnv->DeleteLocalRef(cls);
+              jniEnv->DeleteLocalRef(targetDelegate);
+            }
+            jniEnv->DeleteLocalRef(jDelegateId);
+            jniEnv->DeleteLocalRef(delegateCls);
           } else {
-            LOGW("postMessage: target '%s' not found", targetOrigin.c_str());
+            // No delegate ID — broadcast to all delegates (backward compat)
+            auto& registry = rnsandbox::SandboxRegistry::getInstance();
+            auto delegates = registry.findAll(statePtr->origin);
+            for (auto& delegate : delegates) {
+              auto* jniDelegate =
+                  dynamic_cast<JNISandboxDelegate*>(delegate.get());
+              if (jniDelegate) {
+                jniDelegate->emitOnMessageFromJS(messageJson);
+              }
+            }
           }
         } else {
           jclass cls = jniEnv->GetObjectClass(statePtr->delegateRef);
@@ -297,14 +481,15 @@ jlong installSandboxJSIBindings(
   auto setOnMessageFn = jsi::Function::createFromHostFunction(
       runtime,
       jsi::PropNameID::forAscii(runtime, "setOnMessage"),
-      1,
+      2,
       [stateWeak = std::weak_ptr<SandboxJSIState>(state)](
           jsi::Runtime& rt,
           const jsi::Value&,
           const jsi::Value* args,
           size_t count) -> jsi::Value {
-        if (count != 1) {
-          throw jsi::JSError(rt, "setOnMessage: expected exactly one argument");
+        if (count < 1 || count > 2) {
+          throw jsi::JSError(
+              rt, "setOnMessage(callback, delegateId?): expected 1 or 2 args");
         }
         if (!args[0].isObject() || !args[0].asObject(rt).isFunction(rt)) {
           throw jsi::JSError(rt, "setOnMessage: argument must be a function");
@@ -314,12 +499,25 @@ jlong installSandboxJSIBindings(
         if (!statePtr)
           return jsi::Value::undefined();
 
+        // Check for optional delegate ID (2nd arg) for per-surface registration
+        std::string delegateId;
+        if (count == 2 && args[1].isString()) {
+          delegateId = args[1].getString(rt).utf8(rt);
+        }
+
         std::vector<std::string> buffered;
+        auto fn = std::make_shared<jsi::Function>(
+            args[0].asObject(rt).asFunction(rt));
         {
           std::lock_guard<std::mutex> lock(statePtr->mutex);
-          statePtr->onMessageCallback.reset();
-          statePtr->onMessageCallback = std::make_shared<jsi::Function>(
-              args[0].asObject(rt).asFunction(rt));
+          if (!delegateId.empty()) {
+            // Per-surface: register under the delegate ID
+            statePtr->surfaceMessageCallbacks[delegateId] = fn;
+          } else {
+            // Legacy: single shared callback
+            statePtr->onMessageCallback.reset();
+            statePtr->onMessageCallback = fn;
+          }
           buffered.swap(statePtr->pendingMessages);
         }
 
@@ -330,7 +528,7 @@ jlong installSandboxJSIBindings(
                     .getPropertyAsObject(rt, "JSON")
                     .getPropertyAsFunction(rt, "parse")
                     .call(rt, jsi::String::createFromUtf8(rt, msg));
-            statePtr->onMessageCallback->call(rt, std::move(parsed));
+            fn->call(rt, std::move(parsed));
           } catch (const std::exception& e) {
             LOGE("Error flushing buffered message: %s", e.what());
           }
@@ -388,6 +586,39 @@ jlong installSandboxJSIBindings(
           jniEnv->GetFieldID(cls, "origin", "Ljava/lang/String;");
       auto jOrigin =
           (jstring)jniEnv->GetObjectField(globalDelegateRef, originField);
+
+      // Read allowedOrigins from the delegate
+      std::set<std::string> allowedOrigins;
+      jfieldID allowedOriginsField =
+          jniEnv->GetFieldID(cls, "allowedOrigins", "Ljava/util/Set;");
+      jobject jAllowedOrigins =
+          jniEnv->GetObjectField(globalDelegateRef, allowedOriginsField);
+      if (jAllowedOrigins) {
+        jclass setClass = jniEnv->FindClass("java/util/Set");
+        jmethodID iteratorMethod =
+            jniEnv->GetMethodID(setClass, "iterator", "()Ljava/util/Iterator;");
+        jobject iterator =
+            jniEnv->CallObjectMethod(jAllowedOrigins, iteratorMethod);
+        jclass iterClass = jniEnv->FindClass("java/util/Iterator");
+        jmethodID hasNextMethod =
+            jniEnv->GetMethodID(iterClass, "hasNext", "()Z");
+        jmethodID nextMethod =
+            jniEnv->GetMethodID(iterClass, "next", "()Ljava/lang/Object;");
+        while (jniEnv->CallBooleanMethod(iterator, hasNextMethod)) {
+          auto jStr = (jstring)jniEnv->CallObjectMethod(iterator, nextMethod);
+          if (jStr) {
+            const char* chars = jniEnv->GetStringUTFChars(jStr, nullptr);
+            allowedOrigins.insert(std::string(chars));
+            jniEnv->ReleaseStringUTFChars(jStr, chars);
+            jniEnv->DeleteLocalRef(jStr);
+          }
+        }
+        jniEnv->DeleteLocalRef(iterator);
+        jniEnv->DeleteLocalRef(iterClass);
+        jniEnv->DeleteLocalRef(setClass);
+        jniEnv->DeleteLocalRef(jAllowedOrigins);
+      }
+
       jniEnv->DeleteLocalRef(cls);
       if (jOrigin) {
         const char* originChars = jniEnv->GetStringUTFChars(jOrigin, nullptr);
@@ -398,9 +629,10 @@ jlong installSandboxJSIBindings(
           state->origin = origin;
           auto delegate =
               std::make_shared<JNISandboxDelegate>(jniEnv, globalDelegateRef);
+          delegate->setOrigin(origin);
           state->registryDelegate = delegate;
           rnsandbox::SandboxRegistry::getInstance().registerSandbox(
-              origin, delegate, std::set<std::string>());
+              origin, delegate, allowedOrigins);
         }
       }
     }
@@ -451,15 +683,31 @@ Java_io_callstack_rnsandbox_SandboxJSIInstaller_nativePostMessage(
   std::string messageStr(msgChars);
   env->ReleaseStringUTFChars(message, msgChars);
 
-  std::lock_guard<std::mutex> lock(state->mutex);
-  if (!state->runtime)
-    return;
+  // Copy callbacks out while holding the lock, then release before invoking
+  // them. This prevents a deadlock if a JS callback synchronously calls
+  // setOnMessage (or similar), which would attempt to re-acquire state->mutex
+  // — a non-recursive std::mutex.
+  std::shared_ptr<jsi::Function> onMsgCb;
+  std::vector<std::shared_ptr<jsi::Function>> surfaceCbs;
 
-  if (!state->onMessageCallback) {
-    state->pendingMessages.push_back(std::move(messageStr));
-    return;
+  {
+    std::lock_guard<std::mutex> lock(state->mutex);
+    if (!state->runtime)
+      return;
+
+    if (!state->onMessageCallback && state->surfaceMessageCallbacks.empty()) {
+      state->pendingMessages.push_back(std::move(messageStr));
+      return;
+    }
+
+    onMsgCb = state->onMessageCallback;
+    for (auto& [id, cb] : state->surfaceMessageCallbacks) {
+      if (cb)
+        surfaceCbs.push_back(cb);
+    }
   }
 
+  // Lock released — safe to invoke JS callbacks
   try {
     jsi::Runtime& rt = *state->runtime;
     jsi::Value parsed =
@@ -467,11 +715,15 @@ Java_io_callstack_rnsandbox_SandboxJSIInstaller_nativePostMessage(
             .getPropertyAsObject(rt, "JSON")
             .getPropertyAsFunction(rt, "parse")
             .call(rt, jsi::String::createFromUtf8(rt, messageStr));
-    state->onMessageCallback->call(rt, std::move(parsed));
 
-    // runOnJSQueueThread does not drain the microtask queue, so React/Fabric
-    // never sees the state update. Drain explicitly to mirror what the
-    // RuntimeExecutor (and iOS's callFunctionOnBufferedRuntimeExecutor) does.
+    if (onMsgCb) {
+      onMsgCb->call(rt, parsed);
+    }
+
+    for (auto& cb : surfaceCbs) {
+      cb->call(rt, parsed);
+    }
+
     rt.drainMicrotasks();
   } catch (const jsi::JSError& e) {
     LOGE("JSError in postMessage: %s", e.getMessage().c_str());
@@ -480,6 +732,16 @@ Java_io_callstack_rnsandbox_SandboxJSIInstaller_nativePostMessage(
   }
 }
 
+// Holds a registered delegate so it can be unregistered later.
+struct RegisteredDelegateHandle {
+  std::string origin;
+  std::shared_ptr<JNISandboxDelegate> delegate;
+};
+
+static std::mutex gDelegateHandleMutex;
+static std::unordered_map<jlong, std::shared_ptr<RegisteredDelegateHandle>>
+    gDelegateHandles;
+
 JNIEXPORT void JNICALL
 Java_io_callstack_rnsandbox_SandboxJSIInstaller_nativeInstallErrorHandler(
     JNIEnv*,
@@ -530,6 +792,7 @@ Java_io_callstack_rnsandbox_SandboxJSIInstaller_nativeDestroy(
       delegate = it->second->registryDelegate;
       delegateRef = it->second->delegateRef;
       it->second->onMessageCallback.reset();
+      it->second->surfaceMessageCallbacks.clear();
       it->second->pendingMessages.clear();
       it->second->runtime = nullptr;
       it->second->registryDelegate.reset();
@@ -549,4 +812,139 @@ Java_io_callstack_rnsandbox_SandboxJSIInstaller_nativeDestroy(
   }
 }
 
+JNIEXPORT jlong JNICALL
+Java_io_callstack_rnsandbox_SandboxJSIInstaller_nativeRegisterDelegate(
+    JNIEnv* env,
+    jclass,
+    jstring origin,
+    jobject delegateRef) {
+  if (!origin || !delegateRef)
+    return 0;
+
+  const char* originChars = env->GetStringUTFChars(origin, nullptr);
+  std::string originStr(originChars);
+  env->ReleaseStringUTFChars(origin, originChars);
+
+  if (originStr.empty())
+    return 0;
+
+  // Read allowedOrigins from the delegate
+  std::set<std::string> allowedOrigins;
+  jclass cls = env->GetObjectClass(delegateRef);
+  jfieldID allowedOriginsField =
+      env->GetFieldID(cls, "allowedOrigins", "Ljava/util/Set;");
+  jobject jAllowedOrigins =
+      env->GetObjectField(delegateRef, allowedOriginsField);
+  if (jAllowedOrigins) {
+    jclass setClass = env->FindClass("java/util/Set");
+    jmethodID iteratorMethod =
+        env->GetMethodID(setClass, "iterator", "()Ljava/util/Iterator;");
+    jobject iterator = env->CallObjectMethod(jAllowedOrigins, iteratorMethod);
+    jclass iterClass = env->FindClass("java/util/Iterator");
+    jmethodID hasNextMethod = env->GetMethodID(iterClass, "hasNext", "()Z");
+    jmethodID nextMethod =
+        env->GetMethodID(iterClass, "next", "()Ljava/lang/Object;");
+    while (env->CallBooleanMethod(iterator, hasNextMethod)) {
+      auto jStr = (jstring)env->CallObjectMethod(iterator, nextMethod);
+      if (jStr) {
+        const char* chars = env->GetStringUTFChars(jStr, nullptr);
+        allowedOrigins.insert(std::string(chars));
+        env->ReleaseStringUTFChars(jStr, chars);
+        env->DeleteLocalRef(jStr);
+      }
+    }
+    env->DeleteLocalRef(iterator);
+    env->DeleteLocalRef(iterClass);
+    env->DeleteLocalRef(setClass);
+    env->DeleteLocalRef(jAllowedOrigins);
+  }
+  env->DeleteLocalRef(cls);
+
+  auto delegate = std::make_shared<JNISandboxDelegate>(env, delegateRef);
+  delegate->setOrigin(originStr);
+  rnsandbox::SandboxRegistry::getInstance().registerSandbox(
+      originStr, delegate, allowedOrigins);
+
+  auto handle = std::make_shared<RegisteredDelegateHandle>();
+  handle->origin = originStr;
+  handle->delegate = delegate;
+
+  jlong handleId = reinterpret_cast<jlong>(handle.get());
+  {
+    std::lock_guard<std::mutex> lock(gDelegateHandleMutex);
+    gDelegateHandles[handleId] = handle;
+  }
+
+  return handleId;
+}
+
+JNIEXPORT void JNICALL
+Java_io_callstack_rnsandbox_SandboxJSIInstaller_nativeUnregisterDelegate(
+    JNIEnv*,
+    jclass,
+    jlong handle) {
+  std::lock_guard<std::mutex> lock(gDelegateHandleMutex);
+  auto it = gDelegateHandles.find(handle);
+  if (it != gDelegateHandles.end()) {
+    auto& h = it->second;
+    rnsandbox::SandboxRegistry::getInstance().unregisterDelegate(
+        h->origin, h->delegate);
+    h->delegate->invalidate();
+    gDelegateHandles.erase(it);
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_io_callstack_rnsandbox_SandboxJSIInstaller_nativeUnregisterStateDelegate(
+    JNIEnv*,
+    jclass,
+    jlong stateHandle) {
+  std::lock_guard<std::mutex> lock(gRegistryMutex);
+  auto it = gStates.find(stateHandle);
+  if (it != gStates.end()) {
+    std::lock_guard<std::mutex> stateLock(it->second->mutex);
+    auto& origin = it->second->origin;
+    auto& delegate = it->second->registryDelegate;
+    if (!origin.empty() && delegate) {
+      rnsandbox::SandboxRegistry::getInstance().unregisterDelegate(
+          origin, delegate);
+      delegate.reset();
+    }
+  }
+}
+
+JNIEXPORT void JNICALL
+Java_io_callstack_rnsandbox_SandboxJSIInstaller_nativeUpdateAllowedOrigins(
+    JNIEnv* env,
+    jclass,
+    jstring origin,
+    jobjectArray allowedOrigins) {
+  if (!origin)
+    return;
+
+  const char* originChars = env->GetStringUTFChars(origin, nullptr);
+  std::string originStr(originChars);
+  env->ReleaseStringUTFChars(origin, originChars);
+
+  if (originStr.empty())
+    return;
+
+  std::set<std::string> origins;
+  if (allowedOrigins) {
+    jsize len = env->GetArrayLength(allowedOrigins);
+    for (jsize i = 0; i < len; i++) {
+      auto jStr = (jstring)env->GetObjectArrayElement(allowedOrigins, i);
+      if (jStr) {
+        const char* chars = env->GetStringUTFChars(jStr, nullptr);
+        origins.insert(std::string(chars));
+        env->ReleaseStringUTFChars(jStr, chars);
+        env->DeleteLocalRef(jStr);
+      }
+    }
+  }
+
+  auto& registry = rnsandbox::SandboxRegistry::getInstance();
+  registry.updateAllowedOrigins(originStr, origins);
+}
+
 } // extern "C"
diff --git a/packages/react-native-sandbox/cxx/ISandboxDelegate.h b/packages/react-native-sandbox/cxx/ISandboxDelegate.h
index 095c9da..2d0b670 100644
--- a/packages/react-native-sandbox/cxx/ISandboxDelegate.h
+++ b/packages/react-native-sandbox/cxx/ISandboxDelegate.h
@@ -34,6 +34,19 @@ class ISandboxDelegate {
       const std::string& message,
       const std::string& targetId) = 0;
 
+  /**
+   * Posts an error to the host view.
+   * @param name Error name/type
+   * @param message Error message
+   * @param stack Stack trace (may be empty)
+   * @param isFatal Whether the error is fatal
+   */
+  virtual void postError(
+      const std::string& name,
+      const std::string& message,
+      const std::string& stack,
+      bool isFatal) = 0;
+
   /**
    * Sets the origin identifier for this sandbox.
    * @param origin Unique identifier for the sandbox
diff --git a/packages/react-native-sandbox/cxx/SandboxDelegateWrapper.h b/packages/react-native-sandbox/cxx/SandboxDelegateWrapper.h
index b42d146..f3332f3 100644
--- a/packages/react-native-sandbox/cxx/SandboxDelegateWrapper.h
+++ b/packages/react-native-sandbox/cxx/SandboxDelegateWrapper.h
@@ -32,6 +32,11 @@ class SandboxDelegateWrapper : public ISandboxDelegate {
   void postMessage(const std::string& message) override;
   bool routeMessage(const std::string& message, const std::string& targetId)
       override;
+  void postError(
+      const std::string& name,
+      const std::string& message,
+      const std::string& stack,
+      bool isFatal) override;
   void setOrigin(const std::string& origin) override;
   void setAllowedOrigins(const std::set<std::string>& origins) override;
   void setAllowedTurboModules(const std::set<std::string>& modules) override;
diff --git a/packages/react-native-sandbox/cxx/SandboxRegistry.cpp b/packages/react-native-sandbox/cxx/SandboxRegistry.cpp
index 928c88e..ced7162 100644
--- a/packages/react-native-sandbox/cxx/SandboxRegistry.cpp
+++ b/packages/react-native-sandbox/cxx/SandboxRegistry.cpp
@@ -20,12 +20,17 @@ void SandboxRegistry::registerSandbox(
 
   auto& delegates = sandboxRegistry_[origin];
   // Avoid duplicate registration of the same delegate
+  bool alreadyRegistered = false;
   for (const auto& d : delegates) {
     if (d == delegate) {
-      return;
+      alreadyRegistered = true;
+      break;
     }
   }
-  delegates.push_back(delegate);
+  if (!alreadyRegistered) {
+    delegates.push_back(delegate);
+  }
+  // Always update allowedOrigins (may change after initial registration)
   allowedOrigins_[origin] = allowedOrigins;
 }
 
@@ -105,12 +110,16 @@ bool SandboxRegistry::isPermittedFrom(
 
   std::lock_guard<std::recursive_mutex> lock(registryMutex_);
 
-  auto originsIt = allowedOrigins_.find(sourceOrigin);
+  // Check the TARGET's allowedOrigins to see if the source is permitted
+  // to send messages to it. This matches the documented semantics:
+  // "allowedOrigins specifies which sandbox origins are allowed to send
+  // messages TO this sandbox."
+  auto originsIt = allowedOrigins_.find(targetOrigin);
   if (originsIt == allowedOrigins_.end()) {
     return false;
   }
 
-  return originsIt->second.find(targetOrigin) != originsIt->second.end();
+  return originsIt->second.find(sourceOrigin) != originsIt->second.end();
 }
 
 void SandboxRegistry::reset() {
@@ -119,4 +128,15 @@ void SandboxRegistry::reset() {
   allowedOrigins_.clear();
 }
 
+void SandboxRegistry::updateAllowedOrigins(
+    const std::string& origin,
+    const std::set<std::string>& allowedOrigins) {
+  if (origin.empty()) {
+    return;
+  }
+
+  std::lock_guard<std::recursive_mutex> lock(registryMutex_);
+  allowedOrigins_[origin] = allowedOrigins;
+}
+
 } // namespace rnsandbox
diff --git a/packages/react-native-sandbox/cxx/SandboxRegistry.h b/packages/react-native-sandbox/cxx/SandboxRegistry.h
index 487c91f..ecb8b78 100644
--- a/packages/react-native-sandbox/cxx/SandboxRegistry.h
+++ b/packages/react-native-sandbox/cxx/SandboxRegistry.h
@@ -30,12 +30,27 @@ class SandboxRegistry {
   std::vector<std::shared_ptr<ISandboxDelegate>> findAll(
       const std::string& origin);
 
+  /**
+   * Checks whether sourceOrigin is permitted to send messages to targetOrigin.
+   * Returns true if the TARGET's allowedOrigins includes the source.
+   * This implements receiver-side access control: each sandbox's allowedOrigins
+   * specifies which origins are allowed to send messages TO it.
+   */
   bool isPermittedFrom(
       const std::string& sourceOrigin,
       const std::string& targetOrigin);
 
   void reset();
 
+  /**
+   * Updates the allowedOrigins for an existing origin without requiring
+   * a delegate reference. Used by Android when the allowedOrigins prop
+   * changes after initial registration.
+   */
+  void updateAllowedOrigins(
+      const std::string& origin,
+      const std::set<std::string>& allowedOrigins);
+
  private:
   SandboxRegistry() = default;
   SandboxRegistry(const SandboxRegistry&) = delete;
diff --git a/packages/react-native-sandbox/ios/SandboxDelegateWrapper.mm b/packages/react-native-sandbox/ios/SandboxDelegateWrapper.mm
index 36bcea8..f63af2d 100644
--- a/packages/react-native-sandbox/ios/SandboxDelegateWrapper.mm
+++ b/packages/react-native-sandbox/ios/SandboxDelegateWrapper.mm
@@ -25,6 +25,17 @@
   return [delegate_ routeMessage:message toSandbox:targetId];
 }
 
+void SandboxDelegateWrapper::postError(
+    const std::string &name,
+    const std::string &message,
+    const std::string &stack,
+    bool isFatal)
+{
+  if (!delegate_)
+    return;
+  [delegate_ postErrorWithName:name message:message stack:stack isFatal:isFatal];
+}
+
 void SandboxDelegateWrapper::setOrigin(const std::string &origin)
 {
   if (!delegate_)
diff --git a/packages/react-native-sandbox/ios/SandboxReactNativeDelegate.h b/packages/react-native-sandbox/ios/SandboxReactNativeDelegate.h
index d23f780..119fae9 100644
--- a/packages/react-native-sandbox/ios/SandboxReactNativeDelegate.h
+++ b/packages/react-native-sandbox/ios/SandboxReactNativeDelegate.h
@@ -77,6 +77,42 @@ NS_ASSUME_NONNULL_BEGIN
  */
 - (bool)routeMessage:(const std::string &)message toSandbox:(const std::string &)targetId;
 
+/**
+ * Posts an error to the host view via the event emitter.
+ * Used by the C++ SandboxRegistry to broadcast errors to all delegates
+ * sharing the same origin.
+ * @param name Error name/type
+ * @param message Error message
+ * @param stack Stack trace (may be empty)
+ * @param isFatal Whether the error is fatal
+ */
+- (void)postErrorWithName:(const std::string &)name
+                  message:(const std::string &)message
+                    stack:(const std::string &)stack
+                  isFatal:(bool)isFatal;
+
+/**
+ * Flushes any messages that were buffered because the event emitter wasn't
+ * ready when they arrived (warm start timing race). Called from the
+ * ComponentView after the event emitter is set.
+ */
+- (void)flushPendingHostMessages;
+
+/**
+ * Ensures the delegate is registered in the SandboxRegistry.
+ * Called before loading a React Native view to handle the case where
+ * the delegate was unregistered by TTL cleanup while the view was recycled
+ * with the same origin (setOrigin won't be called again in that case).
+ */
+- (void)ensureRegistered;
+
+/**
+ * Cleans up JSI resources and unregisters from the SandboxRegistry.
+ * Called when the idle TTL expires after the last sandbox for an origin unmounts,
+ * ensuring the registry entry is removed and the stale runtime reference is cleared.
+ */
+- (void)cleanupResources;
+
 @end
 
 NS_ASSUME_NONNULL_END
diff --git a/packages/react-native-sandbox/ios/SandboxReactNativeDelegate.mm b/packages/react-native-sandbox/ios/SandboxReactNativeDelegate.mm
index a559928..ae529e2 100644
--- a/packages/react-native-sandbox/ios/SandboxReactNativeDelegate.mm
+++ b/packages/react-native-sandbox/ios/SandboxReactNativeDelegate.mm
@@ -13,6 +13,7 @@
 #include <map>
 #include <memory>
 #include <mutex>
+#include <unordered_map>
 
 #import <React/RCTBridge+Private.h>
 #import <React/RCTBridge.h>
@@ -21,6 +22,7 @@
 #import <ReactAppDependencyProvider/RCTAppDependencyProvider.h>
 #import <ReactCommon/RCTInteropTurboModule.h>
 #import <ReactCommon/RCTTurboModule.h>
+#include <folly/json.h>
 
 #import <objc/runtime.h>
 
@@ -83,6 +85,10 @@ static void stubJsiFunction(jsi::Runtime &runtime, jsi::Object &object, const ch
 @interface SandboxReactNativeDelegate () {
   RCTInstance *_rctInstance;
   std::shared_ptr<jsi::Function> _onMessageSandbox;
+  // Per-surface message callbacks keyed by delegate ID.
+  // When a sandbox uses useSurfaceMessaging, its setOnMessage registers here
+  // so each surface gets its own listener even in a shared VM.
+  std::unordered_map<std::string, std::shared_ptr<jsi::Function>> _surfaceMessageCallbacks;
   std::shared_ptr<rnsandbox::SandboxDelegateWrapper> _delegateWrapper;
   std::set<std::string> _allowedTurboModules;
   std::set<std::string> _allowedOrigins;
@@ -90,6 +96,7 @@ @interface SandboxReactNativeDelegate () {
   std::string _origin;
   std::string _jsBundleSource;
   NSMutableDictionary<NSString *, id<RCTBridgeModule>> *_substitutedModuleInstances;
+  NSMutableArray<NSDictionary *> *_pendingHostMessages;
 }
 
 - (void)cleanupResources;
@@ -113,6 +120,7 @@ - (instancetype)init
     _hasOnMessageHandler = NO;
     _hasOnErrorHandler = NO;
     _substitutedModuleInstances = [NSMutableDictionary new];
+    _pendingHostMessages = [NSMutableArray new];
     self.dependencyProvider = [[RCTAppDependencyProvider alloc] init];
   }
   return self;
@@ -121,17 +129,46 @@ - (instancetype)init
 - (void)cleanupResources
 {
   _onMessageSandbox.reset();
+  _surfaceMessageCallbacks.clear();
   _rctInstance = nil;
   _allowedTurboModules.clear();
   _allowedOrigins.clear();
   _turboModuleSubstitutions.clear();
   [_substitutedModuleInstances removeAllObjects];
+  @synchronized(_pendingHostMessages) {
+    [_pendingHostMessages removeAllObjects];
+  }
   if (_delegateWrapper) {
     _delegateWrapper->invalidate();
     _delegateWrapper.reset();
   }
 }
 
+- (void)flushPendingHostMessages
+{
+  if (!self.eventEmitter || !self.hasOnMessageHandler) {
+    return;
+  }
+
+  NSArray<NSDictionary *> *messages;
+  @synchronized(_pendingHostMessages) {
+    if (_pendingHostMessages.count == 0) {
+      return;
+    }
+    messages = [_pendingHostMessages copy];
+    [_pendingHostMessages removeAllObjects];
+  }
+
+  for (NSDictionary *msg in messages) {
+    NSString *dataStr = msg[@"data"];
+    if (dataStr) {
+      folly::dynamic parsed = folly::parseJson([dataStr UTF8String]);
+      SandboxReactNativeViewEventEmitter::OnMessage messageEvent = {.data = parsed};
+      self.eventEmitter->onMessage(messageEvent);
+    }
+  }
+}
+
 #pragma mark - C++ Property Getters
 
 - (std::string)origin
@@ -162,7 +199,9 @@ - (void)setOrigin:(std::string)origin
 
   if (!_origin.empty()) {
     auto &registry = rnsandbox::SandboxRegistry::getInstance();
-    registry.unregister(_origin);
+    if (_delegateWrapper) {
+      registry.unregisterDelegate(_origin, _delegateWrapper);
+    }
   }
   if (_delegateWrapper) {
     _delegateWrapper->invalidate();
@@ -183,6 +222,32 @@ - (void)setJsBundleSource:(std::string)jsBundleSource
   _jsBundleSource = jsBundleSource;
 }
 
+- (void)ensureRegistered
+{
+  if (_origin.empty()) {
+    return;
+  }
+  // Check the registry directly rather than relying on _delegateWrapper,
+  // since registry.unregister() removes the entry without invalidating the wrapper.
+  auto &registry = rnsandbox::SandboxRegistry::getInstance();
+  auto existing = registry.findAll(_origin);
+  bool isRegistered = false;
+  for (const auto &d : existing) {
+    if (_delegateWrapper && d == _delegateWrapper) {
+      isRegistered = true;
+      break;
+    }
+  }
+  if (!isRegistered) {
+    if (_delegateWrapper) {
+      _delegateWrapper->invalidate();
+      _delegateWrapper.reset();
+    }
+    _delegateWrapper = std::make_shared<rnsandbox::SandboxDelegateWrapper>(self);
+    registry.registerSandbox(_origin, _delegateWrapper, _allowedOrigins);
+  }
+}
+
 - (void)setAllowedOrigins:(std::set<std::string>)allowedOrigins
 {
   _allowedOrigins = allowedOrigins;
@@ -214,13 +279,13 @@ - (void)setTurboModuleSubstitutions:(std::map<std::string, std::string>)turboMod
 - (void)dealloc
 {
   if (_delegateWrapper) {
+    if (!_origin.empty()) {
+      auto &registry = rnsandbox::SandboxRegistry::getInstance();
+      registry.unregisterDelegate(_origin, _delegateWrapper);
+    }
     _delegateWrapper->invalidate();
     _delegateWrapper.reset();
-  }
-  if (!_origin.empty()) {
-    auto &registry = rnsandbox::SandboxRegistry::getInstance();
-    registry.unregister(_origin);
-  } else {
+  } else if (_origin.empty()) {
     [self cleanupResources];
   }
 }
@@ -267,7 +332,8 @@ - (NSURL *)bundleURL
 
 - (void)postMessage:(const std::string &)message
 {
-  if (!_onMessageSandbox || !_rctInstance) {
+  bool hasAnyCallback = _onMessageSandbox || !_surfaceMessageCallbacks.empty();
+  if (!hasAnyCallback || !_rctInstance) {
     return;
   }
 
@@ -276,17 +342,22 @@ - (void)postMessage:(const std::string &)message
       // Validate runtime before any JSI operations
       runtime.global(); // Test if runtime is accessible
 
-      // Double-check the JSI function is still valid
-      if (!_onMessageSandbox) {
-        return;
-      }
-
       jsi::Value parsedValue = runtime.global()
                                    .getPropertyAsObject(runtime, "JSON")
                                    .getPropertyAsFunction(runtime, "parse")
                                    .call(runtime, jsi::String::createFromUtf8(runtime, message));
 
-      _onMessageSandbox->call(runtime, {std::move(parsedValue)});
+      // Invoke the legacy shared callback (if any)
+      if (_onMessageSandbox) {
+        _onMessageSandbox->call(runtime, parsedValue);
+      }
+
+      // Invoke all per-surface callbacks
+      for (auto &[id, cb] : _surfaceMessageCallbacks) {
+        if (cb) {
+          cb->call(runtime, parsedValue);
+        }
+      }
     } catch (const jsi::JSError &e) {
       if (self.eventEmitter && self.hasOnErrorHandler) {
         SandboxReactNativeViewEventEmitter::OnError errorEvent = {
@@ -308,27 +379,44 @@ - (void)postMessage:(const std::string &)message
 - (bool)routeMessage:(const std::string &)message toSandbox:(const std::string &)targetId
 {
   auto &registry = rnsandbox::SandboxRegistry::getInstance();
-  auto target = registry.find(targetId);
-  if (!target) {
+
+  // Check if target exists before checking permissions
+  auto targets = registry.findAll(targetId);
+  if (targets.empty()) {
     return false;
   }
 
-  // Check if the current sandbox is permitted to send messages to the target
+  // Enforce allowedOrigins access control
   if (!registry.isPermittedFrom(_origin, targetId)) {
-    if (self.eventEmitter && self.hasOnErrorHandler) {
-      std::string errorMessage =
-          fmt::format("Access denied: Sandbox '{}' is not permitted to send messages to '{}'", _origin, targetId);
-      SandboxReactNativeViewEventEmitter::OnError errorEvent = {
-          .isFatal = false, .name = "AccessDeniedError", .message = errorMessage, .stack = ""};
-      self.eventEmitter->onError(errorEvent);
-    }
-    return false;
+    [self postErrorWithName:"AccessDeniedError"
+                    message:fmt::format(
+                                "Access denied: Sandbox '{}' is not permitted to send messages to '{}'",
+                                _origin,
+                                targetId)
+                      stack:""
+                    isFatal:false];
+    return true; // Error already handled, don't emit SandboxRoutingError
   }
 
-  target->postMessage(message);
+  for (auto &target : targets) {
+    target->postMessage(message);
+  }
   return true;
 }
 
+- (void)postErrorWithName:(const std::string &)name
+                  message:(const std::string &)message
+                    stack:(const std::string &)stack
+                  isFatal:(bool)isFatal
+{
+  if (!self.eventEmitter || !self.hasOnErrorHandler) {
+    return;
+  }
+  SandboxReactNativeViewEventEmitter::OnError errorEvent = {
+      .isFatal = isFatal, .name = name, .message = message, .stack = stack};
+  self.eventEmitter->onError(errorEvent);
+}
+
 - (void)hostDidStart:(RCTHost *)host
 {
   if (!host) {
@@ -357,6 +445,14 @@ - (void)hostDidStart:(RCTHost *)host
     _onMessageSandbox = nullptr;
   }
 
+  // Same treatment for per-surface callbacks
+  for (auto &[id, cb] : _surfaceMessageCallbacks) {
+    if (cb) {
+      [[maybe_unused]] auto leaked = new std::shared_ptr<jsi::Function>(std::move(cb));
+    }
+  }
+  _surfaceMessageCallbacks.clear();
+
   _rctInstance = nil;
 
   Ivar ivar = class_getInstanceVariable([host class], "_instance");
@@ -367,8 +463,27 @@ - (void)hostDidStart:(RCTHost *)host
   }
 
   [_rctInstance callFunctionOnBufferedRuntimeExecutor:[=](jsi::Runtime &runtime) {
-    facebook::react::defineReadOnlyGlobal(runtime, "postMessage", [self createPostMessageFunction:runtime]);
-    facebook::react::defineReadOnlyGlobal(runtime, "setOnMessage", [self createSetOnMessageFunction:runtime]);
+    auto postMessageFn = [self createPostMessageFunction:runtime];
+    auto setOnMessageFn = [self createSetOnMessageFunction:runtime];
+
+    // Use Object.defineProperty with configurable:true so that warm-start
+    // re-installations can redefine these globals for the new delegate.
+    jsi::Object global = runtime.global();
+    jsi::Object objectCtor = global.getPropertyAsObject(runtime, "Object");
+    jsi::Function defineProperty = objectCtor.getPropertyAsFunction(runtime, "defineProperty");
+
+    auto defineGlobal = [&](const char *name, jsi::Function &&fn) {
+      jsi::Object descriptor(runtime);
+      descriptor.setProperty(runtime, "value", std::move(fn));
+      descriptor.setProperty(runtime, "writable", false);
+      descriptor.setProperty(runtime, "enumerable", false);
+      descriptor.setProperty(runtime, "configurable", true);
+      defineProperty.call(runtime, global, jsi::String::createFromAscii(runtime, name), descriptor);
+    };
+
+    defineGlobal("postMessage", std::move(postMessageFn));
+    defineGlobal("setOnMessage", std::move(setOnMessageFn));
+
     [self setupErrorHandler:runtime];
     // Must run post-bundle (in the buffered executor) because:
     // 1. installConsoleHandler sets __FUSEBOX = true during runtime init
@@ -662,45 +777,41 @@ - (Class)getModuleClassFromName:(const char *)name
           std::string targetOrigin = targetOriginArg.getString(rt).utf8(rt);
 
           // Prevent self-targeting
-          if (_origin == targetOrigin) {
-            if (self.eventEmitter && self.hasOnErrorHandler) {
-              std::string errorMessage = fmt::format("Cannot send message to self (sandbox '{}')", targetOrigin);
-              SandboxReactNativeViewEventEmitter::OnError errorEvent = {
-                  .isFatal = false, .name = "SelfTargetingError", .message = errorMessage, .stack = ""};
-              self.eventEmitter->onError(errorEvent);
-            } else {
-              // Fallback: throw JSError if no error handler
-              throw jsi::JSError(rt, fmt::format("Cannot send message to self (sandbox '{}')", targetOrigin).c_str());
-            }
-            return jsi::Value::undefined();
-          }
-
           // Convert message to JSON string
           jsi::Object jsonObject = rt.global().getPropertyAsObject(rt, "JSON");
           jsi::Function jsonStringify = jsonObject.getPropertyAsFunction(rt, "stringify");
           jsi::Value jsonResult = jsonStringify.call(rt, messageArg);
           std::string messageJson = jsonResult.getString(rt).utf8(rt);
 
-          // Route message to specific sandbox
+          // Route message to specific sandbox (same-origin allowed, matches Android)
           BOOL success = [self routeMessage:messageJson toSandbox:targetOrigin];
           if (!success) {
-            // Target sandbox doesn't exist - trigger error event
+            // Target sandbox doesn't exist
             if (self.eventEmitter && self.hasOnErrorHandler) {
               std::string errorMessage = fmt::format("Target sandbox '{}' not found", targetOrigin);
               SandboxReactNativeViewEventEmitter::OnError errorEvent = {
                   .isFatal = false, .name = "SandboxRoutingError", .message = errorMessage, .stack = ""};
               self.eventEmitter->onError(errorEvent);
             } else {
-              // Fallback: throw JSError if no error handler
               std::string errorMessage = fmt::format("Target sandbox '{}' not found", targetOrigin);
               throw jsi::JSError(rt, errorMessage.c_str());
             }
           }
         } else {
-          // targetOrigin is undefined/null - route to host (backward compatibility)
+          // targetOrigin is undefined/null - route to host
           if (self.eventEmitter && self.hasOnMessageHandler) {
             SandboxReactNativeViewEventEmitter::OnMessage messageEvent = {.data = jsi::dynamicFromValue(rt, args[0])};
             self.eventEmitter->onMessage(messageEvent);
+          } else {
+            // Event emitter or handler not ready yet (warm start race). Buffer the message.
+            jsi::Object jsonObject = rt.global().getPropertyAsObject(rt, "JSON");
+            jsi::Function jsonStringify = jsonObject.getPropertyAsFunction(rt, "stringify");
+            jsi::Value jsonResult = jsonStringify.call(rt, args[0]);
+            std::string messageJson = jsonResult.getString(rt).utf8(rt);
+            NSString *nsMsg = [NSString stringWithUTF8String:messageJson.c_str()];
+            @synchronized(_pendingHostMessages) {
+              [_pendingHostMessages addObject:@{@"data" : nsMsg}];
+            }
           }
         }
 
@@ -713,10 +824,10 @@ - (Class)getModuleClassFromName:(const char *)name
   return jsi::Function::createFromHostFunction(
       runtime,
       jsi::PropNameID::forAscii(runtime, "setOnMessage"),
-      1,
+      2, // Accept 1 or 2 arguments: callback and optional delegateId
       [=](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, size_t count) {
-        if (count != 1) {
-          throw jsi::JSError(rt, "Expected exactly one argument");
+        if (count < 1 || count > 2) {
+          throw jsi::JSError(rt, "Expected 1 or 2 arguments: setOnMessage(callback, delegateId?)");
         }
 
         const jsi::Value &arg = args[0];
@@ -726,10 +837,20 @@ - (Class)getModuleClassFromName:(const char *)name
 
         jsi::Function fn = arg.asObject(rt).asFunction(rt);
 
-        // Safely reset existing function before assigning new one
-        // This prevents crash if old function is tied to invalid runtime
-        _onMessageSandbox.reset();
-        _onMessageSandbox = std::make_shared<jsi::Function>(std::move(fn));
+        // Check for optional delegate ID (2nd arg) for per-surface registration
+        std::string delegateId;
+        if (count == 2 && args[1].isString()) {
+          delegateId = args[1].getString(rt).utf8(rt);
+        }
+
+        if (!delegateId.empty()) {
+          // Per-surface: register under the delegate ID
+          _surfaceMessageCallbacks[delegateId] = std::make_shared<jsi::Function>(std::move(fn));
+        } else {
+          // Legacy: single shared callback (last-writer-wins)
+          _onMessageSandbox.reset();
+          _onMessageSandbox = std::make_shared<jsi::Function>(std::move(fn));
+        }
 
         return jsi::Value::undefined();
       });
@@ -746,31 +867,67 @@ - (void)setupErrorHandler:(jsi::Runtime &)runtime
 
   jsi::Object errorUtils = errorUtilsVal.asObject(runtime);
 
+  // On warm start, setGlobalHandler is already stubbed — our error handler
+  // from the cold start is still active and broadcasts via the registry,
+  // so we can safely skip re-installation.
+  jsi::Value setHandlerVal = errorUtils.getProperty(runtime, "setGlobalHandler");
+  if (!setHandlerVal.isObject() || !setHandlerVal.asObject(runtime).isFunction(runtime)) {
+    return;
+  }
+  // Check if it's our stub (stub has length 1 and returns undefined for any input).
+  // A more reliable check: try to get the handler name. If setGlobalHandler was
+  // already called and stubbed, just skip.
+  jsi::Function setHandlerFn = setHandlerVal.asObject(runtime).asFunction(runtime);
+  // The stub we install has the name "setGlobalHandler" but accepts 1 arg.
+  // The real RN setGlobalHandler also accepts 1 arg. We need a different signal.
+  // Simplest: use a flag property on ErrorUtils to mark that we've installed.
+  jsi::Value installedFlag = errorUtils.getProperty(runtime, "__sandboxErrorHandlerInstalled");
+  if (!installedFlag.isUndefined() && installedFlag.getBool()) {
+    return;
+  }
+
   std::shared_ptr<jsi::Value> originalHandler = std::make_shared<jsi::Value>(
       errorUtils.getProperty(runtime, "getGlobalHandler").asObject(runtime).asFunction(runtime).call(runtime));
 
+  SandboxReactNativeDelegate *__weak weakSelf = self;
+
   auto handlerFunc = jsi::Function::createFromHostFunction(
       runtime,
       jsi::PropNameID::forAscii(runtime, "customGlobalErrorHandler"),
       2,
-      [=, originalHandler = std::move(originalHandler)](
+      [weakSelf, capturedOrigin = std::string(_origin), originalHandler = std::move(originalHandler)](
           jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args, size_t count) -> jsi::Value {
         if (count < 2) {
           return jsi::Value::undefined();
         }
 
-        if (self.eventEmitter && self.hasOnErrorHandler) {
-          const jsi::Object &error = args[0].asObject(rt);
-          bool isFatal = args[1].getBool();
-
-          SandboxReactNativeViewEventEmitter::OnError errorEvent = {
-              .isFatal = isFatal,
-              .name = safeGetStringProperty(rt, error, "name"),
-              .message = safeGetStringProperty(rt, error, "message"),
-              .stack = safeGetStringProperty(rt, error, "stack")};
-          self.eventEmitter->onError(errorEvent);
-        } else { // Call the original handler
-          if (originalHandler->isObject() && originalHandler->asObject(rt).isFunction(rt)) {
+        const jsi::Object &error = args[0].asObject(rt);
+        bool isFatal = args[1].getBool();
+        std::string name = safeGetStringProperty(rt, error, "name");
+        std::string message = safeGetStringProperty(rt, error, "message");
+        std::string stack = safeGetStringProperty(rt, error, "stack");
+
+        bool handled = false;
+
+        // When an origin is set, broadcast the error to ALL delegates
+        // registered for this origin so every view sharing the VM can
+        // independently receive onError events (matches Android behavior).
+        if (!capturedOrigin.empty()) {
+          auto &registry = rnsandbox::SandboxRegistry::getInstance();
+          auto delegates = registry.findAll(capturedOrigin);
+          for (auto &delegate : delegates) {
+            delegate->postError(name, message, stack, isFatal);
+            handled = true;
+          }
+        }
+
+        if (!handled) {
+          SandboxReactNativeDelegate *strongSelf = weakSelf;
+          if (strongSelf && strongSelf.eventEmitter && strongSelf.hasOnErrorHandler) {
+            SandboxReactNativeViewEventEmitter::OnError errorEvent = {
+                .isFatal = isFatal, .name = name, .message = message, .stack = stack};
+            strongSelf.eventEmitter->onError(errorEvent);
+          } else if (originalHandler->isObject() && originalHandler->asObject(rt).isFunction(rt)) {
             jsi::Function original = originalHandler->asObject(rt).asFunction(rt);
             original.call(rt, args, count);
           }
@@ -781,10 +938,13 @@ - (void)setupErrorHandler:(jsi::Runtime &)runtime
 
   // Set the new global error handler
   jsi::Function setHandler = errorUtils.getProperty(runtime, "setGlobalHandler").asObject(runtime).asFunction(runtime);
-  setHandler.call(runtime, {std::move(handlerFunc)});
+  setHandler.call(runtime, std::move(handlerFunc));
 
-  // Disable further setGlobalHandler from sandbox
+  // Disable further setGlobalHandler from sandbox JS code
   stubJsiFunction(runtime, errorUtils, "setGlobalHandler");
+
+  // Mark that our error handler is installed so warm starts skip re-installation
+  errorUtils.setProperty(runtime, "__sandboxErrorHandlerInstalled", true);
 }
 
 @end
diff --git a/packages/react-native-sandbox/ios/SandboxReactNativeViewComponentView.mm b/packages/react-native-sandbox/ios/SandboxReactNativeViewComponentView.mm
index 70bc65c..2145fcf 100644
--- a/packages/react-native-sandbox/ios/SandboxReactNativeViewComponentView.mm
+++ b/packages/react-native-sandbox/ios/SandboxReactNativeViewComponentView.mm
@@ -14,6 +14,8 @@
 
 #import "SandboxReactNativeDelegate.h"
 
+#include "SandboxRegistry.h"
+
 using namespace facebook::react;
 
 #pragma mark - SharedFactory (origin-based pooling)
@@ -75,6 +77,15 @@ - (void)updateEventEmitter:(const facebook::react::EventEmitter::Shared &)eventE
 {
   [super updateEventEmitter:eventEmitter];
   [self updateEventEmitterIfNeeded];
+
+  // If the factory was destroyed (e.g. by TTL cleanup) but the view is being
+  // remounted with the same props (so updateProps won't trigger a reload),
+  // detect this here and schedule a reload.
+  const auto &props = *std::static_pointer_cast<const SandboxReactNativeViewProps>(_props);
+  if (!self.reactNativeFactory && !self.reactNativeRootView && props.componentName.length() > 0 &&
+      props.jsBundleSource.length() > 0) {
+    [self scheduleReactViewLoad];
+  }
 }
 
 - (void)updateState:(const facebook::react::State::Shared &)state
@@ -152,6 +163,16 @@ - (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &
       newViewProps.jsBundleSource.length() > 0) {
     [self scheduleReactViewLoad];
   }
+
+  // If the factory was destroyed by TTL cleanup but the view still has a root
+  // view (props unchanged, so no reload was triggered above), force a reload.
+  // This handles the case where the same sandbox is re-added after TTL expiry.
+  if (self.reactNativeRootView && !self.reactNativeFactory && newViewProps.componentName.length() > 0 &&
+      newViewProps.jsBundleSource.length() > 0) {
+    [self.reactNativeRootView removeFromSuperview];
+    self.reactNativeRootView = nil;
+    [self scheduleReactViewLoad];
+  }
 }
 
 - (void)updateEventEmitterIfNeeded
@@ -159,6 +180,8 @@ - (void)updateEventEmitterIfNeeded
   if (self.reactNativeDelegate && _eventEmitter) {
     if (auto eventEmitter = std::static_pointer_cast<const SandboxReactNativeViewEventEmitter>(_eventEmitter)) {
       self.reactNativeDelegate.eventEmitter = eventEmitter;
+      // Flush any messages buffered during warm start before the emitter was ready
+      [self.reactNativeDelegate flushPendingHostMessages];
     }
   }
 }
@@ -197,6 +220,12 @@ - (void)loadReactNativeView
     return;
   }
 
+  // Ensure the delegate is registered in the SandboxRegistry before loading.
+  // The delegate may have been unregistered by TTL cleanup while the view was
+  // recycled with the same origin — setOrigin won't be called again in that
+  // case since the prop hasn't changed, so we force re-registration here.
+  [self.reactNativeDelegate ensureRegistered];
+
   NSDictionary *initialProperties = @{};
   if (!props.initialProperties.isNull()) {
     initialProperties = (NSDictionary *)convertFollyDynamicToId(props.initialProperties);
@@ -248,6 +277,15 @@ - (void)acquireFactory
       shared.idleTTLMs = MAX(shared.idleTTLMs, props.idleTTL);
       self.usesSharedFactory = YES;
       self.currentOrigin = origin;
+
+      // Warm start: the factory's RCTHost already has JSI bindings pointing
+      // to the old delegate. Re-install them on the existing runtime so
+      // postMessage/setOnMessage route to this new delegate.
+      RCTHost *host = shared.factory.rootViewFactory.reactHost;
+      if (host) {
+        [self.reactNativeDelegate hostDidStart:host];
+      }
+
       return;
     }
   }
@@ -295,6 +333,12 @@ - (void)releaseSharedFactory
         SharedFactory *current = sSharedFactories[origin];
         if (current && current.refCount <= 0 && current.destroyGeneration == gen) {
           [sSharedFactories removeObjectForKey:origin];
+          // Purge all delegates for this origin from the registry so that
+          // subsequent pings correctly get SandboxRoutingError.
+          // We use unregister (not unregisterDelegate) because the host is
+          // being torn down — all delegates for this origin are stale.
+          auto &registry = rnsandbox::SandboxRegistry::getInstance();
+          registry.unregister([origin UTF8String]);
         }
       });
     } else {
diff --git a/packages/react-native-sandbox/src/index.tsx b/packages/react-native-sandbox/src/index.tsx
index c01386e..0e6bf07 100644
--- a/packages/react-native-sandbox/src/index.tsx
+++ b/packages/react-native-sandbox/src/index.tsx
@@ -376,4 +376,5 @@ const SandboxReactNativeView = forwardRef<
 )
 
 SandboxReactNativeView.displayName = 'SandboxReactNativeView'
+export {useSurfaceMessaging} from './useSurfaceMessaging'
 export default SandboxReactNativeView
diff --git a/packages/react-native-sandbox/src/useSurfaceMessaging.ts b/packages/react-native-sandbox/src/useSurfaceMessaging.ts
new file mode 100644
index 0000000..db8b583
--- /dev/null
+++ b/packages/react-native-sandbox/src/useSurfaceMessaging.ts
@@ -0,0 +1,75 @@
+import {useCallback} from 'react'
+
+declare const globalThis: {
+  postMessage: (msg: unknown, targetOrigin?: string) => void
+  setOnMessage: (cb: (msg: unknown) => void, delegateId?: string) => void
+}
+
+/**
+ * Hook for sandbox components to send and receive messages scoped to their
+ * own surface when sharing an origin (and therefore a Hermes VM) with other
+ * sandboxes.
+ *
+ * Without this hook:
+ * - `globalThis.postMessage(msg)` broadcasts to ALL host views sharing the origin.
+ * - `globalThis.setOnMessage(cb)` is last-writer-wins (only one listener).
+ *
+ * With this hook:
+ * - `postMessage` attaches a routing hint so the message is delivered only to
+ *   the calling surface's parent view.
+ * - `setOnMessage` registers a per-surface listener so every surface receives
+ *   incoming sandbox-to-sandbox messages independently.
+ *
+ * Usage:
+ * ```tsx
+ * function MyWidget({__sandboxDelegateId}: Props) {
+ *   const {postMessage, setOnMessage} = useSurfaceMessaging(__sandboxDelegateId);
+ *
+ *   useEffect(() => {
+ *     const unsubscribe = setOnMessage((msg) => console.log('received', msg));
+ *     return unsubscribe;
+ *   }, [setOnMessage]);
+ *
+ *   postMessage({type: 'hello'});
+ * }
+ * ```
+ *
+ * @param delegateId - The `__sandboxDelegateId` prop injected by the native
+ *   side into initialProperties. If undefined, falls back to broadcast/shared.
+ */
+export function useSurfaceMessaging(delegateId?: string) {
+  const postMessage = useCallback(
+    (msg: unknown, targetOrigin?: string) => {
+      if (targetOrigin) {
+        // Cross-origin: forward directly without adding delegate routing hint.
+        // The native side routes by origin, not by delegate ID.
+        globalThis.postMessage(
+          typeof msg === 'object' && msg !== null ? msg : {data: msg},
+          targetOrigin
+        )
+        return
+      }
+      // Per-surface: attach routing hint for the host view
+      const payload =
+        typeof msg === 'object' && msg !== null ? {...msg} : {data: msg}
+      if (delegateId) {
+        ;(payload as Record<string, unknown>).__sandboxDelegateId = delegateId
+      }
+      globalThis.postMessage(payload)
+    },
+    [delegateId]
+  )
+
+  const setOnMessage = useCallback(
+    (cb: (msg: unknown) => void) => {
+      globalThis.setOnMessage(cb, delegateId)
+      // Return a cleanup function that unregisters the per-surface listener
+      return () => {
+        globalThis.setOnMessage(() => {}, delegateId)
+      }
+    },
+    [delegateId]
+  )
+
+  return {postMessage, setOnMessage}
+}
diff --git a/packages/react-native-sandbox/tests/MockSandboxDelegate.h b/packages/react-native-sandbox/tests/MockSandboxDelegate.h
index b68401f..74ae1b3 100644
--- a/packages/react-native-sandbox/tests/MockSandboxDelegate.h
+++ b/packages/react-native-sandbox/tests/MockSandboxDelegate.h
@@ -16,6 +16,14 @@ class MockSandboxDelegate : public ISandboxDelegate {
       routeMessage,
       (const std::string& message, const std::string& targetId),
       (override));
+  MOCK_METHOD(
+      void,
+      postError,
+      (const std::string& name,
+       const std::string& message,
+       const std::string& stack,
+       bool isFatal),
+      (override));
   MOCK_METHOD(void, setOrigin, (const std::string& origin), (override));
   MOCK_METHOD(
       void,
diff --git a/packages/react-native-sandbox/tests/SandboxRegistryTest.cpp b/packages/react-native-sandbox/tests/SandboxRegistryTest.cpp
index b2f708d..e6c4561 100644
--- a/packages/react-native-sandbox/tests/SandboxRegistryTest.cpp
+++ b/packages/react-native-sandbox/tests/SandboxRegistryTest.cpp
@@ -189,17 +189,20 @@ TEST_F(SandboxRegistryTest, AllowedOriginsOverwriteOnReRegistration) {
   auto delegate1 = std::make_shared<StrictMock<MockSandboxDelegate>>();
   auto delegate2 = std::make_shared<StrictMock<MockSandboxDelegate>>();
 
+  // shared-origin allows messages from "allowed-a" (receiver-side: allowed-a
+  // can send TO shared-origin)
   std::set<std::string> firstOrigins = {"allowed-a"};
   registry.registerSandbox("shared-origin", delegate1, firstOrigins);
-  EXPECT_TRUE(registry.isPermittedFrom("shared-origin", "allowed-a"));
-  EXPECT_FALSE(registry.isPermittedFrom("shared-origin", "allowed-b"));
+  EXPECT_TRUE(registry.isPermittedFrom("allowed-a", "shared-origin"));
+  EXPECT_FALSE(registry.isPermittedFrom("allowed-b", "shared-origin"));
 
+  // Re-registration overwrites allowedOrigins: now only "allowed-b" can send to
+  // shared-origin
   std::set<std::string> secondOrigins = {"allowed-b"};
   registry.registerSandbox("shared-origin", delegate2, secondOrigins);
 
-  // Second registration overwrites the allowedOrigins for the whole origin
-  EXPECT_FALSE(registry.isPermittedFrom("shared-origin", "allowed-a"));
-  EXPECT_TRUE(registry.isPermittedFrom("shared-origin", "allowed-b"));
+  EXPECT_FALSE(registry.isPermittedFrom("allowed-a", "shared-origin"));
+  EXPECT_TRUE(registry.isPermittedFrom("allowed-b", "shared-origin"));
 
   // Both delegates are still registered
   auto all = registry.findAll("shared-origin");
@@ -275,8 +278,11 @@ TEST_F(SandboxRegistryTest, ThreadSafety) {
             auto found = registry.find(origin);
             EXPECT_EQ(found, mockDelegate);
 
-            EXPECT_TRUE(registry.isPermittedFrom(origin, "other_sandbox"));
-            EXPECT_FALSE(registry.isPermittedFrom(origin, "blocked_sandbox"));
+            // With receiver-side semantics: "other_sandbox" would need to
+            // allow this origin. Instead test that this origin allows
+            // messages from "other_sandbox" (i.e. other_sandbox → origin).
+            EXPECT_TRUE(registry.isPermittedFrom("other_sandbox", origin));
+            EXPECT_FALSE(registry.isPermittedFrom("blocked_sandbox", origin));
 
             registry.unregisterDelegate(origin, mockDelegate);
 

From d614c3173ef3bd37a9a822f0d071ab7a5d118c6d Mon Sep 17 00:00:00 2001
From: Ryan Karn <rkarn@amazon.com>
Date: Wed, 3 Jun 2026 09:53:54 -0700
Subject: [PATCH 2/4] fix: add iOS surface ID injection and rename delegateId
 to surfaceId

Adds __sandboxSurfaceId injection into iOS initialProperties for
per-surface message routing parity with Android. Renames the concept
from delegateId to surfaceId across both platforms and JS to align
with existing RN surface terminology (PR #36 feedback).
---
 apps/origin-pooling/SandboxApp.tsx            |  6 +-
 apps/origin-pooling/SandboxAppConvention.tsx  | 24 +++----
 .../rnsandbox/SandboxReactNativeDelegate.kt   | 30 ++++----
 .../src/main/jni/SandboxJSIInstaller.cpp      | 38 +++++-----
 .../ios/SandboxReactNativeDelegate.h          |  7 ++
 .../ios/SandboxReactNativeDelegate.mm         | 70 +++++++++++++++----
 .../SandboxReactNativeViewComponentView.mm    |  6 ++
 .../src/useSurfaceMessaging.ts                | 26 +++----
 8 files changed, 131 insertions(+), 76 deletions(-)

diff --git a/apps/origin-pooling/SandboxApp.tsx b/apps/origin-pooling/SandboxApp.tsx
index 42ec2c0..6aa7bb5 100644
--- a/apps/origin-pooling/SandboxApp.tsx
+++ b/apps/origin-pooling/SandboxApp.tsx
@@ -17,11 +17,11 @@ import {
 type LogEntry = {dir: 'in' | 'out'; text: string; ts: number}
 
 type Props = {
-  __sandboxDelegateId?: string
+  __sandboxSurfaceId?: string
 }
 
-export default function SandboxApp({__sandboxDelegateId}: Props) {
-  const {postMessage, setOnMessage} = useSurfaceMessaging(__sandboxDelegateId)
+export default function SandboxApp({__sandboxSurfaceId}: Props) {
+  const {postMessage, setOnMessage} = useSurfaceMessaging(__sandboxSurfaceId)
   const [log, setLog] = useState<LogEntry[]>([])
   const instanceId = useRef(Math.random().toString(36).slice(2, 6)).current
   const seq = useRef(0)
diff --git a/apps/origin-pooling/SandboxAppConvention.tsx b/apps/origin-pooling/SandboxAppConvention.tsx
index ce3f6da..d6d5a5b 100644
--- a/apps/origin-pooling/SandboxAppConvention.tsx
+++ b/apps/origin-pooling/SandboxAppConvention.tsx
@@ -1,7 +1,7 @@
 /**
  * SandboxAppConvention — convention-based approach (no library dependency).
  *
- * Uses the __sandboxDelegateId prop directly with globalThis.postMessage
+ * Uses the __sandboxSurfaceId prop directly with globalThis.postMessage
  * and globalThis.setOnMessage for per-surface routing. No import from
  * @callstack/react-native-sandbox needed.
  */
@@ -16,16 +16,16 @@ import {
 
 declare const globalThis: {
   postMessage: (msg: unknown, targetOrigin?: string) => void
-  setOnMessage: (cb: (msg: unknown) => void, delegateId?: string) => void
+  setOnMessage: (cb: (msg: unknown) => void, surfaceId?: string) => void
 }
 
 type LogEntry = {dir: 'in' | 'out'; text: string; ts: number}
 
 type Props = {
-  __sandboxDelegateId?: string
+  __sandboxSurfaceId?: string
 }
 
-export default function SandboxAppConvention({__sandboxDelegateId}: Props) {
+export default function SandboxAppConvention({__sandboxSurfaceId}: Props) {
   const [log, setLog] = useState<LogEntry[]>([])
   const instanceId = useRef(Math.random().toString(36).slice(2, 6)).current
   const seq = useRef(0)
@@ -34,16 +34,14 @@ export default function SandboxAppConvention({__sandboxDelegateId}: Props) {
   const addLog = (dir: 'in' | 'out', text: string) =>
     setLog(prev => [...prev.slice(-19), {dir, text, ts: Date.now()}])
 
-  // Convention: spread __sandboxDelegateId into the payload for per-surface routing
+  // Convention: spread __sandboxSurfaceId into the payload for per-surface routing
   const send = React.useCallback(
     (msg: Record<string, unknown>, targetOrigin?: string) => {
       const payload =
-        !targetOrigin && __sandboxDelegateId
-          ? {...msg, __sandboxDelegateId}
-          : msg
+        !targetOrigin && __sandboxSurfaceId ? {...msg, __sandboxSurfaceId} : msg
       globalThis.postMessage(payload, targetOrigin)
     },
-    [__sandboxDelegateId]
+    [__sandboxSurfaceId]
   )
 
   useEffect(() => {
@@ -51,16 +49,16 @@ export default function SandboxAppConvention({__sandboxDelegateId}: Props) {
     addLog('out', `rendered (${instanceId})`)
   }, [instanceId, send])
 
-  // Convention: pass delegateId as 2nd arg for per-surface listener
+  // Convention: pass surfaceId as 2nd arg for per-surface listener
   useEffect(() => {
     globalThis.setOnMessage((msg: unknown) => {
       const data = msg as Record<string, unknown>
       addLog('in', `from ${data.instanceId ?? '?'}: ${data.type}`)
-    }, __sandboxDelegateId)
+    }, __sandboxSurfaceId)
     return () => {
-      globalThis.setOnMessage(() => {}, __sandboxDelegateId)
+      globalThis.setOnMessage(() => {}, __sandboxSurfaceId)
     }
-  }, [__sandboxDelegateId])
+  }, [__sandboxSurfaceId])
 
   const sendHeartbeat = () => {
     const s = ++seq.current
diff --git a/packages/react-native-sandbox/android/src/main/java/io/callstack/rnsandbox/SandboxReactNativeDelegate.kt b/packages/react-native-sandbox/android/src/main/java/io/callstack/rnsandbox/SandboxReactNativeDelegate.kt
index f061d4f..d101298 100644
--- a/packages/react-native-sandbox/android/src/main/java/io/callstack/rnsandbox/SandboxReactNativeDelegate.kt
+++ b/packages/react-native-sandbox/android/src/main/java/io/callstack/rnsandbox/SandboxReactNativeDelegate.kt
@@ -81,22 +81,22 @@ class SandboxReactNativeDelegate(
             var jsiStateHandle: Long = 0,
         )
 
-        private val nextDelegateId =
+        private val nextSurfaceId =
             java.util.concurrent.atomic
                 .AtomicLong(0)
-        private val delegateById = java.util.concurrent.ConcurrentHashMap<String, SandboxReactNativeDelegate>()
+        private val delegateBySurfaceId = java.util.concurrent.ConcurrentHashMap<String, SandboxReactNativeDelegate>()
 
         /**
-         * Finds a delegate by its unique ID. Called from JNI when postMessage
-         * includes a __sandboxDelegateId for per-surface routing.
+         * Finds a delegate by its surface ID. Called from JNI when postMessage
+         * includes a __sandboxSurfaceId for per-surface routing.
          */
         @JvmStatic
-        fun findByDelegateId(id: String): SandboxReactNativeDelegate? = delegateById[id]
+        fun findBySurfaceId(id: String): SandboxReactNativeDelegate? = delegateBySurfaceId[id]
     }
 
     @JvmField var origin: String = ""
 
-    @JvmField var delegateId: String = ""
+    @JvmField var surfaceId: String = ""
 
     var jsBundleSource: String = ""
     var allowedTurboModules: Set<String> = emptySet()
@@ -131,9 +131,9 @@ class SandboxReactNativeDelegate(
         val capturedBundleSource = jsBundleSource
         val capturedAllowedModules = allowedTurboModules
 
-        // Generate a unique delegate ID for per-surface message routing
-        delegateId = "delegate:${nextDelegateId.incrementAndGet()}"
-        delegateById[delegateId] = this
+        // Generate a unique surface ID for per-surface message routing
+        surfaceId = "surface:${nextSurfaceId.incrementAndGet()}"
+        delegateBySurfaceId[surfaceId] = this
 
         try {
             val shared = if (origin.isNotEmpty()) sharedHosts[origin] else null
@@ -233,7 +233,7 @@ class SandboxReactNativeDelegate(
             instanceEventListener = listener
             host.addReactInstanceEventListener(listener)
 
-            val surface = host.createSurface(sandboxContext, componentName, initialProperties.withDelegateId())
+            val surface = host.createSurface(sandboxContext, componentName, initialProperties.withSurfaceId())
             reactSurface = surface
 
             val activity = getActivity()
@@ -418,8 +418,8 @@ class SandboxReactNativeDelegate(
     }
 
     fun cleanup() {
-        if (delegateId.isNotEmpty()) {
-            delegateById.remove(delegateId)
+        if (surfaceId.isNotEmpty()) {
+            delegateBySurfaceId.remove(surfaceId)
         }
 
         synchronized(pendingHostMessages) {
@@ -517,12 +517,12 @@ class SandboxReactNativeDelegate(
     }
 
     /**
-     * Injects __sandboxDelegateId into the initialProperties Bundle so the
+     * Injects __sandboxSurfaceId into the initialProperties Bundle so the
      * sandbox JS can pass it back through useSurfaceMessaging for per-surface routing.
      */
-    private fun Bundle?.withDelegateId(): Bundle {
+    private fun Bundle?.withSurfaceId(): Bundle {
         val bundle = this ?: Bundle()
-        bundle.putString("__sandboxDelegateId", delegateId)
+        bundle.putString("__sandboxSurfaceId", surfaceId)
         return bundle
     }
 
diff --git a/packages/react-native-sandbox/android/src/main/jni/SandboxJSIInstaller.cpp b/packages/react-native-sandbox/android/src/main/jni/SandboxJSIInstaller.cpp
index 2cd6dd8..ee5b684 100644
--- a/packages/react-native-sandbox/android/src/main/jni/SandboxJSIInstaller.cpp
+++ b/packages/react-native-sandbox/android/src/main/jni/SandboxJSIInstaller.cpp
@@ -406,22 +406,22 @@ jlong installSandboxJSIBindings(
           // and setOnMessage callbacks, so deliver to JS only once.
           targets.front()->postMessage(messageJson);
         } else if (!statePtr->origin.empty()) {
-          // Per-surface routing: if the message contains __sandboxDelegateId,
+          // Per-surface routing: if the message contains __sandboxSurfaceId,
           // route only to that specific delegate instead of broadcasting.
-          std::string delegateId;
+          std::string surfaceId;
           if (args[0].isObject()) {
             jsi::Object msgObj = args[0].getObject(rt);
-            jsi::Value idVal = msgObj.getProperty(rt, "__sandboxDelegateId");
+            jsi::Value idVal = msgObj.getProperty(rt, "__sandboxSurfaceId");
             if (idVal.isString()) {
-              delegateId = idVal.getString(rt).utf8(rt);
-              // Create a shallow copy without __sandboxDelegateId to avoid
+              surfaceId = idVal.getString(rt).utf8(rt);
+              // Create a shallow copy without __sandboxSurfaceId to avoid
               // mutating the caller's object (which may be frozen/sealed).
               jsi::Object copy(rt);
               jsi::Array names = msgObj.getPropertyNames(rt);
               size_t len = names.size(rt);
               for (size_t i = 0; i < len; ++i) {
                 jsi::String name = names.getValueAtIndex(rt, i).getString(rt);
-                if (name.utf8(rt) != "__sandboxDelegateId") {
+                if (name.utf8(rt) != "__sandboxSurfaceId") {
                   copy.setProperty(rt, name, msgObj.getProperty(rt, name));
                 }
               }
@@ -429,18 +429,18 @@ jlong installSandboxJSIBindings(
             }
           }
 
-          if (!delegateId.empty()) {
-            // Route to the specific delegate identified by delegateId
+          if (!surfaceId.empty()) {
+            // Route to the specific delegate identified by surfaceId
             jclass delegateCls = jniEnv->FindClass(
                 "io/callstack/rnsandbox/SandboxReactNativeDelegate");
             jmethodID findMethod = jniEnv->GetStaticMethodID(
                 delegateCls,
-                "findByDelegateId",
+                "findBySurfaceId",
                 "(Ljava/lang/String;)"
                 "Lio/callstack/rnsandbox/SandboxReactNativeDelegate;");
-            jstring jDelegateId = jniEnv->NewStringUTF(delegateId.c_str());
+            jstring jSurfaceId = jniEnv->NewStringUTF(surfaceId.c_str());
             jobject targetDelegate = jniEnv->CallStaticObjectMethod(
-                delegateCls, findMethod, jDelegateId);
+                delegateCls, findMethod, jSurfaceId);
             if (targetDelegate) {
               jclass cls = jniEnv->GetObjectClass(targetDelegate);
               jmethodID mid = jniEnv->GetMethodID(
@@ -451,7 +451,7 @@ jlong installSandboxJSIBindings(
               jniEnv->DeleteLocalRef(cls);
               jniEnv->DeleteLocalRef(targetDelegate);
             }
-            jniEnv->DeleteLocalRef(jDelegateId);
+            jniEnv->DeleteLocalRef(jSurfaceId);
             jniEnv->DeleteLocalRef(delegateCls);
           } else {
             // No delegate ID — broadcast to all delegates (backward compat)
@@ -489,7 +489,7 @@ jlong installSandboxJSIBindings(
           size_t count) -> jsi::Value {
         if (count < 1 || count > 2) {
           throw jsi::JSError(
-              rt, "setOnMessage(callback, delegateId?): expected 1 or 2 args");
+              rt, "setOnMessage(callback, surfaceId?): expected 1 or 2 args");
         }
         if (!args[0].isObject() || !args[0].asObject(rt).isFunction(rt)) {
           throw jsi::JSError(rt, "setOnMessage: argument must be a function");
@@ -499,10 +499,10 @@ jlong installSandboxJSIBindings(
         if (!statePtr)
           return jsi::Value::undefined();
 
-        // Check for optional delegate ID (2nd arg) for per-surface registration
-        std::string delegateId;
+        // Check for optional surface ID (2nd arg) for per-surface registration
+        std::string surfaceId;
         if (count == 2 && args[1].isString()) {
-          delegateId = args[1].getString(rt).utf8(rt);
+          surfaceId = args[1].getString(rt).utf8(rt);
         }
 
         std::vector<std::string> buffered;
@@ -510,9 +510,9 @@ jlong installSandboxJSIBindings(
             args[0].asObject(rt).asFunction(rt));
         {
           std::lock_guard<std::mutex> lock(statePtr->mutex);
-          if (!delegateId.empty()) {
-            // Per-surface: register under the delegate ID
-            statePtr->surfaceMessageCallbacks[delegateId] = fn;
+          if (!surfaceId.empty()) {
+            // Per-surface: register under the surface ID
+            statePtr->surfaceMessageCallbacks[surfaceId] = fn;
           } else {
             // Legacy: single shared callback
             statePtr->onMessageCallback.reset();
diff --git a/packages/react-native-sandbox/ios/SandboxReactNativeDelegate.h b/packages/react-native-sandbox/ios/SandboxReactNativeDelegate.h
index 119fae9..c2a5e54 100644
--- a/packages/react-native-sandbox/ios/SandboxReactNativeDelegate.h
+++ b/packages/react-native-sandbox/ios/SandboxReactNativeDelegate.h
@@ -113,6 +113,13 @@ NS_ASSUME_NONNULL_BEGIN
  */
 - (void)cleanupResources;
 
+/**
+ * Generates a new unique surface ID for per-surface message routing.
+ * Called before each view load so the JS side can identify this surface.
+ * @return The generated surface ID string (e.g. "surface:1")
+ */
+- (NSString *)generateSurfaceId;
+
 @end
 
 NS_ASSUME_NONNULL_END
diff --git a/packages/react-native-sandbox/ios/SandboxReactNativeDelegate.mm b/packages/react-native-sandbox/ios/SandboxReactNativeDelegate.mm
index ae529e2..513fefe 100644
--- a/packages/react-native-sandbox/ios/SandboxReactNativeDelegate.mm
+++ b/packages/react-native-sandbox/ios/SandboxReactNativeDelegate.mm
@@ -10,6 +10,7 @@
 #include <jsi/JSIDynamic.h>
 #include <jsi/decorator.h>
 #include <react/utils/jsi-utils.h>
+#include <atomic>
 #include <map>
 #include <memory>
 #include <mutex>
@@ -95,6 +96,7 @@ @interface SandboxReactNativeDelegate () {
   std::map<std::string, std::string> _turboModuleSubstitutions;
   std::string _origin;
   std::string _jsBundleSource;
+  std::string _surfaceId;
   NSMutableDictionary<NSString *, id<RCTBridgeModule>> *_substitutedModuleInstances;
   NSMutableArray<NSDictionary *> *_pendingHostMessages;
 }
@@ -112,6 +114,10 @@ @implementation SandboxReactNativeDelegate
 // Note: Registry functionality has been moved to SandboxRegistry class
 // This class now focuses solely on delegate responsibilities
 
+static std::atomic<long> sNextSurfaceId{0};
+static std::mutex sDelegateBySurfaceIdMutex;
+static std::unordered_map<std::string, __unsafe_unretained SandboxReactNativeDelegate *> sDelegateBySurfaceId;
+
 #pragma mark - Instance Methods
 
 - (instancetype)init
@@ -126,11 +132,27 @@ - (instancetype)init
   return self;
 }
 
+- (NSString *)generateSurfaceId
+{
+  long nextId = ++sNextSurfaceId;
+  _surfaceId = "surface:" + std::to_string(nextId);
+  {
+    std::lock_guard<std::mutex> lock(sDelegateBySurfaceIdMutex);
+    sDelegateBySurfaceId[_surfaceId] = self;
+  }
+  return [NSString stringWithUTF8String:_surfaceId.c_str()];
+}
+
 - (void)cleanupResources
 {
   _onMessageSandbox.reset();
   _surfaceMessageCallbacks.clear();
   _rctInstance = nil;
+  if (!_surfaceId.empty()) {
+    std::lock_guard<std::mutex> lock(sDelegateBySurfaceIdMutex);
+    sDelegateBySurfaceId.erase(_surfaceId);
+  }
+  _surfaceId.clear();
   _allowedTurboModules.clear();
   _allowedOrigins.clear();
   _turboModuleSubstitutions.clear();
@@ -278,6 +300,10 @@ - (void)setTurboModuleSubstitutions:(std::map<std::string, std::string>)turboMod
 
 - (void)dealloc
 {
+  if (!_surfaceId.empty()) {
+    std::lock_guard<std::mutex> lock(sDelegateBySurfaceIdMutex);
+    sDelegateBySurfaceId.erase(_surfaceId);
+  }
   if (_delegateWrapper) {
     if (!_origin.empty()) {
       auto &registry = rnsandbox::SandboxRegistry::getInstance();
@@ -799,9 +825,27 @@ - (Class)getModuleClassFromName:(const char *)name
           }
         } else {
           // targetOrigin is undefined/null - route to host
-          if (self.eventEmitter && self.hasOnMessageHandler) {
-            SandboxReactNativeViewEventEmitter::OnMessage messageEvent = {.data = jsi::dynamicFromValue(rt, args[0])};
-            self.eventEmitter->onMessage(messageEvent);
+          // Check for __sandboxSurfaceId to route to the correct delegate
+          SandboxReactNativeDelegate *targetDelegate = self;
+          jsi::Object msgObj = args[0].getObject(rt);
+          if (msgObj.hasProperty(rt, "__sandboxSurfaceId")) {
+            jsi::Value idVal = msgObj.getProperty(rt, "__sandboxSurfaceId");
+            if (idVal.isString()) {
+              std::string surfaceId = idVal.getString(rt).utf8(rt);
+              std::lock_guard<std::mutex> lock(sDelegateBySurfaceIdMutex);
+              auto it = sDelegateBySurfaceId.find(surfaceId);
+              if (it != sDelegateBySurfaceId.end() && it->second != nil) {
+                targetDelegate = it->second;
+              }
+            }
+          }
+
+          if (targetDelegate.eventEmitter && targetDelegate.hasOnMessageHandler) {
+            // Strip __sandboxSurfaceId from the emitted event data
+            folly::dynamic eventData = jsi::dynamicFromValue(rt, args[0]);
+            eventData.erase("__sandboxSurfaceId");
+            SandboxReactNativeViewEventEmitter::OnMessage messageEvent = {.data = eventData};
+            targetDelegate.eventEmitter->onMessage(messageEvent);
           } else {
             // Event emitter or handler not ready yet (warm start race). Buffer the message.
             jsi::Object jsonObject = rt.global().getPropertyAsObject(rt, "JSON");
@@ -809,8 +853,8 @@ - (Class)getModuleClassFromName:(const char *)name
             jsi::Value jsonResult = jsonStringify.call(rt, args[0]);
             std::string messageJson = jsonResult.getString(rt).utf8(rt);
             NSString *nsMsg = [NSString stringWithUTF8String:messageJson.c_str()];
-            @synchronized(_pendingHostMessages) {
-              [_pendingHostMessages addObject:@{@"data" : nsMsg}];
+            @synchronized(targetDelegate->_pendingHostMessages) {
+              [targetDelegate->_pendingHostMessages addObject:@{@"data" : nsMsg}];
             }
           }
         }
@@ -824,10 +868,10 @@ - (Class)getModuleClassFromName:(const char *)name
   return jsi::Function::createFromHostFunction(
       runtime,
       jsi::PropNameID::forAscii(runtime, "setOnMessage"),
-      2, // Accept 1 or 2 arguments: callback and optional delegateId
+      2, // Accept 1 or 2 arguments: callback and optional surfaceId
       [=](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, size_t count) {
         if (count < 1 || count > 2) {
-          throw jsi::JSError(rt, "Expected 1 or 2 arguments: setOnMessage(callback, delegateId?)");
+          throw jsi::JSError(rt, "Expected 1 or 2 arguments: setOnMessage(callback, surfaceId?)");
         }
 
         const jsi::Value &arg = args[0];
@@ -837,15 +881,15 @@ - (Class)getModuleClassFromName:(const char *)name
 
         jsi::Function fn = arg.asObject(rt).asFunction(rt);
 
-        // Check for optional delegate ID (2nd arg) for per-surface registration
-        std::string delegateId;
+        // Check for optional surface ID (2nd arg) for per-surface registration
+        std::string surfaceId;
         if (count == 2 && args[1].isString()) {
-          delegateId = args[1].getString(rt).utf8(rt);
+          surfaceId = args[1].getString(rt).utf8(rt);
         }
 
-        if (!delegateId.empty()) {
-          // Per-surface: register under the delegate ID
-          _surfaceMessageCallbacks[delegateId] = std::make_shared<jsi::Function>(std::move(fn));
+        if (!surfaceId.empty()) {
+          // Per-surface: register under the surface ID
+          _surfaceMessageCallbacks[surfaceId] = std::make_shared<jsi::Function>(std::move(fn));
         } else {
           // Legacy: single shared callback (last-writer-wins)
           _onMessageSandbox.reset();
diff --git a/packages/react-native-sandbox/ios/SandboxReactNativeViewComponentView.mm b/packages/react-native-sandbox/ios/SandboxReactNativeViewComponentView.mm
index 2145fcf..97f3e73 100644
--- a/packages/react-native-sandbox/ios/SandboxReactNativeViewComponentView.mm
+++ b/packages/react-native-sandbox/ios/SandboxReactNativeViewComponentView.mm
@@ -231,6 +231,12 @@ - (void)loadReactNativeView
     initialProperties = (NSDictionary *)convertFollyDynamicToId(props.initialProperties);
   }
 
+  // Inject __sandboxSurfaceId for per-surface message routing (parity with Android)
+  NSString *surfaceId = [self.reactNativeDelegate generateSurfaceId];
+  NSMutableDictionary *propsWithSurfaceId = [initialProperties mutableCopy];
+  propsWithSurfaceId[@"__sandboxSurfaceId"] = surfaceId;
+  initialProperties = [propsWithSurfaceId copy];
+
   NSDictionary *launchOptions = @{};
   if (!props.launchOptions.isNull()) {
     launchOptions = (NSDictionary *)convertFollyDynamicToId(props.launchOptions);
diff --git a/packages/react-native-sandbox/src/useSurfaceMessaging.ts b/packages/react-native-sandbox/src/useSurfaceMessaging.ts
index db8b583..3edf68f 100644
--- a/packages/react-native-sandbox/src/useSurfaceMessaging.ts
+++ b/packages/react-native-sandbox/src/useSurfaceMessaging.ts
@@ -2,7 +2,7 @@ import {useCallback} from 'react'
 
 declare const globalThis: {
   postMessage: (msg: unknown, targetOrigin?: string) => void
-  setOnMessage: (cb: (msg: unknown) => void, delegateId?: string) => void
+  setOnMessage: (cb: (msg: unknown) => void, surfaceId?: string) => void
 }
 
 /**
@@ -22,8 +22,8 @@ declare const globalThis: {
  *
  * Usage:
  * ```tsx
- * function MyWidget({__sandboxDelegateId}: Props) {
- *   const {postMessage, setOnMessage} = useSurfaceMessaging(__sandboxDelegateId);
+ * function MyWidget({__sandboxSurfaceId}: Props) {
+ *   const {postMessage, setOnMessage} = useSurfaceMessaging(__sandboxSurfaceId);
  *
  *   useEffect(() => {
  *     const unsubscribe = setOnMessage((msg) => console.log('received', msg));
@@ -34,15 +34,15 @@ declare const globalThis: {
  * }
  * ```
  *
- * @param delegateId - The `__sandboxDelegateId` prop injected by the native
+ * @param surfaceId - The `__sandboxSurfaceId` prop injected by the native
  *   side into initialProperties. If undefined, falls back to broadcast/shared.
  */
-export function useSurfaceMessaging(delegateId?: string) {
+export function useSurfaceMessaging(surfaceId?: string) {
   const postMessage = useCallback(
     (msg: unknown, targetOrigin?: string) => {
       if (targetOrigin) {
-        // Cross-origin: forward directly without adding delegate routing hint.
-        // The native side routes by origin, not by delegate ID.
+        // Cross-origin: forward directly without adding surface routing hint.
+        // The native side routes by origin, not by surface ID.
         globalThis.postMessage(
           typeof msg === 'object' && msg !== null ? msg : {data: msg},
           targetOrigin
@@ -52,23 +52,23 @@ export function useSurfaceMessaging(delegateId?: string) {
       // Per-surface: attach routing hint for the host view
       const payload =
         typeof msg === 'object' && msg !== null ? {...msg} : {data: msg}
-      if (delegateId) {
-        ;(payload as Record<string, unknown>).__sandboxDelegateId = delegateId
+      if (surfaceId) {
+        ;(payload as Record<string, unknown>).__sandboxSurfaceId = surfaceId
       }
       globalThis.postMessage(payload)
     },
-    [delegateId]
+    [surfaceId]
   )
 
   const setOnMessage = useCallback(
     (cb: (msg: unknown) => void) => {
-      globalThis.setOnMessage(cb, delegateId)
+      globalThis.setOnMessage(cb, surfaceId)
       // Return a cleanup function that unregisters the per-surface listener
       return () => {
-        globalThis.setOnMessage(() => {}, delegateId)
+        globalThis.setOnMessage(() => {}, surfaceId)
       }
     },
-    [delegateId]
+    [surfaceId]
   )
 
   return {postMessage, setOnMessage}

From fac195d357bc7ae02a36cd895a1df73bd45dec5c Mon Sep 17 00:00:00 2001
From: Ryan Karn <rkarn@amazon.com>
Date: Wed, 3 Jun 2026 11:48:51 -0700
Subject: [PATCH 3/4] fix(ios): unregister delegate from SandboxRegistry on
 immediate factory teardown

The TTL=0 path in releaseSharedFactory removed the factory from the pool
but left the stale delegate wrapper in the C++ registry. When another
sandbox then tried to route a message to the removed origin, it found
the dangling wrapper and crashed accessing a deallocated RCTInstance.

Verified fix in the p2p-chat app.  Prior to this, the app would crash
on ios after removing a chat sandbox and trying to message it from
another chat.
---
 .../ios/SandboxReactNativeViewComponentView.mm                  | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/packages/react-native-sandbox/ios/SandboxReactNativeViewComponentView.mm b/packages/react-native-sandbox/ios/SandboxReactNativeViewComponentView.mm
index 97f3e73..9c488bf 100644
--- a/packages/react-native-sandbox/ios/SandboxReactNativeViewComponentView.mm
+++ b/packages/react-native-sandbox/ios/SandboxReactNativeViewComponentView.mm
@@ -349,6 +349,8 @@ - (void)releaseSharedFactory
       });
     } else {
       [sSharedFactories removeObjectForKey:origin];
+      auto &registry = rnsandbox::SandboxRegistry::getInstance();
+      registry.unregister([origin UTF8String]);
     }
   }
 

From 70b05cb9ee4f7e7601d82abc1f66817b82e13a4e Mon Sep 17 00:00:00 2001
From: Ryan Karn <rkarn@amazon.com>
Date: Wed, 3 Jun 2026 16:41:08 -0700
Subject: [PATCH 4/4] docs: add useSurfaceMessaging and origin-pooling
 documentation

Documents the per-surface messaging API for bundle authors sharing
an origin, with both hook and convention-based examples. Adds the
origin-pooling demo to the examples list and reorders sections for
better flow.
---
 README.md                               |   1 +
 packages/react-native-sandbox/README.md | 100 ++++++++++++++++++------
 2 files changed, 78 insertions(+), 23 deletions(-)

diff --git a/README.md b/README.md
index aadd39a..1d4a4b9 100644
--- a/README.md
+++ b/README.md
@@ -150,6 +150,7 @@ Full examples:
 - [`apps/p2p-chat`](./apps/p2p-counter/README.md): Direct sandbox-to-sandbox chat demo.
 - [`apps/p2p-counter`](./apps/p2p-counter/README.md): Direct sandbox-to-sandbox communication demo.
 - [`apps/fs-experiment`](./apps/fs-experiment/README.md): File system & storage isolation with TurboModule substitutions.
+- [`apps/origin-pooling`](./apps/origin-pooling/): Origin sharing, idle TTL, and per-surface messaging demo.
 
 ## 📚 API Reference
 
diff --git a/packages/react-native-sandbox/README.md b/packages/react-native-sandbox/README.md
index df011bd..cc1888e 100644
--- a/packages/react-native-sandbox/README.md
+++ b/packages/react-native-sandbox/README.md
@@ -224,29 +224,7 @@ const handleMessage = (data: unknown) => {
 };
 ```
 
-### Origin Pooling with Idle TTL
-
-Sandboxes sharing the same `origin` reuse a single ReactHost / Hermes VM. When the last surface for an origin unmounts, the ReactHost is kept alive for `idleTTL` milliseconds so that a re-mount within that window gets a warm start instead of a cold boot.
-
-```tsx
-// Static TTL
-<SandboxReactNativeView
-  origin="dashboard"
-  idleTTL={2000}
-  componentName="DashboardWidget"
-  jsBundleSource="sandbox"
-/>
-
-// Dynamic TTL via function — evaluated at render time, not at unmount time
-<SandboxReactNativeView
-  origin="analytics"
-  idleTTL={() => isLowMemory() ? 1000 : 5000}
-  componentName="AnalyticsWidget"
-  jsBundleSource="sandbox"
-/>
-```
-
-### Direct communication Between Sandboxes
+### Direct Communication Between Sandboxes
 
 Enable direct communication between two sandbox instances:
 
@@ -311,6 +289,82 @@ export default function SandboxA() {
 
 The `SandboxB` component looks similar.
 
+### Origin Pooling with Idle TTL
+
+Sandboxes sharing the same `origin` reuse a single ReactHost / Hermes VM. When the last surface for an origin unmounts, the ReactHost is kept alive for `idleTTL` milliseconds so that a re-mount within that window gets a warm start instead of a cold boot.
+
+```tsx
+// Static TTL
+<SandboxReactNativeView
+  origin="dashboard"
+  idleTTL={2000}
+  componentName="DashboardWidget"
+  jsBundleSource="sandbox"
+/>
+
+// Dynamic TTL via function — evaluated at render time, not at unmount time
+<SandboxReactNativeView
+  origin="analytics"
+  idleTTL={() => isLowMemory() ? 1000 : 5000}
+  componentName="AnalyticsWidget"
+  jsBundleSource="sandbox"
+/>
+```
+
+### Per-Surface Messaging (`useSurfaceMessaging`)
+
+When multiple sandboxes share the same `origin`, they share a single Hermes VM. Without per-surface routing, `globalThis.postMessage` and `globalThis.setOnMessage` would be last-writer-wins — only the most recently mounted sandbox's listener would be active.
+
+Each sandbox automatically receives a `__sandboxSurfaceId` prop that uniquely identifies its surface. Pass this to `useSurfaceMessaging` (or directly to the global APIs) to get correctly scoped messaging.
+
+See the [`apps/origin-pooling`](https://github.com/callstackincubator/react-native-sandbox/tree/main/apps/origin-pooling) demo for both approaches in action.
+
+**Option A: `useSurfaceMessaging` hook (recommended)**
+
+```tsx
+import {useSurfaceMessaging} from '@callstack/react-native-sandbox'
+
+function MyWidget({__sandboxSurfaceId}: {__sandboxSurfaceId?: string}) {
+  const {postMessage, setOnMessage} = useSurfaceMessaging(__sandboxSurfaceId)
+
+  useEffect(() => {
+    const unsubscribe = setOnMessage((msg) => {
+      console.log('received', msg)
+    })
+    return unsubscribe
+  }, [setOnMessage])
+
+  const sendToHost = () => postMessage({type: 'hello'})
+  const sendToOther = () => postMessage({type: 'ping'}, 'other-origin')
+
+  return <Button title="Send" onPress={sendToHost} />
+}
+```
+
+**Option B: Convention-based (no library import)**
+
+```tsx
+declare const globalThis: {
+  postMessage: (msg: unknown, targetOrigin?: string) => void
+  setOnMessage: (cb: (msg: unknown) => void, surfaceId?: string) => void
+}
+
+function MyWidget({__sandboxSurfaceId}: {__sandboxSurfaceId?: string}) {
+  useEffect(() => {
+    globalThis.setOnMessage((msg) => {
+      console.log('received', msg)
+    }, __sandboxSurfaceId)
+    return () => globalThis.setOnMessage(() => {}, __sandboxSurfaceId)
+  }, [__sandboxSurfaceId])
+
+  const sendToHost = () => {
+    globalThis.postMessage({type: 'hello', __sandboxSurfaceId})
+  }
+}
+```
+
+If `__sandboxSurfaceId` is `undefined` (e.g. the sandbox has its own origin), both approaches fall back to standard broadcast behavior — no changes needed in your code.
+
 ## ⚡ Performance & Best Practices
 
 ### Memory Management