@onekeyfe/react-native-splash-screen 1.1.21

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 OneKey
+
+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.

package/README.md

@@ -0,0 +1,36 @@
+# react-native-splash-screen
+
+react-native-splash-screen
+
+## Installation
+
+```sh
+npm install react-native-splash-screen react-native-nitro-modules
+
+> `react-native-nitro-modules` is required as this library relies on [Nitro Modules](https://nitro.margelo.com/).
+```
+
+## Usage
+
+```js
+import { ReactNativeSplashScreen } from 'react-native-splash-screen';
+
+// ...
+
+const result = await ReactNativeSplashScreen.hello({ message: 'World' });
+console.log(result); // { success: true, data: 'Hello, World!' }
+```
+
+## Contributing
+
+- [Development workflow](CONTRIBUTING.md#development-workflow)
+- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
+- [Code of conduct](CODE_OF_CONDUCT.md)
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/ReactNativeSplashScreen.podspec

@@ -0,0 +1,30 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "ReactNativeSplashScreen"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/OneKeyHQ/app-modules/react-native-splash-screen.git", :tag => "#{s.version}" }
+
+  s.source_files = [
+    "ios/**/*.{swift}",
+    "ios/**/*.{m,mm}",
+    "cpp/**/*.{hpp,cpp}",
+  ]
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+  s.dependency 'ReactNativeNativeLogger'
+
+  load 'nitrogen/generated/ios/ReactNativeSplashScreen+autolinking.rb'
+  add_nitrogen_files(s)
+
+  install_modules_dependencies(s)
+end

package/android/CMakeLists.txt

@@ -0,0 +1,24 @@
+project(reactnativesplashscreen)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(PACKAGE_NAME reactnativesplashscreen)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+
+# Define C++ library and add all sources
+add_library(${PACKAGE_NAME} SHARED src/main/cpp/cpp-adapter.cpp)
+
+# Add Nitrogen specs :)
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/reactnativesplashscreen+autolinking.cmake)
+
+# Set up local includes
+include_directories("src/main/cpp" "../cpp")
+
+find_library(LOG_LIB log)
+
+# Link all libraries together
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android # <-- Android core
+)

package/android/build.gradle

@@ -0,0 +1,130 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['ReactNativeSplashScreen_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply from: '../nitrogen/generated/android/reactnativesplashscreen+autolinking.gradle'
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["ReactNativeSplashScreen_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.nitro.reactnativesplashscreen"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libfolly_json.so",
+            "**/libfolly_runtime.so",
+            "**/libglog.so",
+            "**/libhermes.so",
+            "**/libhermes-executor-debug.so",
+            "**/libhermes_executor.so",
+            "**/libreactnative.so",
+            "**/libreactnativejni.so",
+            "**/libturbomodulejsijni.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libjscexecutor.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation project(":react-native-nitro-modules")
+
+  implementation project(":onekeyfe_react-native-native-logger")
+}

package/android/gradle.properties

@@ -0,0 +1,4 @@
+ReactNativeSplashScreen_kotlinVersion=1.9.25
+ReactNativeSplashScreen_compileSdkVersion=35
+ReactNativeSplashScreen_targetSdkVersion=35
+ReactNativeSplashScreen_minSdkVersion=24

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,6 @@
+#include <jni.h>
+#include "reactnativesplashscreenOnLoad.hpp"
+
+extern "C" JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::reactnativesplashscreen::initialize(vm);
+}

package/android/src/main/java/com/margelo/nitro/reactnativesplashscreen/ReactNativeSplashScreen.kt

@@ -0,0 +1,77 @@
+package com.margelo.nitro.reactnativesplashscreen
+
+import android.os.Build
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.nativelogger.OneKeyLog
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+
+/**
+ * Splash screen module for Android compatibility.
+ *
+ * - API >= 31 (Android 12+): The system AndroidX SplashScreen API handles the splash screen
+ *   natively in MainActivity. Both methods are no-ops and return true immediately.
+ *
+ * - API < 31 (Android < 12): The system has no built-in splash screen API.
+ *   MainActivity calls [SplashScreenBridge.show] during onCreate to display a view overlay
+ *   matching the app's splash drawable. This module then delegates:
+ *     - [preventAutoHideAsync] → [SplashScreenBridge.preventAutoHide] to keep the overlay visible
+ *       until JS explicitly hides it.
+ *     - [hideAsync] → [SplashScreenBridge.hide] to remove the overlay.
+ *
+ * iOS: expo-splash-screen via the launch storyboard handles everything. The iOS implementation
+ * in ReactNativeSplashScreen.swift is intentionally empty.
+ */
+@DoNotStrip
+class ReactNativeSplashScreen : HybridReactNativeSplashScreenSpec() {
+
+    override fun preventAutoHideAsync(): Promise<Boolean> {
+        return Promise.async {
+            OneKeyLog.info("SplashScreen", "preventAutoHideAsync OS_VERSION=${Build.VERSION.SDK_INT}")
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                // API 31+: AndroidX SplashScreen handles it in MainActivity
+                return@async true
+            }
+            val activity = NitroModules.applicationContext?.currentActivity
+            if (activity == null) {
+                OneKeyLog.warn("SplashScreen", "preventAutoHideAsync: no current activity")
+                return@async false
+            }
+            SplashScreenBridge.preventAutoHide(activity)
+            true
+        }
+    }
+
+    override fun hideAsync(): Promise<Boolean> {
+        return Promise.async {
+            OneKeyLog.info("SplashScreen", "hideAsync OS_VERSION=${Build.VERSION.SDK_INT}")
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                // API 31+: AndroidX SplashScreen handles it
+                return@async true
+            }
+            val activity = NitroModules.applicationContext?.currentActivity
+            if (activity == null) {
+                OneKeyLog.warn("SplashScreen", "hideAsync: no current activity")
+                return@async false
+            }
+            val latch = CountDownLatch(1)
+            var result = false
+            SplashScreenBridge.hide(
+                activity,
+                onSuccess = { hasEffect ->
+                    result = hasEffect
+                    latch.countDown()
+                },
+                onFailure = { reason ->
+                    OneKeyLog.warn("SplashScreen", "hideAsync failed: $reason")
+                    result = false
+                    latch.countDown()
+                }
+            )
+            latch.await(5, TimeUnit.SECONDS)
+            result
+        }
+    }
+}

package/android/src/main/java/com/margelo/nitro/reactnativesplashscreen/ReactNativeSplashScreenPackage.kt

@@ -0,0 +1,24 @@
+package com.margelo.nitro.reactnativesplashscreen
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class ReactNativeSplashScreenPackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return null
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider { HashMap() }
+    }
+
+    companion object {
+        init {
+            System.loadLibrary("reactnativesplashscreen")
+        }
+    }
+}
+
+

package/android/src/main/java/com/margelo/nitro/reactnativesplashscreen/SplashImageResizeMode.kt

@@ -0,0 +1,23 @@
+package com.margelo.nitro.reactnativesplashscreen
+
+import android.widget.ImageView
+
+internal enum class SplashImageResizeMode(
+    val scaleType: ImageView.ScaleType,
+    val value: String
+) {
+    CONTAIN(ImageView.ScaleType.FIT_CENTER, "contain"),
+    COVER(ImageView.ScaleType.CENTER_CROP, "cover"),
+    NATIVE(ImageView.ScaleType.CENTER, "native");
+
+    companion object {
+        fun fromString(value: String?): SplashImageResizeMode {
+            if (value != null) {
+                for (mode in values()) {
+                    if (mode.value == value) return mode
+                }
+            }
+            return CONTAIN
+        }
+    }
+}

package/android/src/main/java/com/margelo/nitro/reactnativesplashscreen/SplashScreenBridge.kt

@@ -0,0 +1,108 @@
+package com.margelo.nitro.reactnativesplashscreen
+
+import android.app.Activity
+import androidx.core.content.ContextCompat
+import com.margelo.nitro.nativelogger.OneKeyLog
+import java.util.WeakHashMap
+
+/**
+ * Static bridge called by the host app's MainActivity to show/manage the splash screen.
+ *
+ * Usage in MainActivity.onCreate() (for API < 31 only):
+ *   SplashScreenBridge.show(this)
+ */
+object SplashScreenBridge {
+    private const val TAG = "SplashScreen"
+
+    private val controllers = WeakHashMap<Activity, SplashViewController>()
+
+    @Volatile
+    var isAlreadyHidden = false
+
+    /**
+     * Show the splash screen overlay. Call this from MainActivity.onCreate()
+     * for API < Build.VERSION_CODES.S (API 31).
+     */
+    @JvmStatic
+    fun show(activity: Activity) {
+        if (isAlreadyHidden) return
+        if (controllers.containsKey(activity)) {
+            OneKeyLog.warn(TAG, "show: already shown for this activity")
+            return
+        }
+        val splashView = createSplashView(activity) ?: run {
+            OneKeyLog.warn(TAG, "show: failed to create splash view")
+            return
+        }
+        val controller = SplashViewController(activity, splashView)
+        controllers[activity] = controller
+        controller.show()
+        OneKeyLog.info(TAG, "show: started for activity")
+    }
+
+    @JvmStatic
+    fun preventAutoHide(activity: Activity) {
+        val controller = controllers[activity]
+        if (controller == null) {
+            OneKeyLog.warn(TAG, "preventAutoHide: no controller for activity")
+            return
+        }
+        controller.preventAutoHide()
+    }
+
+    @JvmStatic
+    fun hide(
+        activity: Activity,
+        onSuccess: ((Boolean) -> Unit)?,
+        onFailure: ((String) -> Unit)?
+    ) {
+        isAlreadyHidden = true
+        val controller = controllers[activity]
+        if (controller == null) {
+            OneKeyLog.warn(TAG, "hide: no controller for activity")
+            onFailure?.invoke("No splash screen registered for this activity")
+            return
+        }
+        controller.hide(onSuccess, onFailure)
+    }
+
+    private fun createSplashView(activity: Activity): android.view.View? {
+        return try {
+            val context = activity
+
+            // Read resize mode from app string resource (convention: "expo_splash_screen_resize_mode")
+            val resizeModeStr = try {
+                val id = context.resources.getIdentifier(
+                    "expo_splash_screen_resize_mode", "string", context.packageName
+                )
+                if (id != 0) context.getString(id).lowercase() else "contain"
+            } catch (e: Exception) { "contain" }
+
+            val resizeMode = SplashImageResizeMode.fromString(resizeModeStr)
+
+            // For NATIVE mode use "splashscreen", otherwise use "splashscreen_image"
+            val drawableName = if (resizeMode == SplashImageResizeMode.NATIVE) "splashscreen" else "splashscreen_image"
+            val imageResId = context.resources.getIdentifier(drawableName, "drawable", context.packageName)
+            val bgColorId = context.resources.getIdentifier(
+                "splashscreen_background", "color", context.packageName
+            )
+
+            OneKeyLog.info(TAG, "createSplashView: resizeMode=$resizeModeStr drawable=$drawableName imageResId=$imageResId")
+
+            val view = SplashScreenView(context)
+            if (bgColorId != 0) {
+                view.setBackgroundColor(ContextCompat.getColor(context, bgColorId))
+            } else {
+                view.setBackgroundColor(android.graphics.Color.WHITE)
+            }
+            if (imageResId != 0) {
+                view.imageView.setImageResource(imageResId)
+            }
+            view.configureResizeMode(resizeMode)
+            view
+        } catch (e: Exception) {
+            OneKeyLog.error(TAG, "createSplashView failed: ${e.message}")
+            null
+        }
+    }
+}

package/android/src/main/java/com/margelo/nitro/reactnativesplashscreen/SplashScreenView.kt

@@ -0,0 +1,34 @@
+package com.margelo.nitro.reactnativesplashscreen
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.view.ViewGroup
+import android.widget.ImageView
+import android.widget.RelativeLayout
+
+@SuppressLint("ViewConstructor")
+internal class SplashScreenView(context: Context) : RelativeLayout(context) {
+
+    val imageView: ImageView = ImageView(context).also { iv ->
+        iv.layoutParams = LayoutParams(
+            LayoutParams.MATCH_PARENT,
+            LayoutParams.MATCH_PARENT
+        )
+        addView(iv)
+    }
+
+    init {
+        layoutParams = ViewGroup.LayoutParams(
+            ViewGroup.LayoutParams.MATCH_PARENT,
+            ViewGroup.LayoutParams.MATCH_PARENT
+        )
+    }
+
+    fun configureResizeMode(resizeMode: SplashImageResizeMode) {
+        imageView.scaleType = resizeMode.scaleType
+        when (resizeMode) {
+            SplashImageResizeMode.CONTAIN -> imageView.adjustViewBounds = true
+            else -> imageView.adjustViewBounds = false
+        }
+    }
+}

package/android/src/main/java/com/margelo/nitro/reactnativesplashscreen/SplashViewController.kt

@@ -0,0 +1,117 @@
+package com.margelo.nitro.reactnativesplashscreen
+
+import android.app.Activity
+import android.os.Handler
+import android.os.Looper
+import android.view.View
+import android.view.ViewGroup
+import com.margelo.nitro.nativelogger.OneKeyLog
+import java.lang.ref.WeakReference
+
+internal class SplashViewController(
+    activity: Activity,
+    private val splashView: View
+) {
+    private companion object {
+        private const val TAG = "SplashScreen"
+        private const val SEARCH_INTERVAL_MS = 20L
+
+        // Look up ReactRootView class at runtime to avoid compile-time dependency
+        private val reactRootViewClass: Class<*>? by lazy {
+            try {
+                Class.forName("com.facebook.react.ReactRootView")
+            } catch (e: ClassNotFoundException) {
+                null
+            }
+        }
+    }
+
+    private val weakActivity = WeakReference(activity)
+    private val contentView: ViewGroup = activity.findViewById(android.R.id.content)
+    private val handler = Handler(Looper.getMainLooper())
+
+    private var autoHideEnabled = true
+    private var splashShown = false
+
+    fun show() {
+        val activity = weakActivity.get() ?: return
+        activity.runOnUiThread {
+            val parent = splashView.parent as? ViewGroup
+            parent?.removeView(splashView)
+            contentView.addView(splashView)
+            splashShown = true
+            OneKeyLog.info(TAG, "splash view added to content")
+            searchForRootView()
+        }
+    }
+
+    fun preventAutoHide() {
+        autoHideEnabled = false
+        OneKeyLog.info(TAG, "autoHide disabled")
+    }
+
+    fun hide(
+        onSuccess: ((Boolean) -> Unit)?,
+        onFailure: ((String) -> Unit)?
+    ) {
+        if (!splashShown) {
+            OneKeyLog.info(TAG, "hide: splash not shown, skipping")
+            onSuccess?.invoke(false)
+            return
+        }
+        val activity = weakActivity.get()
+        if (activity == null || activity.isFinishing || activity.isDestroyed) {
+            onFailure?.invoke("Activity is already destroyed")
+            return
+        }
+        Handler(activity.mainLooper).post {
+            contentView.removeView(splashView)
+            autoHideEnabled = true
+            splashShown = false
+            OneKeyLog.info(TAG, "splash view removed")
+            onSuccess?.invoke(true)
+        }
+    }
+
+    private fun searchForRootView() {
+        val found = findRootView(contentView)
+        if (found != null) {
+            handleRootView(found)
+            return
+        }
+        handler.postDelayed(::searchForRootView, SEARCH_INTERVAL_MS)
+    }
+
+    private fun findRootView(view: View): ViewGroup? {
+        val cls = reactRootViewClass
+        if (cls != null && cls.isInstance(view)) {
+            return view as? ViewGroup
+        }
+        if (view !== splashView && view is ViewGroup) {
+            for (i in 0 until view.childCount) {
+                val found = findRootView(view.getChildAt(i))
+                if (found != null) return found
+            }
+        }
+        return null
+    }
+
+    private fun handleRootView(rootView: ViewGroup) {
+        if (rootView.childCount > 0 && autoHideEnabled) {
+            hide(null, null)
+        }
+        rootView.setOnHierarchyChangeListener(object : ViewGroup.OnHierarchyChangeListener {
+            override fun onChildViewAdded(parent: View, child: View) {
+                if (rootView.childCount == 1 && autoHideEnabled) {
+                    hide(null, null)
+                }
+            }
+
+            override fun onChildViewRemoved(parent: View, child: View) {
+                if (rootView.childCount == 0) {
+                    show()
+                }
+            }
+        })
+    }
+}

package/ios/ReactNativeSplashScreen.swift

@@ -0,0 +1,15 @@
+import NitroModules
+
+// iOS splash screen is managed by expo-splash-screen via the launch storyboard.
+// This module exists solely to provide Android < API 31 compatibility (see SplashScreenBridge.kt).
+// On iOS, both methods are intentional no-ops.
+class ReactNativeSplashScreen: HybridReactNativeSplashScreenSpec {
+
+    func preventAutoHideAsync() throws -> Promise<Bool> {
+        return Promise.resolved(withResult: true)
+    }
+
+    func hideAsync() throws -> Promise<Bool> {
+        return Promise.resolved(withResult: true)
+    }
+}

package/lib/module/ReactNativeSplashScreen.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=ReactNativeSplashScreen.nitro.js.map

package/lib/module/ReactNativeSplashScreen.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["ReactNativeSplashScreen.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,6 @@
+"use strict";
+
+import { NitroModules } from 'react-native-nitro-modules';
+const ReactNativeSplashScreenHybridObject = NitroModules.createHybridObject('ReactNativeSplashScreen');
+export const ReactNativeSplashScreen = ReactNativeSplashScreenHybridObject;
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroModules","ReactNativeSplashScreenHybridObject","createHybridObject","ReactNativeSplashScreen"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAGzD,MAAMC,mCAAmC,GACvCD,YAAY,CAACE,kBAAkB,CAA8B,yBAAyB,CAAC;AAEzF,OAAO,MAAMC,uBAAuB,GAAGF,mCAAmC","ignoreList":[]}