@particle-network/connectkit 2.1.2 → 3.0.0-alpha.0

package/dist/chunk-OWHSDWQK.js

@@ -0,0 +1,1464 @@
+"use client";
+import {
+  getLocale,
+  loadLocale
+} from "./chunk-ABM25MSG.js";
+
+// src/hooks/useAppearance.ts
+import { useCallback as useCallback4, useSyncExternalStore as useSyncExternalStore2 } from "react";
+
+// src/context/index.tsx
+import React3, { createContext as createContext3, useMemo as useMemo6 } from "react";
+
+// src/components/connectModal/index.tsx
+import { lazy as lazy2, useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo3 } from "react";
+
+// src/actions/getAccount.ts
+import { checksumAddress, isAddress } from "viem";
+
+// src/utils/deepEqual.ts
+function deepEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a && b && typeof a === "object" && typeof b === "object") {
+    if (a.constructor !== b.constructor)
+      return false;
+    let length;
+    let i;
+    if (Array.isArray(a) && Array.isArray(b)) {
+      length = a.length;
+      if (length !== b.length)
+        return false;
+      for (i = length; i-- !== 0; )
+        if (!deepEqual(a[i], b[i]))
+          return false;
+      return true;
+    }
+    if (a.valueOf !== Object.prototype.valueOf)
+      return a.valueOf() === b.valueOf();
+    if (a.toString !== Object.prototype.toString)
+      return a.toString() === b.toString();
+    const keys = Object.keys(a);
+    length = keys.length;
+    if (length !== Object.keys(b).length)
+      return false;
+    for (i = length; i-- !== 0; )
+      if (!Object.prototype.hasOwnProperty.call(b, keys[i]))
+        return false;
+    for (i = length; i-- !== 0; ) {
+      const key = keys[i];
+      if (key && !deepEqual(a[key], b[key]))
+        return false;
+    }
+    return true;
+  }
+  return a !== a && b !== b;
+}
+
+// src/actions/getAccount.ts
+var previousAccount;
+var previousState;
+function getAccount(config) {
+  const state = config.state;
+  if (deepEqual(previousState, state))
+    return previousAccount;
+  const uid = config.state.current;
+  const connection = config.state.connections.get(uid);
+  let addresses = connection?.accounts;
+  if (addresses?.length && addresses.every((account) => isAddress(account, { strict: false }))) {
+    addresses = addresses.map((item) => checksumAddress(item));
+  }
+  const address = addresses?.[0];
+  const chain = config.chains.find((chain2) => chain2.id === connection?.chainId);
+  const status = config.state.status;
+  let result;
+  switch (status) {
+    case "connected":
+      result = {
+        address,
+        addresses,
+        chain,
+        chainId: connection?.chainId,
+        connector: connection?.connector,
+        isConnected: true,
+        isConnecting: false,
+        isDisconnected: false,
+        isReconnecting: false,
+        status
+      };
+      break;
+    case "reconnecting":
+      result = {
+        address,
+        addresses,
+        chain,
+        chainId: connection?.chainId,
+        connector: connection?.connector,
+        isConnected: !!address,
+        isConnecting: false,
+        isDisconnected: false,
+        isReconnecting: true,
+        status
+      };
+      break;
+    case "connecting":
+      result = {
+        address,
+        addresses,
+        chain,
+        chainId: connection?.chainId,
+        connector: connection?.connector,
+        isConnected: false,
+        isConnecting: true,
+        isDisconnected: false,
+        isReconnecting: false,
+        status
+      };
+      break;
+    case "disconnected":
+      result = {
+        address: void 0,
+        addresses: void 0,
+        chain: void 0,
+        chainId: void 0,
+        connector: void 0,
+        isConnected: false,
+        isConnecting: false,
+        isDisconnected: true,
+        isReconnecting: false,
+        status
+      };
+      break;
+  }
+  previousState = state;
+  previousAccount = result;
+  return result;
+}
+
+// src/actions/watchAccount.ts
+function watchAccount(config, parameters) {
+  const { onChange } = parameters;
+  return config.subscribe(() => getAccount(config), onChange, {
+    equalityFn(a, b) {
+      const { connector: aConnector, ...aRest } = a;
+      const { connector: bConnector, ...bRest } = b;
+      return deepEqual(aRest, bRest) && aConnector?.id === bConnector?.id && aConnector?.uid === bConnector?.uid;
+    }
+  });
+}
+
+// src/hooks/useSyncExternalStoreWithTracked.ts
+import { useRef } from "react";
+import { useSyncExternalStoreWithSelector } from "use-sync-external-store/shim/with-selector.js";
+var isPlainObject = (obj) => typeof obj === "object" && !Array.isArray(obj);
+function useSyncExternalStoreWithTracked(subscribe, getSnapshot, getServerSnapshot = getSnapshot, isEqual = deepEqual) {
+  const trackedKeys = useRef([]);
+  const result = useSyncExternalStoreWithSelector(
+    subscribe,
+    getSnapshot,
+    getServerSnapshot,
+    (x) => x,
+    (a, b) => {
+      if (isPlainObject(a) && isPlainObject(b) && trackedKeys.current.length) {
+        for (const key of trackedKeys.current) {
+          const equal = isEqual(a[key], b[key]);
+          if (!equal)
+            return false;
+        }
+        return true;
+      }
+      return isEqual(a, b);
+    }
+  );
+  if (isPlainObject(result)) {
+    const trackedResult = { ...result };
+    let properties = {};
+    for (const [key, value] of Object.entries(trackedResult)) {
+      properties = {
+        ...properties,
+        [key]: {
+          configurable: false,
+          enumerable: true,
+          get: () => {
+            if (!trackedKeys.current.includes(key)) {
+              trackedKeys.current.push(key);
+            }
+            return value;
+          }
+        }
+      };
+    }
+    Object.defineProperties(trackedResult, properties);
+    return trackedResult;
+  }
+  return result;
+}
+
+// src/hooks/useAccount.ts
+function useAccount() {
+  const { config } = useContext();
+  return useSyncExternalStoreWithTracked(
+    (onChange) => watchAccount(config, { onChange }),
+    () => getAccount(config)
+  );
+}
+
+// src/hooks/useLocales.ts
+import { useEffect, useMemo, useState } from "react";
+function useLocales() {
+  const { appearance } = useAppearance();
+  const language = useMemo(() => {
+    return appearance?.language ?? "en-US";
+  }, [appearance.language]);
+  const overrideLocales = useMemo(() => {
+    return appearance.overrideLocales;
+  }, [appearance.overrideLocales]);
+  const [loadedLocale, setLoadedLocale] = useState(() => getLocale(language));
+  useEffect(() => {
+    let cancelled = false;
+    loadLocale(language).then((locale) => {
+      if (!cancelled)
+        setLoadedLocale(locale);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [language]);
+  const translations = useMemo(() => {
+    const overrideLanguage = overrideLocales?.[language];
+    return { ...loadedLocale, ...overrideLanguage };
+  }, [loadedLocale, language, overrideLocales]);
+  if (!translations) {
+    throw new Error(`Missing translations for ${language}`);
+  }
+  return translations;
+}
+
+// src/hooks/useModalError.ts
+import { create } from "zustand";
+var useModalError = create((set) => ({
+  showError: (value) => {
+    set({ error: value });
+  },
+  hideError: () => {
+    set({ error: void 0 });
+  }
+}));
+
+// src/hooks/useModalState.ts
+import { create as create2 } from "zustand";
+var useModalState = create2((set) => ({
+  open: false,
+  setOpen: (value) => set({ open: value })
+}));
+
+// src/hooks/useRouteState.ts
+import { create as create3 } from "zustand";
+
+// src/pages/index.ts
+import { lazy } from "react";
+var Captcha = lazy(() => import("./captcha-EHLVZTNO.js"));
+var Connecting = lazy(() => import("./connecting-QWVHEIVC.js"));
+var Connectors = lazy(() => import("./connectors-76AHMIB5.js"));
+var DownloadApp = lazy(() => import("./downloadApp-QC2QWDWU.js"));
+var LoginPasskey = lazy(() => import("./loginPasskey-IBZBVCR5.js"));
+var PasskeySetup = lazy(() => import("./passkeySetup-EUUYSRYK.js"));
+var Receive = lazy(() => import("./receive-QKIRVPMW.js"));
+var SelectChain = lazy(() => import("./selectChain-JMDASW66.js"));
+var Signup = lazy(() => import("./signup-Y4X3SH5G.js"));
+var WalletInfo = lazy(() => import("./walletInfo-FNFUVEYU.js"));
+var WalletInfoTitle = lazy(() => import("./title-VWZ7DIO6.js"));
+var Walletconnect = lazy(() => import("./walletconnect-4EXYRW5P.js"));
+var safeRoutes = {
+  connected: ["wallet-info" /* WalletInfo */, "receive" /* Receive */],
+  disconnected: [
+    "signup" /* Signup */,
+    "connectors" /* Connectors */,
+    "captcha" /* Captcha */,
+    "connecting" /* Connecting */,
+    "download-app" /* DownloadApp */,
+    "select-chain" /* SelectChain */,
+    "walletconnect" /* Walletconnect */,
+    "passkey-setup" /* PasskeySetup */,
+    "login-passkey" /* LoginPasskey */
+  ]
+};
+var allRoutes = [...safeRoutes.connected, ...safeRoutes.disconnected];
+var pages = [
+  {
+    title: "signupTitle",
+    path: "signup" /* Signup */,
+    element: Signup
+  },
+  {
+    title: "connectorsTitle",
+    path: "connectors" /* Connectors */,
+    element: Connectors
+  },
+  {
+    title: "captchaTitle",
+    path: "captcha" /* Captcha */,
+    element: Captcha
+  },
+  {
+    path: "connecting" /* Connecting */,
+    element: Connecting
+  },
+  {
+    path: "download-app" /* DownloadApp */,
+    element: DownloadApp
+  },
+  {
+    title: "scanWithPhone",
+    path: "walletconnect" /* Walletconnect */,
+    element: Walletconnect
+  },
+  {
+    title: "selectChainTitle",
+    path: "select-chain" /* SelectChain */,
+    element: SelectChain
+  },
+  {
+    title: WalletInfoTitle,
+    path: "wallet-info" /* WalletInfo */,
+    element: WalletInfo
+  },
+  {
+    title: "receive",
+    path: "receive" /* Receive */,
+    element: Receive
+  },
+  {
+    title: "setupPasskey",
+    path: "passkey-setup" /* PasskeySetup */,
+    element: PasskeySetup
+  },
+  {
+    title: "usePasskeyToLogin",
+    path: "login-passkey" /* LoginPasskey */,
+    element: LoginPasskey
+  }
+];
+var getPage = (path) => {
+  const page = pages.find((item) => item.path === path);
+  if (!page) {
+    throw new Error("route path undefined");
+  }
+  return page;
+};
+
+// src/hooks/useRouteState.ts
+var initialState = { path: "signup" /* Signup */ };
+var useRouteState = create3((set) => ({
+  route: initialState,
+  setRoute: (value) => {
+    if (typeof value === "string") {
+      set({
+        route: {
+          path: value
+        }
+      });
+    } else {
+      set({ route: value });
+    }
+  }
+}));
+
+// src/hooks/useRouter.ts
+import { useCallback, useMemo as useMemo2 } from "react";
+var useRouter = () => {
+  const open = useModalState((s) => s.open);
+  const setOpen = useModalState((s) => s.setOpen);
+  const setRoute = useRouteState((state) => state.setRoute);
+  const { isConnected } = useAccount();
+  const navigate = useCallback(
+    (route, state) => {
+      let validRoute = route;
+      if (!allRoutes.includes(route)) {
+        validRoute = isConnected ? "wallet-info" /* WalletInfo */ : "signup" /* Signup */;
+      }
+      if (isConnected) {
+        if (!safeRoutes.connected.includes(route)) {
+          validRoute = "wallet-info" /* WalletInfo */;
+        }
+      } else {
+        if (!safeRoutes.disconnected.includes(route)) {
+          validRoute = "signup" /* Signup */;
+        }
+      }
+      setOpen(true);
+      setRoute({ path: validRoute, state });
+    },
+    [isConnected, setOpen, setRoute]
+  );
+  const close = useCallback(() => {
+    setOpen(false);
+  }, [setOpen]);
+  return useMemo2(() => ({ navigate, close, isOpen: open }), [navigate, close, open]);
+};
+
+// src/components/connectModal/index.tsx
+import { jsx } from "react/jsx-runtime";
+var Modal = lazy2(() => import("./modal-GEND4BCZ.js"));
+var ConnectModal = () => {
+  const { setOpen, open } = useModalState();
+  const { route } = useRouteState();
+  const { navigate } = useRouter();
+  const locales = useLocales();
+  const { hideError } = useModalError();
+  const { isConnected } = useAccount();
+  useEffect2(() => {
+    setOpen(false);
+  }, [isConnected, setOpen]);
+  useEffect2(() => {
+    hideError();
+  }, [route, hideError]);
+  const {
+    element: PageElement,
+    title,
+    state
+  } = useMemo3(() => {
+    const page = getPage(route.path);
+    return { ...page, state: route.state };
+  }, [route]);
+  const onClose = useCallback2(() => {
+    setOpen(false);
+  }, [setOpen]);
+  const onBack = useCallback2(() => {
+    navigate("signup" /* Signup */);
+  }, [navigate]);
+  const isCanBack = useMemo3(() => route.path !== "signup" /* Signup */ && route.path !== "wallet-info" /* WalletInfo */, [route.path]);
+  return /* @__PURE__ */ jsx(
+    Modal,
+    {
+      open,
+      onClose,
+      title: typeof title === "string" ? locales[title] : title,
+      onBack: isCanBack ? onBack : void 0,
+      children: /* @__PURE__ */ jsx(PageElement, { ...state })
+    }
+  );
+};
+var connectModal_default = ConnectModal;
+
+// src/styles/index.ts
+import { css, styled } from "styled-components";
+
+// src/utils/detect.ts
+import { detect } from "detect-browser";
+var _detected = null;
+var getDetected = () => _detected ??= detect();
+var detectOS = () => getDetected()?.os ?? "";
+var isIOS = () => {
+  const os = detectOS();
+  return os.toLowerCase().includes("ios");
+};
+var isAndroid = () => {
+  const os = detectOS();
+  return os.toLowerCase().includes("android");
+};
+var isMobile = () => {
+  return isAndroid() || isIOS();
+};
+
+// src/utils/index.ts
+function hexToRgba(hex, alpha) {
+  if (!hex)
+    return "";
+  hex = hex.replace(/^#/, "");
+  if (hex.length === 3) {
+    hex = hex.split("").map((c) => c + c).join("");
+  }
+  if (hex.length !== 6)
+    return "";
+  const r = parseInt(hex.slice(0, 2), 16);
+  const g = parseInt(hex.slice(2, 4), 16);
+  const b = parseInt(hex.slice(4, 6), 16);
+  return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+}
+var shortAddress = (address) => {
+  if (!address) {
+    return "";
+  }
+  if (address.length <= 10) {
+    return address;
+  }
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+};
+var openMobileUrl = (url) => {
+  if (url.startsWith("http")) {
+    const link = document.createElement("a");
+    link.href = url;
+    link.target = "_blank";
+    link.rel = "noreferrer noopener";
+    link.click();
+  } else {
+    window.location.href = url;
+  }
+};
+var hasPCDownloadUrl = (walletProps) => {
+  return Boolean(
+    walletProps.downloadUrls?.chrome || walletProps.downloadUrls?.brave || walletProps.downloadUrls?.edge || walletProps.downloadUrls?.firefox || walletProps.downloadUrls?.safari
+  );
+};
+function getElementDimensionsRelativeToParent(ref) {
+  if (!ref.current) {
+    return null;
+  }
+  const element = ref.current;
+  const parent = element.parentElement;
+  if (!parent) {
+    return null;
+  }
+  const elementRect = element.getBoundingClientRect();
+  const parentRect = parent.getBoundingClientRect();
+  const topDistance = elementRect.top - parentRect.top;
+  const bottomDistance = parentRect.bottom - elementRect.bottom;
+  const dimensions = {
+    width: elementRect.width,
+    height: elementRect.height,
+    topDistance,
+    bottomDistance
+  };
+  return dimensions;
+}
+function getBuyUrl(chainId, address, currency = "USD", theme = "light", language = "en-US") {
+  const RAMP_WEB_URL = "https://ramp.particle.network";
+  const supportedNetworks = {
+    "1": ["Ethereum", "ETH"],
+    "10": ["Optimism", "ETH"],
+    "56": ["Binance Smart Chain", "BNB"],
+    "101": ["Solana", "SOL"],
+    "137": ["Polygon", "MATIC"],
+    "204": ["opBNB", "BNB"],
+    "324": ["Zksync", "ETH"],
+    "5000": ["Mantle", "MNT"],
+    "8453": ["Base", "ETH"],
+    "42161": ["Arbitrum One", "ETH"],
+    "42220": ["Celo", "CELO"],
+    "43114": ["Avalanche", "AVAX"],
+    "728126428": ["Tron", "TRX"]
+  };
+  if (!chainId || !address || !supportedNetworks[chainId]) {
+    return "";
+  }
+  const chainName = supportedNetworks[chainId]?.[0] || "";
+  const cryptoCoin = supportedNetworks[chainId]?.[1] || "ETH";
+  const buyParams = {
+    walletAddress: address,
+    fiatCoin: currency,
+    cryptoCoin,
+    chainName,
+    showBackButton: false,
+    theme,
+    language
+  };
+  const queryString = new URLSearchParams(buyParams).toString();
+  return `${RAMP_WEB_URL}/?${queryString}`;
+}
+function popupWindow(url, title, w, h) {
+  const left = screen.width / 2 - w / 2;
+  const top = screen.height / 2 - h / 2;
+  return window.open(
+    url,
+    title,
+    "toolbar=no, location=no, directories=no, status=no, menubar=no, scrollbars=no, resizable=no, copyhistory=no, width=" + w + ", height=" + h + ", top=" + top + ", left=" + left
+  );
+}
+var roundToEven = (value) => {
+  return Math.floor(value / 2) * 2;
+};
+var isFirstRegisterPasskey = () => {
+  return localStorage.getItem("passkeyRegistrationStatus") !== "completed";
+};
+var setFirstRegisterPasskey = () => {
+  localStorage.setItem("passkeyRegistrationStatus", "completed");
+};
+
+// src/utils/theme.ts
+function getSystemMode() {
+  if (typeof window !== "undefined" && window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").matches) {
+    return "dark";
+  } else {
+    return "light";
+  }
+}
+
+// src/styles/themes/dark.ts
+var darkTheme = {
+  "--pcm-overlay-background": "rgba(0,0,0,0.4)",
+  "--pcm-modal-box-shadow": "0px 6px 20px 6px rgba(0, 0, 0, 0.1)",
+  "--pcm-body-background": "#1C1D22",
+  "--pcm-body-background-secondary": "#41424A",
+  "--pcm-body-background-tertiary": "#232529",
+  "--pcm-body-color": "#ffffff",
+  "--pcm-body-color-secondary": "#8B8EA1",
+  "--pcm-body-color-tertiary": "#42444B",
+  "--pcm-body-action-color": "#808080",
+  "--pcm-button-border-color": "#292B36",
+  "--pcm-accent-color": "#A257FA",
+  "--pcm-button-font-weight": "500",
+  "--pcm-button-hover-shadow": "0px 2px 4px rgba(255, 255, 255, 0.05)",
+  "--pcm-primary-button-color": "#000000",
+  "--pcm-primary-button-bankground": "#FFFFFF",
+  "--pcm-primary-button-hover-background": "#f5f5f5",
+  "--pcm-secondary-button-color": "#FFFFFF",
+  "--pcm-secondary-button-bankground": "#41424A",
+  "--pcm-secondary-button-hover-background": "#5A5B66"
+};
+var dark_default = darkTheme;
+
+// src/styles/themes/light.ts
+var lightTheme = {
+  "--pcm-overlay-background": "rgba(71, 88, 107, 0.24)",
+  "--pcm-modal-box-shadow": "0px 2px 4px rgba(0, 0, 0, 0.1)",
+  "--pcm-body-background": "#ffffff",
+  "--pcm-body-background-secondary": "#EFF0F2",
+  "--pcm-body-background-tertiary": "#F9F9FA",
+  "--pcm-body-color": "#181B1E",
+  "--pcm-body-color-secondary": "#8B8EA1",
+  "--pcm-body-color-tertiary": "#DCDFE6",
+  "--pcm-body-action-color": "#999999",
+  "--pcm-button-border-color": "#EAECF0",
+  "--pcm-accent-color": "#A257FA",
+  "--pcm-button-font-weight": "500",
+  "--pcm-button-hover-shadow": "0px 2px 4px rgba(0, 0, 0, 0.05)",
+  "--pcm-primary-button-color": "#ffffff",
+  "--pcm-primary-button-bankground": "#181B1E",
+  "--pcm-primary-button-hover-background": "#353738",
+  "--pcm-secondary-button-color": "#181B1E",
+  "--pcm-secondary-button-bankground": "#EFF0F2",
+  "--pcm-secondary-button-hover-background": "#D9DBDD"
+};
+var light_default = lightTheme;
+
+// src/styles/themes/index.ts
+var base = {
+  dark: dark_default,
+  light: light_default
+};
+var themes_default = { base };
+
+// src/styles/index.ts
+var getWalletOption = (appearance) => {
+  let theme = appearance?.mode ?? getSystemMode();
+  if (theme === "auto") {
+    theme = getSystemMode();
+  }
+  let themeConfig = theme === "light" ? light_default : dark_default;
+  themeConfig = mergeThemes({ ...themeGlobals.default, ...themeConfig }, appearance?.theme || {});
+  const walletTheme = {};
+  walletTheme.colorAccent = themeConfig["--pcm-accent-color"];
+  walletTheme.colorPrimary = themeConfig["--pcm-body-background"];
+  walletTheme.colorOnPrimary = themeConfig["--pcm-primary-button-color"];
+  walletTheme.primaryButtonBackgroundColors = [
+    themeConfig["--pcm-primary-button-bankground"],
+    themeConfig["--pcm-primary-button-hover-background"]
+  ];
+  walletTheme.primaryIconButtonBackgroundColors = [
+    themeConfig["--pcm-accent-color"],
+    themeConfig["--pcm-accent-color"]
+  ];
+  walletTheme.primaryIconTextColor = themeConfig["--pcm-secondary-button-color"];
+  walletTheme.primaryButtonTextColor = themeConfig["--pcm-primary-button-color"];
+  walletTheme.cancelButtonBackgroundColor = themeConfig["--pcm-secondary-button-bankground"];
+  walletTheme.backgroundColors = [
+    themeConfig["--pcm-body-background-secondary"],
+    [
+      [themeConfig["--pcm-body-background"], themeConfig["--pcm-body-background"]],
+      [themeConfig["--pcm-body-background"], themeConfig["--pcm-body-background"]]
+    ]
+  ];
+  walletTheme.messageColors = [themeConfig["--pcm-success-color"], themeConfig["--pcm-error-color"]];
+  walletTheme.borderGlowColors = [themeConfig["--pcm-accent-color"], themeConfig["--pcm-body-color"]];
+  walletTheme.modalMaskBackgroundColor = themeConfig["--pcm-overlay-background"];
+  walletTheme.cardBorderRadius = parseInt(themeConfig["--pcm-rounded-xl"]);
+  const options = {
+    themeType: theme,
+    customStyle: {
+      [theme]: walletTheme
+    },
+    language: appearance?.language
+  };
+  return options;
+};
+var mergeThemes = (base2, override) => {
+  const result = { ...base2 };
+  Object.keys(override).forEach((key) => {
+    if (Object.prototype.hasOwnProperty.call(override, key) && override[key] !== "") {
+      result[key] = override[key];
+    }
+  });
+  return result;
+};
+var getAuthCoreTheme = (appearance) => {
+  let theme = appearance?.mode ?? getSystemMode();
+  if (theme === "auto") {
+    theme = getSystemMode();
+  }
+  let themeConfig = theme === "light" ? light_default : dark_default;
+  themeConfig = mergeThemes({ ...themeGlobals.default, ...themeConfig }, appearance?.theme || {});
+  const authTheme = {
+    primaryBtnColor: themeConfig["--pcm-primary-button-color"],
+    primaryBtnBackgroundColor: themeConfig["--pcm-primary-button-bankground"],
+    textColor: themeConfig["--pcm-body-color"],
+    secondaryTextColor: themeConfig["--pcm-body-color-secondary"],
+    themeBackgroundColor: themeConfig["--pcm-body-background"],
+    iconBorderColor: themeConfig["--pcm-button-border-color"],
+    accentColor: themeConfig["--pcm-accent-color"],
+    inputBackgroundColor: themeConfig["--pcm-body-background-secondary"],
+    inputBorderColor: themeConfig["--pcm-button-border-color"],
+    inputPlaceholderColor: themeConfig["--pcm-body-color-tertiary"],
+    cardBorderColor: themeConfig["--pcm-button-border-color"],
+    cardUnclickableBackgroundColor: themeConfig["--pcm-body-background-tertiary"],
+    cardUnclickableBorderColor: themeConfig["--pcm-button-border-color"],
+    cardDividerColor: themeConfig["--pcm-button-border-color"],
+    tagBackgroundColor: themeConfig["--pcm-body-background-secondary"],
+    modalBackgroundColor: themeConfig["--pcm-body-background"],
+    tipsBackgroundColor: themeConfig["--pcm-body-background-secondary"],
+    primaryBtnBorderRadius: themeConfig["--pcm-rounded-lg"],
+    cardBorderRadius: themeConfig["--pcm-rounded-md"],
+    modalBorderRadius: themeConfig["--pcm-rounded-lg"]
+  };
+  return authTheme;
+};
+var themeGlobals = {
+  default: {
+    "--pcm-font-family": `-apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica,
+    'Apple Color Emoji', Arial, sans-serif, 'Segoe UI Emoji',
+    'Segoe UI Symbol'`,
+    "--pcm-overlay-backdrop-filter": "blur(6px)",
+    "--pcm-rounded-sm": "4px",
+    "--pcm-rounded-md": "8px",
+    "--pcm-rounded-lg": "11px",
+    "--pcm-rounded-xl": "22px",
+    "--pcm-rounded-full": "9999px",
+    "--pcm-error-color": "#EA4335",
+    "--pcm-error-background": hexToRgba("#EA4335", 0.2),
+    "--pcm-success-color": "#58C08F",
+    "--pcm-success-background": hexToRgba("#58C08F", 0.2),
+    "--pcm-warning-color": "#F59E0A",
+    "--pcm-warning-background": hexToRgba("#F59E0A", 0.2),
+    "--pcm-wallet-lable-color": "#33C759",
+    "--pcm-wallet-lable-background": hexToRgba("#33C759", 0.2)
+  }
+};
+var themeColors = {
+  light: themes_default.base.light,
+  dark: themes_default.base.dark
+};
+var createCssVars = (scheme, override) => {
+  const important = override ? " !important" : "";
+  return css`
+    ${Object.keys(scheme).map((key) => {
+    const value = scheme[key];
+    return value && `${key}:${value}${important};`;
+  })}
+  `;
+};
+var themes = {
+  default: createCssVars(themeGlobals.default),
+  light: createCssVars(themeColors.light),
+  dark: createCssVars(themeColors.dark)
+};
+var ThemeContainer = styled.div`
+  ${themes.default}
+
+  ${(props) => {
+  if (props.$useMode === "light") {
+    return themes.light;
+  } else if (props.$useMode === "dark") {
+    return themes.dark;
+  } else {
+    return css`
+        @media (prefers-color-scheme: light) {
+          ${themes.light}
+        }
+        @media (prefers-color-scheme: dark) {
+          ${themes.dark}
+        }
+      `;
+  }
+}}
+  
+
+  ${(props) => {
+  if (props.$useTheme) {
+    return createCssVars(props.$useTheme, true);
+  }
+  return void 0;
+}}
+
+
+  ${(props) => {
+  if (props.$useTheme) {
+    const merge = {};
+    if (props.$useTheme["--pcm-success-color"]) {
+      merge["--pcm-success-background"] = hexToRgba(props.$useTheme["--pcm-success-color"], 0.2);
+    }
+    if (props.$useTheme["--pcm-warning-color"]) {
+      merge["--pcm-warning-background"] = hexToRgba(props.$useTheme["--pcm-warning-color"], 0.2);
+    }
+    if (props.$useTheme["--pcm-error-color"]) {
+      merge["--pcm-error-background"] = hexToRgba(props.$useTheme["--pcm-error-color"], 0.2);
+    }
+    if (props.$useTheme["--pcm-wallet-lable-color"]) {
+      merge["--pcm-wallet-lable-background"] = hexToRgba(props.$useTheme["--pcm-wallet-lable-color"], 0.2);
+    }
+    return createCssVars(merge, true);
+  }
+  return void 0;
+}}
+
+
+  all: initial;
+  text-align: left;
+  text-direction: ltr;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: auto;
+  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
+  -webkit-text-stroke: 0.001px transparent;
+  text-size-adjust: none;
+  font-size: 16px;
+  color: var(--pcm-body-color);
+
+  &,
+  * {
+    font-family: var(--pcm-font-family);
+    box-sizing: border-box;
+
+    &:after,
+    &:before {
+      box-sizing: border-box;
+      border: 0 solid #e5e7eb;
+    }
+  }
+
+  img,
+  svg {
+    max-width: 100%;
+    overflow: visible;
+  }
+  strong {
+    font-weight: 600;
+  }
+  input:focus-visible,
+  a:focus-visible,
+  button:focus-visible {
+    outline: 1px solid var(--pcm-focus-color, var(--pcm-accent-color));
+  }
+
+  input {
+    caret-color: var(--pcm-focus-color, var(--pcm-accent-color));
+  }
+
+  @keyframes spin {
+    0% {
+      transform: rotate(0deg);
+    }
+    100% {
+      transform: rotate(360deg);
+    }
+  }
+`;
+
+// src/context/modalProvider/index.tsx
+import React, { createContext, useEffect as useEffect3, useMemo as useMemo4, useRef as useRef2 } from "react";
+
+// src/hooks/useAAPlugin.ts
+import { create as create4 } from "zustand";
+var useAAPlugin = create4((set) => ({
+  smartAccount: null,
+  setSmartAccount: (value) => {
+    set({ smartAccount: value });
+  }
+}));
+
+// src/hooks/useConnections.ts
+import { useSyncExternalStore } from "react";
+
+// src/actions/getConnections.ts
+var previousConnections = [];
+function getConnections(config) {
+  if (config.state.status === "reconnecting")
+    return previousConnections;
+  const connections = [...config.state.connections.values()];
+  const current = config.state.current;
+  connections.sort((a, b) => {
+    if (a.connector.uid === current) {
+      return -1;
+    }
+    if (b.connector.uid === current) {
+      return 1;
+    }
+    return 0;
+  });
+  if (deepEqual(previousConnections, connections))
+    return previousConnections;
+  previousConnections = connections;
+  return connections;
+}
+
+// src/actions/watchConnections.ts
+function watchConnections(config, parameters) {
+  const { onChange } = parameters;
+  return config.subscribe(() => getConnections(config), onChange, {
+    equalityFn: deepEqual
+  });
+}
+
+// src/hooks/useConnections.ts
+function useConnections() {
+  const { config } = useContext();
+  return useSyncExternalStore(
+    (onChange) => watchConnections(config, { onChange }),
+    () => getConnections(config),
+    () => getConnections(config)
+  );
+}
+
+// src/config/walletKeys.ts
+var walletConfigKeys = [
+  "particleEVM, particleSolana, network.particle",
+  "coinbaseWallet, coinbaseWalletSDK, com.coinbase.wallet",
+  "metaMask, io.metamask, io.metamask.mobile",
+  "phantom, app.phantom",
+  "okxWallet, oKExWallet, com.okex.wallet",
+  "bitKeep, bitget, com.bitget.web3",
+  "rabby, io.rabby",
+  "rainbow, me.rainbow",
+  "talisman, xyz.talisman",
+  "trust, trustWallet, com.trustwallet.app",
+  "com.crypto.wallet",
+  "frontier, xyz.frontier.wallet",
+  "zerion, io.zerion.wallet",
+  "tokenPocket, pro.tokenpocket",
+  "safePal, https://www.safepal.com/download",
+  "coin98, coin98.com",
+  "onekey, so.onekey.app.wallet",
+  "bybitWallet, com.bybit",
+  "braveWallet, com.brave.wallet",
+  "mantaWallet,manta.network"
+];
+
+// src/actions/filterConnectors.ts
+var filterConnectors = (connectors) => {
+  return connectors.filter(
+    (connector, index, self) => self.findIndex((c) => c.id === connector.id && c.chainType === connector.chainType) === index
+  ).filter((connector, index, self) => {
+    if (connector.chainType === "solana") {
+      return true;
+    }
+    const isMipd = connector.id.includes(".");
+    if (isMipd) {
+      return true;
+    }
+    const groupId = walletConfigKeys.find(
+      (id) => id.split(",").map((i) => i.trim()).indexOf(connector.id) !== -1
+    );
+    if (groupId && groupId.includes(",")) {
+      const mipdIds = groupId.split(",").map((id) => id.trim()).filter((id) => id.includes("."));
+      const hasMipd = self.find((c) => mipdIds.includes(c.id));
+      return Boolean(!hasMipd);
+    }
+    return true;
+  });
+};
+
+// src/actions/reconnect.ts
+var reconnectingConfigUid;
+async function reconnect(config, parameters = {}) {
+  if (reconnectingConfigUid && reconnectingConfigUid === config.uid)
+    return [];
+  const status = reconnectingConfigUid ? "reconnecting" : void 0;
+  reconnectingConfigUid = config.uid;
+  config.setState((x) => ({
+    ...x,
+    status: x.current || status ? "reconnecting" : "connecting"
+  }));
+  const connectors = [];
+  if (parameters.connectors?.length) {
+    connectors.push(...parameters.connectors);
+  } else {
+    const configConnectors = config.connectors;
+    connectors.push(...filterConnectors(configConnectors));
+  }
+  let recentConnectorId;
+  try {
+    recentConnectorId = await config.storage?.getItem("recentConnectorId");
+  } catch {
+  }
+  const scores = {};
+  for (const [, connection] of config.state.connections) {
+    scores[connection.connector.id] = 1;
+  }
+  if (recentConnectorId)
+    scores[recentConnectorId] = 0;
+  const sorted = Object.keys(scores).length > 0 ? [...connectors].sort((a, b) => (scores[a.id] ?? 10) - (scores[b.id] ?? 10)) : connectors;
+  let connected = false;
+  const connections = [];
+  const providers = [];
+  for (const connector of sorted) {
+    const provider_ = await connector.getProvider().catch(() => void 0);
+    if (!provider_)
+      continue;
+    if (providers.some((provider) => provider === provider_))
+      continue;
+    const isAuthorized = await connector.isAuthorized();
+    if (!isAuthorized)
+      continue;
+    const data = await connector.connect({ isReconnecting: true }).catch(() => null);
+    if (!data)
+      continue;
+    connector.emitter.off("connect", config._internal.events.connect);
+    connector.emitter.on("change", config._internal.events.change);
+    connector.emitter.on("disconnect", config._internal.events.disconnect);
+    config.setState((x) => {
+      const connections2 = new Map(connected ? x.connections : /* @__PURE__ */ new Map()).set(connector.uid, {
+        accounts: data.accounts,
+        chainId: data.chainId,
+        connector
+      });
+      return {
+        ...x,
+        current: connected ? x.current : connector.uid,
+        connections: connections2
+      };
+    });
+    connections.push({
+      accounts: data.accounts,
+      chainId: data.chainId,
+      connector
+    });
+    providers.push(provider_);
+    connected = true;
+  }
+  if (config.state.status === "reconnecting" || config.state.status === "connecting") {
+    if (!connected) {
+      config.setState((x) => ({
+        ...x,
+        connections: /* @__PURE__ */ new Map(),
+        current: null,
+        status: "disconnected"
+      }));
+    } else {
+      config.setState((x) => ({ ...x, status: "connected" }));
+    }
+  }
+  reconnectingConfigUid = void 0;
+  return connections;
+}
+
+// src/utils/hydrate.ts
+function hydrate(config, parameters) {
+  const { reconnectOnMount } = parameters;
+  return {
+    async onMount() {
+      if (reconnectOnMount) {
+        reconnect(config);
+      } else if (config.storage) {
+        config.setState((x) => ({
+          ...x,
+          connections: /* @__PURE__ */ new Map()
+        }));
+      }
+    }
+  };
+}
+
+// src/context/modalProvider/index.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var ModalContext = createContext(null);
+var modalContextValue = {};
+var reconnectConfigUid;
+var ModalProvider = (props) => {
+  const { reconnectOnMount } = props;
+  const { config } = useContext();
+  const connections = useConnections();
+  const account = useAccount();
+  const { appearance } = useAppearance();
+  const setSmartAccount = useAAPlugin((state) => state.setSmartAccount);
+  const handlePlugin = async (connections2, plugins) => {
+    const result = connections2.filter((connection) => connection.connector && connection.connector.getProvider);
+    for (const plugin of plugins) {
+      if (result.length) {
+        await plugin.onConnect?.(result);
+      } else {
+        await plugin.onDisconnect?.();
+      }
+    }
+    const aaPlugin = config.plugins.find((plugin) => plugin.id === "aa");
+    setSmartAccount(aaPlugin?.smartAccount ?? null);
+  };
+  useEffect3(() => {
+  }, [account]);
+  const reconnectRef = useRef2(false);
+  const { onMount } = hydrate(config, {
+    reconnectOnMount
+  });
+  if (!reconnectRef.current) {
+    reconnectRef.current = true;
+    reconnectConfigUid = config.uid;
+    onMount();
+  }
+  useEffect3(() => {
+    if (config.uid !== reconnectConfigUid) {
+      reconnectConfigUid = config.uid;
+      onMount();
+    }
+  }, [config.uid, onMount]);
+  const walletPlugin = useMemo4(() => {
+    const plugin = config.plugins.find((plugin2) => plugin2.id === "wallet");
+    if (plugin) {
+      return plugin;
+    }
+    return void 0;
+  }, [config.plugins]);
+  useEffect3(() => {
+    if (walletPlugin) {
+      const aaPlugin = config.plugins.find((plugin) => plugin.id === "aa");
+      const erc4337 = aaPlugin ? aaPlugin.erc4337 : void 0;
+      walletPlugin.init({
+        erc4337
+      });
+    }
+  }, [walletPlugin, config.plugins]);
+  useEffect3(() => {
+    if (walletPlugin) {
+      const walletOption = getWalletOption(appearance);
+      walletPlugin.overrideWalletOption({
+        ...walletOption,
+        language: appearance.language
+      });
+    }
+  }, [appearance, walletPlugin]);
+  useEffect3(() => {
+    handlePlugin(connections, config.plugins);
+  }, [connections, config.plugins]);
+  return /* @__PURE__ */ jsx2(ModalContext.Provider, { value: modalContextValue, children: props.children });
+};
+
+// src/context/web3Provider/index.tsx
+import React2, { createContext as createContext2, useEffect as useEffect4, useMemo as useMemo5 } from "react";
+
+// src/actions/getSolanaWalletClient.ts
+import {
+  ChainTypeError,
+  ConnectorAccountNotFoundError,
+  ConnectorNotConnectedError,
+  sendSolanaTransaction
+} from "@particle-network/connector-core";
+var getSolanaWalletClient = async (config, parameters = {}) => {
+  let connection;
+  if (parameters.connector) {
+    const { connector: connector2 } = parameters;
+    const [accounts, chainId2] = await Promise.all([connector2.getAccounts(), connector2.getChainId()]);
+    connection = {
+      accounts,
+      chainId: chainId2,
+      connector: connector2
+    };
+  } else
+    connection = config.state.connections.get(config.state.current);
+  if (!connection)
+    throw new ConnectorNotConnectedError();
+  const chainId = parameters.chainId ?? connection.chainId;
+  const connector = connection.connector;
+  if (connector.chainType !== "solana") {
+    throw new ChainTypeError();
+  }
+  const provider = await connector.getProvider();
+  const account = parameters.account ?? connection.accounts[0];
+  const chain = config.chains.find((chain2) => chain2.id === chainId);
+  const clientConnection = config.getWalletConnector(connector.walletConnectorType).getClient(chain?.id || 101);
+  if (parameters.account && !connection.accounts.some((x) => x.toLowerCase() === account.toLowerCase()))
+    throw new ConnectorAccountNotFoundError({
+      address: account,
+      connector
+    });
+  return {
+    publicKey: provider.publicKey,
+    chain,
+    async signTransaction(transaction) {
+      return await provider.signTransaction(transaction);
+    },
+    async signAllTransactions(transactions) {
+      return await provider.signAllTransactions(transactions);
+    },
+    async sendTransaction(transaction, options = {}) {
+      if (connector.walletConnectorType === "particleAuth") {
+        const result = await provider.signAndSendTransaction(transaction);
+        return result;
+      }
+      return await sendSolanaTransaction(provider, transaction, clientConnection, options);
+    },
+    async signMessage(message) {
+      const { signature } = await provider.signMessage(message);
+      return { signature };
+    },
+    async switchChain(chainId2) {
+      return await connector.switchChain({ chainId: chainId2 });
+    }
+  };
+};
+
+// src/actions/getWalletClient.ts
+import { walletActions } from "viem";
+
+// src/actions/getConnectorClient.ts
+import {
+  ChainTypeError as ChainTypeError2,
+  ConnectorAccountNotFoundError as ConnectorAccountNotFoundError2,
+  ConnectorNotConnectedError as ConnectorNotConnectedError2
+} from "@particle-network/connector-core";
+import {
+  createClient,
+  custom
+} from "viem";
+import { getAddress, parseAccount } from "viem/utils";
+async function getConnectorClient(config, parameters = {}) {
+  let connection;
+  if (parameters.connector) {
+    const { connector: connector2 } = parameters;
+    const [accounts, chainId2] = await Promise.all([connector2.getAccounts(), connector2.getChainId()]);
+    connection = {
+      accounts,
+      chainId: chainId2,
+      connector: connector2
+    };
+  } else
+    connection = config.state.connections.get(config.state.current);
+  if (!connection)
+    throw new ConnectorNotConnectedError2();
+  const chainId = parameters.chainId ?? connection.chainId;
+  const connector = connection.connector;
+  if (connector.chainType !== "evm") {
+    throw new ChainTypeError2();
+  }
+  const account = parseAccount(parameters.account ?? connection.accounts[0]);
+  account.address = getAddress(account.address);
+  const chain = config.chains.find((chain2) => chain2.id === chainId);
+  const provider = await connection.connector.getProvider({ chainId });
+  if (parameters.account && !connection.accounts.some((x) => x.toLowerCase() === account.address.toLowerCase()))
+    throw new ConnectorAccountNotFoundError2({
+      address: account.address,
+      connector
+    });
+  return createClient({
+    account,
+    chain,
+    name: "Connector Client",
+    transport: (opts) => custom(provider)({ ...opts, retryCount: 0 })
+  });
+}
+
+// src/actions/getWalletClient.ts
+async function getWalletClient(config, parameters = {}) {
+  const client = await getConnectorClient(config, parameters);
+  client.extend(walletActions);
+  return client.extend(walletActions);
+}
+
+// src/actions/mapWalletClient.ts
+var mapWalletClient = async (parameters) => {
+  const { connections, config } = parameters;
+  const wallets = [];
+  for (const connection of connections) {
+    if (!connection.connector.walletConnectorType) {
+      continue;
+    }
+    if (connection.connector.chainType === "evm") {
+      const client = await getWalletClient(config, { connector: connection.connector });
+      const wallet = {
+        ...connection,
+        getWalletClient: () => client
+      };
+      wallets.push(wallet);
+    } else {
+      const client = await getSolanaWalletClient(config, { connector: connection.connector });
+      const wallet = {
+        ...connection,
+        getWalletClient: () => client
+      };
+      wallets.push(wallet);
+    }
+  }
+  return wallets;
+};
+
+// src/hooks/useMutation.ts
+import { useCallback as useCallback3, useState as useState2 } from "react";
+var useMutation = (mutationFn, options) => {
+  const [status, setStatus] = useState2("idle");
+  const [data, setData] = useState2(null);
+  const [error, setError] = useState2(null);
+  const mutateAsync = useCallback3(
+    async (variables) => {
+      if (options?.onMutate) {
+        options.onMutate(variables);
+      }
+      setStatus("loading");
+      setData(null);
+      setError(null);
+      try {
+        const result = await mutationFn(variables);
+        setData(result);
+        setStatus("success");
+        if (options?.onSuccess) {
+          options.onSuccess(result);
+        }
+        if (options?.onSettled) {
+          options.onSettled(result, null);
+        }
+        return result;
+      } catch (err) {
+        setError(err);
+        setStatus("error");
+        if (options?.onError) {
+          options.onError(err);
+        }
+        if (options?.onSettled) {
+          options.onSettled(null, err);
+        }
+        throw err;
+      }
+    },
+    [mutationFn, options]
+  );
+  const mutate = useCallback3(
+    (variables) => {
+      mutateAsync(variables).catch(() => {
+      });
+    },
+    [mutateAsync]
+  );
+  return { status, data, error, mutate, mutateAsync };
+};
+
+// src/context/web3Provider/index.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+var Web3Context = createContext2(null);
+var Web3Provder = ({ children }) => {
+  const connections = useConnections();
+  const { config } = useContext();
+  const { data: wallets, mutate: connectionMutate } = useMutation(mapWalletClient);
+  useEffect4(() => {
+    connectionMutate({ connections, config });
+  }, [connections]);
+  return /* @__PURE__ */ jsx3(Web3Context.Provider, { value: useMemo5(() => ({ wallets: wallets ?? [] }), [wallets]), children });
+};
+var useWeb3Context = () => {
+  const context = React2.useContext(Web3Context);
+  if (!context)
+    throw Error("Web3 Hook must be inside a Provider.");
+  return context;
+};
+
+// src/context/index.tsx
+import { jsx as jsx4, jsxs } from "react/jsx-runtime";
+var Context = createContext3(null);
+var ConnectKitProvider = (parameters) => {
+  if (React3.useContext(Context)) {
+    throw new Error("Multiple, nested usages of ConnectKitProvider detected. Please use only one.");
+  }
+  const { children, config, reconnectOnMount = true } = parameters;
+  const { appearance } = useAppearance(config);
+  const { AuthCoreContextProvider, authOptions } = useMemo6(() => {
+    const authWalletConnector = config.getWalletConnector("particleAuth");
+    const aaPlugin = config.plugins.find((plugin) => plugin.id === "aa");
+    const erc4337 = aaPlugin ? aaPlugin.erc4337 : void 0;
+    let theme = appearance?.mode ?? getSystemMode();
+    if (theme === "auto") {
+      theme = getSystemMode();
+    }
+    return {
+      AuthCoreContextProvider: authWalletConnector?.AuthCoreContextProvider ?? React3.Fragment,
+      authOptions: authWalletConnector ? {
+        options: {
+          themeType: theme,
+          ...authWalletConnector.authOptions,
+          customStyle: {
+            ...authWalletConnector.authOptions?.customStyle,
+            theme: {
+              [theme]: getAuthCoreTheme(appearance)
+            }
+          },
+          erc4337
+        }
+      } : void 0
+    };
+  }, [config, appearance]);
+  return /* @__PURE__ */ jsx4(Context.Provider, { value: useMemo6(() => ({ options: config.options, config }), [config]), children: /* @__PURE__ */ jsx4(AuthCoreContextProvider, { ...authOptions, children: /* @__PURE__ */ jsxs(Web3Provder, { children: [
+    children,
+    /* @__PURE__ */ jsx4(ModalProvider, { reconnectOnMount, children: /* @__PURE__ */ jsx4(connectModal_default, {}) })
+  ] }) }) });
+};
+var useContext = () => {
+  const context = React3.useContext(Context);
+  if (!context)
+    throw Error("ConnectKit Hook must be inside a Provider.");
+  return context;
+};
+
+// src/hooks/useAppearance.ts
+var previousAppearance = {};
+function getAppearance(config) {
+  const appearance = { ...config.appearanceStore.getState() };
+  if (deepEqual(previousAppearance, appearance))
+    return previousAppearance;
+  previousAppearance = appearance;
+  return appearance;
+}
+function useAppearance(config) {
+  if (!config) {
+    const { config: globalConfig } = useContext();
+    config = globalConfig;
+  }
+  const setAppearance = useCallback4(
+    (value) => {
+      config.appearanceStore.setState(value || {}, true);
+    },
+    [config.appearanceStore]
+  );
+  const appearance = useSyncExternalStore2(
+    config.appearanceStore.subscribe,
+    () => getAppearance(config),
+    () => getAppearance(config)
+  );
+  return {
+    appearance,
+    setAppearance
+  };
+}
+
+export {
+  deepEqual,
+  useAppearance,
+  useLocales,
+  useModalError,
+  useMutation,
+  useRouter,
+  getSystemMode,
+  isIOS,
+  isAndroid,
+  isMobile,
+  hexToRgba,
+  shortAddress,
+  openMobileUrl,
+  hasPCDownloadUrl,
+  getElementDimensionsRelativeToParent,
+  getBuyUrl,
+  popupWindow,
+  roundToEven,
+  isFirstRegisterPasskey,
+  setFirstRegisterPasskey,
+  useAAPlugin,
+  ThemeContainer,
+  useConnections,
+  useWeb3Context,
+  useRouteState,
+  ConnectKitProvider,
+  useContext,
+  useAccount
+};
+//# sourceMappingURL=chunk-OWHSDWQK.js.map