@rash2x/bridge-widget 0.5.1 → 0.5.6

package/dist/{index-C0llk2Pm.cjs → index-BXUBhn_o.cjs}

@@ -23,16 +23,19 @@ const lucideReact = require("lucide-react");
 const framerMotion = require("framer-motion");
 const accordion = require("@/components/ui/accordion");
 const tooltip = require("@/components/ui/tooltip");
+const alert = require("@/components/ui/alert");
 const sonner = require("sonner");
 const reactDialog = require("@radix-ui/react-dialog");
 const viem = require("viem");
 const tronwalletAdapters = require("@tronweb3/tronwallet-adapters");
+const tronweb = require("tronweb");
 const card = require("@/components/ui/card");
 const badge = require("@/components/ui/badge");
 const common$1 = { "connecting": "Connecting…", "initializing": "Initializing...", "loading": "Loading...", "paste": "paste", "close": "Close", "zeroPlaceholder": "0", "nativeToken": "Native Token" };
 const wallets$1 = { "addTonWallet": "Add TON wallet", "addEvmWallet": "Add EVM wallet", "connectTonWallet": "Connect TON wallet", "connectEvmWallet": "Connect EVM wallet", "initializingMetamask": "Initializing MetaMask SDK...", "initializingTronlink": "Initializing TronLink...", "failedToConnectTon": "Failed to connect to TON wallet", "failedToDisconnect": "Failed to disconnect", "metamaskConnectionError": "MetaMask connection error", "failedToConnectMetamask": "Failed to connect to MetaMask", "failedToDisconnectMetamask": "Failed to disconnect from MetaMask", "selectWallet": "Select Wallet", "tonWallets": "TON", "evmWallets": "EVM", "tronWallets": "TRON", "tonconnect": "TonConnect", "metaMask": "WalletConnect", "walletConnect": "WalletConnect", "tronLink": "TronLink", "addTronWallet": "Add Tron wallet", "comingSoon": "Coming Soon", "connected": "CONNECTED", "disconnect": "Disconnect", "chooseWallet": "Choose wallet", "oneWalletPerEnv": "You can only connect one wallet per environment.", "connect": "Connect", "connectTronWallet": "Connect Tron wallet", "connectWallet": "Connect wallet" };
 const bridge$1 = { "max": "Max", "sourceNetwork": "Source network", "destinationNetwork": "Destination network", "selectToken": "Select token", "selectNetwork": "Select network", "selectSourceNetwork": "Select source network", "selectDestinationNetwork": "Select destination network", "searchToken": "Search token", "myTokens": "My tokens", "allTokens": "All tokens", "search": "Search", "select": "Select", "willChangeSourceChain": "Will change source network", "willChangeSourceNetworkAndToken": "Will change source token", "noBalancesFound": "No balances found.", "noResults": "No results", "tokenNotFound": "We couldn't find a token with that name or symbol. Please try again.", "chainNotFound": "We couldn't find a chain with that name. Please try again.", "sendToAnotherAddress": "Send to another address", "youWillReceive": "You will receive", "anotherAddressPlaceholder": "Address", "addressDoesntMatch": "Address doesn't match the {{network}} network", "checkBeforeTransfer": "Check correctness before transfer" };
 const transaction$1 = { "enterAmount": "Enter amount", "transfer": "Transfer", "getQuote": "Get quote", "failed": "Transaction Failed", "confirm": "Confirm transaction", "signTransaction": "Sign in transaction in wallet", "quoting": "Quoting...", "inProgress": "Processing...", "checkingBalance": "Checking balance...", "insufficientBalance": "Insufficient balance", "amountTooSmall": "Min {{min}}", "amountTooLarge": "Max {{max}}", "success": "Success", "successTitle": "Success", "done": "Done", "hashCopied": "Hash copied to clipboard", "bridged": "Bridged", "transferTitle": "Transfer", "hash": "Hash", "finalFee": "Final Fee", "route": "Route", "estTime": "Est. Time", "slippage": "Slippage", "minimumReceived": "Minimum received", "totalFee": "Total Fee", "noRouteFound": "No route found", "notEnoughGas": "Not enough gas", "noRouteFoundForSettings": "No route found for current settings.", "tryAdjustSettings": "Try disabling Gas on Destination, or adjust amount/networks.", "quoteError": "Quote error" };
+const telegram$1 = { "openWebVersion": "Open EVAA Web to Bridge", "restrictionMessage": "You can bridge between the chosen networks on EVAA web version" };
 const app$1 = { "stargateWidgetName": "Stargate Bridge Widget", "liveWidget": "Live Widget", "getStarted": "Get Started" };
 const settings$1 = { "title": "Settings", "gasOnDestination": "Gas on destination", "slippageTolerance": "Slippage tolerance", "routePriority": "Route Priority", "highSlippageWarning": "High slippage warning", "gasPresets": { "auto": "Auto", "none": "None", "medium": "Medium", "max": "Max" }, "routePresets": { "fastest": "Fastest", "cheapest": "Cheapest", "recommended": "Recommended" } };
 const errors$1 = { "WALLET_NOT_CONNECTED": "{{chainKey}} wallet not connected", "WALLET_CONNECTION_FAILED": "Failed to connect {{chainKey}} wallet", "WALLET_NOT_FOUND": "No {{chainKey}} wallet found. Please install a wallet extension.", "INVALID_ADDRESS": "Invalid {{chainKey}} address format", "INVALID_STEPS": "Invalid transaction steps for {{chainKey}}", "INVALID_TRANSACTION_DATA": "Invalid transaction data for {{chainKey}}", "TRANSACTION_REJECTED": "Transaction rejected by user", "TRANSACTION_FAILED": "Transaction failed", "TRANSACTION_TIMEOUT": "Transaction confirmation timeout", "TRANSACTION_REVERTED": "Transaction reverted on-chain", "INSUFFICIENT_GAS": "Insufficient {{chainKey}} gas", "PROVIDER_NOT_AVAILABLE": "{{chainKey}} provider not available", "NETWORK_REQUEST_FAILED": "Network request failed", "TRANSACTION_FAILED_TO_COMPLETE": "Transaction failed to complete", "COMPLETION_TRACKING_FAILED": "Completion tracking failed", "UNKNOWN_ERROR": "An unknown error occurred" };
@@ -41,6 +44,7 @@ const en$3 = {
   wallets: wallets$1,
   bridge: bridge$1,
   transaction: transaction$1,
+  telegram: telegram$1,
   app: app$1,
   settings: settings$1,
   errors: errors$1
@@ -49,6 +53,7 @@ const common = { "connecting": "Подключение…", "initializing": "И
 const wallets = { "addTonWallet": "Добавить TON кошелёк", "addEvmWallet": "Добавить EVM кошелёк", "connectTonWallet": "Подключить TON кошелёк", "connectEvmWallet": "Подключить EVM кошелёк", "initializingMetamask": "Инициализация MetaMask SDK...", "initializingTronlink": "Инициализация TronLink...", "failedToConnectTon": "Не удалось подключиться к TON кошельку", "failedToDisconnect": "Не удалось отключиться", "metamaskConnectionError": "Ошибка подключения MetaMask", "failedToConnectMetamask": "Не удалось подключиться к MetaMask", "failedToDisconnectMetamask": "Не удалось отключиться от MetaMask", "selectWallet": "Выберите кошелёк", "tonWallets": "TON", "evmWallets": "EVM", "tronWallets": "TRON", "tonconnect": "TonConnect", "metaMask": "WalletConnect", "walletConnect": "WalletConnect", "tronLink": "TronLink", "addTronWallet": "Добавить Tron кошелёк", "comingSoon": "Скоро", "connected": "ПОДКЛЮЧЕНО", "disconnect": "Отключить", "chooseWallet": "Выберите кошелёк", "oneWalletPerEnv": "Можно подключить только один кошелёк на окружение.", "connect": "Подключить", "connectTronWallet": "Подключить Tron кошелёк", "connectWallet": "Подключить кошелёк" };
 const bridge = { "max": "Макс", "sourceNetwork": "Исходная сеть", "destinationNetwork": "Целевая сеть", "selectToken": "Выбрать токен", "selectNetwork": "Выбрать сеть", "selectSourceNetwork": "Выбрать исходную сеть", "selectDestinationNetwork": "Выбрать целевую сеть", "searchToken": "Поиск токена", "myTokens": "Мои токены", "allTokens": "Все токены", "search": "Поиск", "select": "Выбрать", "willChangeSourceChain": "Сменит исходную сеть", "willChangeSourceNetworkAndToken": "Сменит исходный токен", "noBalancesFound": "Балансы не найдены.", "noResults": "Нет результатов", "tokenNotFound": "Мы не смогли найти токен с таким названием или символом. Пожалуйста, попробуйте снова.", "chainNotFound": "Мы не смогли найти сеть с таким названием. Пожалуйста, попробуйте снова.", "sendToAnotherAddress": "Отправить на другой адрес", "youWillReceive": "Вы получите", "anotherAddressPlaceholder": "Адрес", "addressDoesntMatch": "Адрес не соответствует сети {{network}}", "checkBeforeTransfer": "Проверьте корректность перед переводом" };
 const transaction = { "enterAmount": "Введите сумму", "transfer": "Перевести", "getQuote": "Получить котировку", "quoting": "Расчет котировки...", "failed": "Ошибка транзакции", "confirm": "Подтвердите транзакцию", "signTransaction": "Подпишите транзакцию в кошельке", "inProgress": "Выполнение...", "checkingBalance": "Проверка баланса...", "insufficientBalance": "Недостаточно средств", "amountTooSmall": "Минимум {{min}}", "amountTooLarge": "Максимум {{max}}", "success": "Успех", "successTitle": "Успех", "done": "Готово", "hashCopied": "Хэш скопирован в буфер обмена", "bridged": "Переведено", "transferTitle": "Перевод", "hash": "Хэш", "finalFee": "Итоговая комиссия", "route": "Маршрут", "estTime": "Время", "slippage": "Проскальзывание", "minimumReceived": "Минимум к получению", "totalFee": "Общая комиссия", "noRouteFound": "Маршрут не найден", "notEnoughGas": "Недостаточно газа", "noRouteFoundForSettings": "Маршрут не найден для текущих настроек.", "tryAdjustSettings": "Попробуйте отключить Gas on Destination или измените сумму/сети.", "quoteError": "Ошибка котировки" };
+const telegram = { "openWebVersion": "Открыть EVAA веб для трансфера", "restrictionMessage": "Трансфер между выбранными сетями доступен только в веб-версии EVAA" };
 const app = { "stargateWidgetName": "Виджет Stargate Bridge", "liveWidget": "Живой виджет", "getStarted": "Начало работы" };
 const settings = { "title": "Настройки", "gasOnDestination": "Газ на назначении", "slippageTolerance": "Толерантность к проскальзыванию", "routePriority": "Приоритет маршрута", "highSlippageWarning": "Высокое проскальзывание", "gasPresets": { "auto": "Авто", "none": "Нет", "medium": "Средний", "max": "Макс" }, "routePresets": { "fastest": "Быстрейший", "cheapest": "Дешевейший", "recommended": "Рекомендуемый" } };
 const errors = { "WALLET_NOT_CONNECTED": "{{chainKey}} кошелёк не подключен", "WALLET_CONNECTION_FAILED": "Не удалось подключить {{chainKey}} кошелёк", "WALLET_NOT_FOUND": "{{chainKey}} кошелёк не найден. Пожалуйста, установите расширение кошелька.", "INVALID_ADDRESS": "Неверный формат {{chainKey}} адреса", "INVALID_STEPS": "Недопустимые шаги транзакции для {{chainKey}}", "INVALID_TRANSACTION_DATA": "Недопустимые данные транзакции для {{chainKey}}", "TRANSACTION_REJECTED": "Транзакция отклонена пользователем", "TRANSACTION_FAILED": "Транзакция не удалась", "TRANSACTION_TIMEOUT": "Время ожидания подтверждения транзакции истекло", "TRANSACTION_REVERTED": "Транзакция отменена в блокчейне", "INSUFFICIENT_GAS": "Недостаточно {{chainKey}} газа", "PROVIDER_NOT_AVAILABLE": "{{chainKey}} провайдер недоступен", "NETWORK_REQUEST_FAILED": "Сетевой запрос не удался", "TRANSACTION_FAILED_TO_COMPLETE": "Транзакция не завершилась", "COMPLETION_TRACKING_FAILED": "Отслеживание завершения не удалось", "UNKNOWN_ERROR": "Произошла неизвестная ошибка" };
@@ -57,6 +62,7 @@ const ru$1 = {
   wallets,
   bridge,
   transaction,
+  telegram,
   app,
   settings,
   errors
@@ -481,11 +487,40 @@ function fromLD(ld, decimals) {
   const frac = Number(bi2 % base3) / Number(base3);
   return Number(int) + frac;
 }
+const useTronWalletConnectStore = zustand.create(
+  (set2) => ({
+    address: null,
+    isConnected: false,
+    isConnecting: false,
+    connect: null,
+    disconnect: null,
+    signTransaction: null,
+    setAddress: (address) => set2({
+      address,
+      isConnected: !!address
+    }),
+    setIsConnecting: (connecting) => set2({ isConnecting: connecting }),
+    setActions: (actions) => set2({
+      connect: actions.connect,
+      disconnect: actions.disconnect,
+      signTransaction: actions.signTransaction
+    }),
+    reset: () => set2({
+      address: null,
+      isConnected: false,
+      isConnecting: false
+    })
+  })
+);
 function useAddresses() {
   const { fromChain, toChain } = useChainsStore();
   const { address: evmAddress } = wagmi.useAccount();
   const tonAddress = uiReact.useTonAddress();
-  const { address: tronAddress } = tronwalletAdapterReactHooks.useWallet();
+  const { address: tronLinkAddress } = tronwalletAdapterReactHooks.useWallet();
+  const tronWalletConnectAddress = useTronWalletConnectStore(
+    (state2) => state2.address
+  );
+  const tronAddress = tronLinkAddress || tronWalletConnectAddress || void 0;
   const srcAddress = react.useMemo(() => {
     if (!fromChain?.chainKey) return void 0;
     const chainKey = fromChain.chainKey.toLowerCase();
@@ -822,7 +857,14 @@ const isEvmAddress = (addr) => {
   return /^0x[0-9a-fA-F]{40}$/.test(addr ?? "");
 };
 const isTronAddress = (addr) => {
-  return /^T[1-9A-HJ-NP-Za-km-z]{33}$/.test(addr ?? "");
+  if (!addr) return false;
+  const trimmed = addr.trim();
+  if (/^T[1-9A-HJ-NP-Za-km-z]{33}$/.test(trimmed)) {
+    return true;
+  }
+  const normalized = trimmed.startsWith("0x") ? trimmed.slice(2) : trimmed.startsWith("41") ? trimmed : "";
+  if (!normalized) return false;
+  return /^41[0-9a-fA-F]{40}$/.test(normalized);
 };
 const isTonAddress = (addr) => {
   if (!addr) return false;
@@ -2331,6 +2373,7 @@ const TokenInput = react.forwardRef(
   ({
     value,
     onAmountChange,
+    onAmountBlur,
     showSkeleton = false,
     className,
     max,
@@ -2354,6 +2397,7 @@ const TokenInput = react.forwardRef(
     if (showSkeleton && readOnly) {
       return /* @__PURE__ */ jsxRuntime.jsx(skeleton.Skeleton, { className: utils$1.cn("h-8 my-2 w-1/3 bg-secondary rounded-md", className) });
     }
+    const { onBlur: restOnBlur, ...restWithoutOnBlur } = rest;
     return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: /* @__PURE__ */ jsxRuntime.jsx(
       input.Input,
       {
@@ -2370,7 +2414,11 @@ const TokenInput = react.forwardRef(
           className
         ),
         max,
-        ...rest
+        ...restWithoutOnBlur,
+        onBlur: (e2) => {
+          restOnBlur?.(e2);
+          onAmountBlur?.();
+        }
       }
     ) });
   }
@@ -2740,7 +2788,8 @@ const SwapSection = ({
   disableNetworkSelect,
   isSource,
   onSelect,
-  onAmountChange
+  onAmountChange,
+  onAmountBlur
 }) => {
   const { isOpen, onClose, onOpen } = useModal();
   const { assetMatrix, selectedAssetSymbol } = useTokensStore();
@@ -2811,6 +2860,7 @@ const SwapSection = ({
                   (v3) => onAmountChange?.(v3),
                   [onAmountChange]
                 ),
+                onAmountBlur,
                 readOnly: !!readOnlyAmount,
                 showSkeleton: status === "loading",
                 className: "p-0",
@@ -3392,12 +3442,9 @@ class TransactionRevertedError extends ChainStrategyError {
   }
 }
 class ProviderNotAvailableError extends ChainStrategyError {
-  constructor(chainKey) {
-    super(
-      `${chainKey.toUpperCase()} provider not available`,
-      "PROVIDER_NOT_AVAILABLE",
-      chainKey
-    );
+  constructor(chainKey, reason) {
+    const message = reason ? `${chainKey.toUpperCase()} provider not available: ${reason}` : `${chainKey.toUpperCase()} provider not available`;
+    super(message, "PROVIDER_NOT_AVAILABLE", chainKey);
     this.name = "ProviderNotAvailableError";
   }
 }
@@ -3716,6 +3763,22 @@ function useSilentValidations(amountString) {
   ]);
   return validationResult;
 }
+function useTelegramRestriction() {
+  const { fromChain, toChain } = useChainsStore();
+  const restriction = react.useMemo(() => {
+    const isTelegramEnv = typeof window !== "undefined" && /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+    typeof window.TelegramWebviewProxy?.postEvent === "function";
+    if (!isTelegramEnv) {
+      return { isRestricted: false, isTelegramEnv: false };
+    }
+    const hasTonInvolved = fromChain?.chainKey?.toLowerCase() === "ton" || toChain?.chainKey?.toLowerCase() === "ton";
+    return {
+      isRestricted: !hasTonInvolved,
+      isTelegramEnv: true
+    };
+  }, [fromChain?.chainKey, toChain?.chainKey]);
+  return restriction;
+}
 const MainButton = () => {
   const { t: t2 } = useBridgeTranslation();
   const { chainRegistry } = useChainStrategies();
@@ -3732,6 +3795,7 @@ const MainButton = () => {
   );
   const { hasAmountTooLarge, maximumAmountFormatted } = useAmountLimits(amountNum);
   const { isValidForTransfer } = useSilentValidations(inputAmount || "");
+  const { isRestricted: isTelegramRestricted } = useTelegramRestriction();
   const srcChainKey = quote?.srcChainKey ?? fromChain?.chainKey;
   const dstChainKey = quote?.dstChainKey ?? toChain?.chainKey;
   const srcConnectedOk = srcChainKey && chainRegistry.isWalletConnected(srcChainKey);
@@ -3744,6 +3808,8 @@ const MainButton = () => {
   const canTransfer = !missingSrc && !missingDst && amountNum > 0 && !!srcChainKey && !!dstChainKey;
   const label = react.useMemo(() => {
     switch (true) {
+      case isTelegramRestricted:
+        return t2("telegram.openWebVersion");
       case status === "loading":
         return t2("transaction.quoting");
       case isTxProcessing:
@@ -3775,6 +3841,7 @@ const MainButton = () => {
     }
   }, [
     t2,
+    isTelegramRestricted,
     status,
     isTxProcessing,
     isBusy,
@@ -3794,6 +3861,12 @@ const MainButton = () => {
   ]);
   const handleClick = async () => {
     if (isBusy) return;
+    if (isTelegramRestricted) {
+      const searchParams = typeof window !== "undefined" ? window.location.search || "" : "";
+      const targetUrl = `https://app.evaa.finance/bridge${searchParams}`;
+      window.open(targetUrl, "_blank", "noopener,noreferrer");
+      return;
+    }
     if (missingSrc) {
       onOpen("src");
       return;
@@ -3811,51 +3884,26 @@ const MainButton = () => {
       return;
     }
   };
-  const disabled = isBusy || status === "loading" || !missingSrc && !missingDst && (amountNum <= 0 || isBalanceLoading || hasInsufficientBalance || hasAmountTooLarge || !gas.hasEnoughGas || noRoute || !isValidForTransfer);
-  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "pt-4", children: /* @__PURE__ */ jsxRuntime.jsx(
-    button.Button,
-    {
-      onClick: handleClick,
-      disabled,
-      size: "lg",
-      className: "w-full",
-      children: label
-    }
-  ) });
+  const disabled = isBusy || status === "loading" || !isTelegramRestricted && !missingSrc && !missingDst && (amountNum <= 0 || isBalanceLoading || hasInsufficientBalance || hasAmountTooLarge || !gas.hasEnoughGas || noRoute || !isValidForTransfer);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "pt-4 space-y-4", children: [
+    isTelegramRestricted && /* @__PURE__ */ jsxRuntime.jsx(alert.Alert, { variant: "warning", className: "mt-2 text-sm font-medium text-center", children: /* @__PURE__ */ jsxRuntime.jsx(alert.AlertDescription, { children: t2("telegram.restrictionMessage") }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      button.Button,
+      {
+        onClick: handleClick,
+        disabled,
+        size: "lg",
+        className: "w-full",
+        children: label
+      }
+    )
+  ] });
 };
-const useTronWalletConnectStore = zustand.create(
-  (set2) => ({
-    // State
-    address: null,
-    isConnected: false,
-    isConnecting: false,
-    connect: null,
-    disconnect: null,
-    signTransaction: null,
-    // Actions
-    setAddress: (address) => set2({
-      address,
-      isConnected: !!address
-    }),
-    setIsConnecting: (connecting) => set2({ isConnecting: connecting }),
-    setActions: (actions) => set2({
-      connect: actions.connect,
-      disconnect: actions.disconnect,
-      signTransaction: actions.signTransaction
-    }),
-    reset: () => set2({
-      address: null,
-      isConnected: false,
-      isConnecting: false
-    })
-  })
-);
 const WalletModalButton = (props) => {
   const { t: t2 } = reactI18next.useTranslation();
   const { icon: IconComponent, name, onClose } = props;
   const { chainRegistry } = useChainStrategies();
   const { connect, isPending } = wagmi.useConnect();
-  const { connect: connectTronWC } = useTronWalletConnectStore();
   const [isConnecting, setIsConnecting] = react.useState(false);
   if (props.variant === "connected") {
     const { address, onDisconnect } = props;
@@ -3893,15 +3941,13 @@ const WalletModalButton = (props) => {
     try {
       if (connector) {
         connect({ connector });
-      } else if (walletId === "tronwc") {
-        if (connectTronWC) {
-          await connectTronWC();
-        }
-      } else {
-        const strategy = chainRegistry.getStrategyByType(
-          walletId === "ton" ? "ton" : "tron"
-        );
+      } else if (walletId === "ton") {
+        const strategy = chainRegistry.getStrategyByType("ton");
         await strategy?.connect();
+      } else {
+        const strategy = chainRegistry.getStrategyByType("tron");
+        const provider = walletId === "tronwc" ? "walletconnect" : "tronlink";
+        await strategy?.connect({ provider });
       }
       onClose?.();
     } catch (error) {
@@ -3944,7 +3990,10 @@ const WalletSelectModal = () => {
   const tonWallet = chainRegistry.getStrategyByType(CHAIN_TYPES.TON);
   const metaMaskWallet = chainRegistry.getStrategyByType(CHAIN_TYPES.EVM);
   const tronWallet = chainRegistry.getStrategyByType(CHAIN_TYPES.TRON);
-  const { address: tronWCAddress, isConnected: tronWCConnected, disconnect: tronWCDisconnect } = useTronWalletConnectStore();
+  const tronConnections = tronWallet?.getAvailableConnections() ?? [];
+  const isTronWalletConnectConnected = tronConnections.some(
+    (conn) => conn.connected && conn.provider === "walletconnect"
+  );
   const walletConfigs = [
     {
       strategy: tonWallet,
@@ -3957,12 +4006,6 @@ const WalletSelectModal = () => {
       walletId: "metamask",
       name: t2("wallets.metaMask"),
       icon: MetaMaskIcon
-    },
-    {
-      strategy: tronWallet,
-      walletId: "tronlink",
-      name: t2("wallets.tronLink"),
-      icon: TronLinkIcon
     }
   ];
   const connectedWallets = walletConfigs.reduce((acc, { strategy, walletId, name, icon }) => {
@@ -3978,21 +4021,25 @@ const WalletSelectModal = () => {
     }
     return acc;
   }, []);
-  if (tronWCConnected && tronWCAddress) {
+  tronConnections.forEach((connection) => {
+    if (!connection.connected || !connection.address) return;
+    const isWalletConnect = connection.provider === "walletconnect";
     connectedWallets.push({
-      id: "tronwc",
-      name: t2("wallets.walletConnect"),
-      icon: WalletConnectIcon,
-      address: tronWCAddress,
-      onDisconnect: () => tronWCDisconnect?.()
+      id: isWalletConnect ? "tronwc" : "tronlink",
+      name: isWalletConnect ? t2("wallets.walletConnect") : t2("wallets.tronLink"),
+      icon: isWalletConnect ? WalletConnectIcon : TronLinkIcon,
+      address: connection.address,
+      onDisconnect: () => tronWallet?.disconnect({ provider: connection.provider })
     });
-  }
+  });
   const isWalletConnected = (walletId) => {
     const isEvmConnector = connectors.some((c2) => c2.id === walletId);
     if (isEvmConnector && metaMaskWallet?.isConnected()) {
       return true;
     }
-    if (walletId === "tronwc" && tronWCConnected) {
+    if ((walletId === "tronwc" || walletId === "tronlink") && tronConnections.some(
+      (conn) => conn.connected && (walletId === "tronwc" ? conn.provider === "walletconnect" : conn.provider !== "walletconnect")
+    )) {
       return true;
     }
     return connectedWallets.some((w2) => w2.id === walletId);
@@ -4026,7 +4073,12 @@ const WalletSelectModal = () => {
       icon: WalletConnectIcon,
       enabled: true
     }
-  ];
+  ].filter((wallet) => {
+    if (wallet.id === "tronlink" && isTronWalletConnectConnected) {
+      return false;
+    }
+    return true;
+  });
   const notConnected = (w2) => !isWalletConnected(w2.id);
   const categories = [
     {
@@ -4427,19 +4479,19 @@ class ChainStrategyRegistry {
     if (!strategy) return t2("wallets.connectWallet");
     return strategy.getConnectLabel(t2);
   }
-  async connectWallet(chainKey) {
+  async connectWallet(chainKey, options) {
     const strategy = this.getStrategy(chainKey);
     if (!strategy) {
       throw new Error(`No strategy available for chain: ${chainKey}`);
     }
-    await strategy.connect();
+    await strategy.connect(options);
   }
-  async disconnectWallet(chainKey) {
+  async disconnectWallet(chainKey, options) {
     const strategy = this.getStrategy(chainKey);
     if (!strategy) {
       throw new Error(`No strategy available for chain: ${chainKey}`);
     }
-    await strategy.disconnect();
+    await strategy.disconnect(options);
   }
 }
 function isNativeAddress(addr) {
@@ -4777,6 +4829,16 @@ class EvmChainStrategy {
     if (!address) return false;
     return /^0x[0-9a-fA-F]{40}$/.test(address);
   }
+  getAvailableConnections() {
+    return [
+      {
+        provider: "evm",
+        address: this.config.evmAddress || null,
+        connected: this.config.evmIsConnected,
+        isConnecting: false
+      }
+    ];
+  }
   validateSteps(steps) {
     if (!steps || steps.length === 0) {
       throw new InvalidStepsError("evm", "No transaction steps provided");
@@ -5167,6 +5229,16 @@ class TonChainStrategy {
     if (!address) return false;
     return true;
   }
+  getAvailableConnections() {
+    return [
+      {
+        provider: "tonconnect",
+        address: this.config.tonAddress || null,
+        connected: !!this.config.tonAddress,
+        isConnecting: false
+      }
+    ];
+  }
   validateSteps(steps) {
     if (!steps || steps.length === 0) {
       throw new InvalidStepsError("ton", "No transaction steps provided");
@@ -5367,9 +5439,11 @@ class TonChainStrategy {
     }
   }
 }
+const DEFAULT_TRON_NODE = "https://api.trongrid.io";
 class TronChainStrategy {
   constructor(config) {
     __publicField(this, "config");
+    __publicField(this, "fallbackClient");
     this.config = config;
   }
   canHandle(chainKey) {
@@ -5381,7 +5455,19 @@ class TronChainStrategy {
   getName() {
     return "TRON Chain Strategy";
   }
-  async connect() {
+  async connect(options) {
+    const provider = this.resolveProvider(options?.provider);
+    if (provider === "walletconnect") {
+      const walletConnect = this.config.walletConnect;
+      if (!walletConnect?.connect) {
+        throw new ProviderNotAvailableError(
+          "tron",
+          "WalletConnect is not configured for TRON"
+        );
+      }
+      await walletConnect.connect();
+      return;
+    }
     if (!this.isTronLinkInstalled()) {
       if (typeof window !== "undefined") {
         window.open("https://www.tronlink.org/", "_blank");
@@ -5391,21 +5477,83 @@ class TronChainStrategy {
         "TronLink wallet is not installed. Please install TronLink extension and try again."
       );
     }
-    this.config.tronSelect(tronwalletAdapters.TronLinkAdapterName);
+    this.config.tronLink.select(tronwalletAdapters.TronLinkAdapterName);
     await new Promise((resolve) => setTimeout(resolve, 100));
-    await this.config.tronConnect();
+    await this.config.tronLink.connect();
   }
-  async disconnect() {
-    await this.config.tronDisconnect();
+  async disconnect(options) {
+    const provider = options?.provider !== void 0 ? this.resolveProvider(options.provider) : this.getActiveConnector()?.provider ?? "tronlink";
+    if (provider === "walletconnect") {
+      const walletConnect = this.config.walletConnect;
+      if (walletConnect?.disconnect) {
+        await walletConnect.disconnect();
+      }
+      return;
+    }
+    await this.config.tronLink.disconnect();
   }
   isConnected() {
-    return !!this.config.tronConnected;
+    return !!this.getActiveConnector();
   }
   isConnecting() {
-    return false;
+    return !!this.config.walletConnect?.connecting;
   }
   getAccount() {
-    return this.config.tronAddress || null;
+    return this.getActiveConnector()?.address || null;
+  }
+  getAvailableConnections() {
+    const connections = [
+      this.getConnectorState("tronlink")
+    ];
+    if (this.config.walletConnect) {
+      connections.push(this.getConnectorState("walletconnect"));
+    }
+    return connections;
+  }
+  getActiveConnector() {
+    const walletConnect = this.config.walletConnect && this.getConnectorState("walletconnect");
+    if (walletConnect && walletConnect.connected && !!walletConnect.address) {
+      return walletConnect;
+    }
+    const tronLink = this.getConnectorState("tronlink");
+    if (tronLink.connected && !!tronLink.address) {
+      return tronLink;
+    }
+    return null;
+  }
+  getConnectorState(provider) {
+    if (provider === "walletconnect") {
+      const walletConnect = this.config.walletConnect;
+      return {
+        provider: "walletconnect",
+        address: walletConnect?.address ?? null,
+        connected: !!walletConnect?.connected,
+        isConnecting: !!walletConnect?.connecting,
+        connect: walletConnect?.connect,
+        disconnect: walletConnect?.disconnect,
+        signTransaction: walletConnect?.signTransaction
+      };
+    }
+    const tronLink = this.config.tronLink;
+    return {
+      provider: "tronlink",
+      address: tronLink.address ?? null,
+      connected: !!tronLink.connected,
+      isConnecting: false,
+      connect: tronLink.connect,
+      disconnect: tronLink.disconnect,
+      select: tronLink.select
+    };
+  }
+  resolveProvider(provider) {
+    if (!provider) {
+      return "tronlink";
+    }
+    const normalized = typeof provider === "string" ? provider.toLowerCase() : provider;
+    if (normalized === "walletconnect" || normalized === "tronwc") {
+      return "walletconnect";
+    }
+    return "tronlink";
   }
   getError() {
     return null;
@@ -5423,7 +5571,7 @@ class TronChainStrategy {
   }
   isAddressValid(address) {
     if (!address) return false;
-    return /^T[1-9A-HJ-NP-Za-km-z]{33}$/.test(address);
+    return isTronAddress(address);
   }
   validateSteps(steps) {
     console.log("validateSteps");
@@ -5445,14 +5593,13 @@ class TronChainStrategy {
     if (!tronWeb) {
       throw new ProviderNotAvailableError("tron");
     }
-    if (!this.isConnected()) {
+    const connector = this.getActiveConnector();
+    if (!connector?.connected || !connector.address) {
       throw new WalletNotConnectedError("tron");
     }
     this.validateSteps(steps);
-    const fromB58 = tronWeb.defaultAddress?.base58;
-    if (!fromB58) {
-      throw new WalletNotConnectedError("tron");
-    }
+    const fromB58 = connector.address;
+    this.ensureDefaultAddress(tronWeb, fromB58);
     let lastTxId;
     let isFirstHash = true;
     for (const step of steps) {
@@ -5518,7 +5665,7 @@ class TronChainStrategy {
             "Unsupported TRON parsed tx kind"
           );
       }
-      const { txid } = await this.signAndBroadcast(tronWeb, unsigned);
+      const { txid } = await this.signAndBroadcast(tronWeb, unsigned, connector);
       lastTxId = txid;
       if (isFirstHash) {
         onFirstHash?.(txid);
@@ -5641,7 +5788,26 @@ class TronChainStrategy {
     }
   }
   getClient() {
-    return typeof window !== "undefined" ? window.tronWeb : void 0;
+    if (typeof window !== "undefined" && window.tronWeb) {
+      return window.tronWeb;
+    }
+    if (!this.fallbackClient) {
+      this.fallbackClient = this.createFallbackClient();
+    }
+    return this.fallbackClient;
+  }
+  createFallbackClient() {
+    try {
+      const tronWeb = new tronweb.TronWeb(
+        DEFAULT_TRON_NODE,
+        DEFAULT_TRON_NODE,
+        DEFAULT_TRON_NODE
+      );
+      return tronWeb;
+    } catch (error) {
+      console.warn("Failed to create fallback TronWeb client", error);
+      return void 0;
+    }
   }
   /**
    * Check if TronLink wallet is actually installed
@@ -5660,6 +5826,21 @@ class TronChainStrategy {
     }
     return true;
   }
+  ensureDefaultAddress(tronWeb, address) {
+    if (!address) return;
+    try {
+      const hex = tronWeb.address.toHex(address);
+      const current = tronWeb.defaultAddress || {};
+      if (current.base58 !== address) {
+        tronWeb.defaultAddress = {
+          base58: address,
+          hex
+        };
+      }
+    } catch (error) {
+      console.debug("Failed to set TronWeb default address:", error);
+    }
+  }
   hexToAscii(h4) {
     if (!h4) return null;
     const clean2 = h4.replace(/^0x/, "");
@@ -5933,9 +6114,20 @@ class TronChainStrategy {
     }
     return res.transaction;
   }
-  async signAndBroadcast(tronWeb, unsignedTx) {
-    const signed = await tronWeb.trx.sign(unsignedTx);
-    const sent = await tronWeb.trx.sendRawTransaction(signed);
+  async signAndBroadcast(tronWeb, unsignedTx, connector) {
+    let signedTx;
+    if (connector.provider === "walletconnect") {
+      if (!connector.signTransaction) {
+        throw new ProviderNotAvailableError(
+          "tron",
+          "WalletConnect signing is unavailable"
+        );
+      }
+      signedTx = await connector.signTransaction(unsignedTx);
+    } else {
+      signedTx = await tronWeb.trx.sign(unsignedTx);
+    }
+    const sent = await tronWeb.trx.sendRawTransaction(signedTx);
     if (!sent?.result || !sent?.txid) {
       throw new TransactionFailedError(
         "tron",
@@ -6018,18 +6210,29 @@ function ChainStrategyProvider({
   );
   const tronStrategy = react.useMemo(
     () => new TronChainStrategy({
-      tronAddress: tronWallet.address,
-      tronConnected: tronWallet.connected,
-      tronSelect: tronWallet.select,
-      tronConnect: tronWallet.connect,
-      tronDisconnect: tronWallet.disconnect
+      tronLink: {
+        address: tronWallet.tronLink.address,
+        connected: tronWallet.tronLink.connected,
+        select: tronWallet.tronLink.select,
+        connect: tronWallet.tronLink.connect,
+        disconnect: tronWallet.tronLink.disconnect
+      },
+      walletConnect: tronWallet.walletConnect ? {
+        address: tronWallet.walletConnect.address,
+        connected: tronWallet.walletConnect.connected,
+        connecting: tronWallet.walletConnect.connecting,
+        connect: tronWallet.walletConnect.connect,
+        disconnect: tronWallet.walletConnect.disconnect,
+        signTransaction: tronWallet.walletConnect.signTransaction
+      } : void 0
     }),
     [
-      tronWallet.address,
-      tronWallet.connected,
-      tronWallet.select,
-      tronWallet.connect,
-      tronWallet.disconnect
+      tronWallet.tronLink.address,
+      tronWallet.tronLink.connected,
+      tronWallet.tronLink.select,
+      tronWallet.tronLink.connect,
+      tronWallet.tronLink.disconnect,
+      tronWallet.walletConnect
     ]
   );
   const chainRegistry = react.useMemo(
@@ -25606,7 +25809,7 @@ class WalletConnectModal {
   }
   async initUi() {
     if (typeof window !== "undefined") {
-      await Promise.resolve().then(() => require("./index-DedRamsD.cjs"));
+      await Promise.resolve().then(() => require("./index-CebGXD16.cjs"));
       const modal = document.createElement("wcm-modal");
       document.body.insertAdjacentElement("beforeend", modal);
       OptionsCtrl.setIsUiLoaded(true);
@@ -25654,14 +25857,10 @@ const TRON_MAINNET_CHAIN_ID = "tron:0x2b6653dc";
 function useTronWalletConnect(projectId) {
   const { address, isConnected, isConnecting } = useTronWalletConnectStore();
   const { setAddress, setIsConnecting, setActions, reset } = useTronWalletConnectStore();
-  const { setTronConnected } = useConnectedWalletsStore();
   const providerRef = react.useRef(null);
   const modalRef = react.useRef(null);
   const { onClose: closeWalletSelectModal } = useWalletSelectModal();
   const appliedTheme = useThemeStore((state2) => state2.appliedTheme);
-  react.useEffect(() => {
-    setTronConnected(isConnected);
-  }, [isConnected, setTronConnected]);
   react.useEffect(() => {
     if (!projectId || providerRef.current) return;
     const initProvider = async () => {
@@ -25833,6 +26032,194 @@ function useTronWalletConnect(projectId) {
     signTransaction
   };
 }
+function parseBridgeUrlParams(source) {
+  if (source && typeof source === "object") {
+    return source;
+  }
+  const queryString = typeof source === "string" ? source : typeof window !== "undefined" ? window.location.search : "";
+  const searchParams = new URLSearchParams(queryString);
+  return {
+    srcToken: searchParams.get("srcToken") || void 0,
+    srcChain: searchParams.get("srcChain") || void 0,
+    dstChain: searchParams.get("dstChain") || void 0,
+    amount: searchParams.get("amount") || void 0
+  };
+}
+function buildQueryString(params) {
+  const searchParams = new URLSearchParams();
+  if (params.srcToken) searchParams.set("srcToken", params.srcToken);
+  if (params.srcChain) searchParams.set("srcChain", params.srcChain);
+  if (params.dstChain) searchParams.set("dstChain", params.dstChain);
+  if (params.amount) searchParams.set("amount", params.amount);
+  const queryString = searchParams.toString();
+  return queryString ? `?${queryString}` : "";
+}
+function updateBridgeUrlNative(params) {
+  if (typeof window === "undefined" || !window.history) return;
+  const queryString = buildQueryString(params);
+  const newUrl = `${window.location.pathname}${queryString}${window.location.hash}`;
+  window.history.replaceState(null, "", newUrl);
+}
+function useUrlSync(options) {
+  const {
+    enabled = true,
+    urlParams: externalUrlParams,
+    onUrlParamsChange
+  } = options || {};
+  const { chains, fromChain, toChain, setFromChain, setToChain } = useChainsStore();
+  const { tokens, assetMatrix, selectedAssetSymbol, setSelectedAssetSymbol } = useTokensStore();
+  const { inputAmount, setInputAmount } = useBridgeQuoteStore();
+  const [hasInitialized, setHasInitialized] = react.useState(false);
+  const isSyncingRef = react.useRef(false);
+  const lastSyncedParamsRef = react.useRef({});
+  const validateParams = react.useCallback(
+    (urlParams) => {
+      const result = {};
+      if (!chains?.length || !tokens?.length || !assetMatrix) {
+        return result;
+      }
+      if (urlParams.srcToken) {
+        const token = tokens.find(
+          (t2) => t2.symbol.toUpperCase() === urlParams.srcToken?.toUpperCase()
+        );
+        if (token) {
+          result.token = token;
+        }
+      }
+      if (urlParams.srcChain) {
+        const chain2 = chains.find((c2) => c2.chainKey === urlParams.srcChain);
+        if (chain2) {
+          if (result.token) {
+            const tokenOnChain = assetMatrix[result.token.symbol.toUpperCase()]?.[chain2.chainKey];
+            if (tokenOnChain) {
+              result.srcChain = chain2;
+            }
+          } else {
+            result.srcChain = chain2;
+          }
+        }
+      }
+      if (urlParams.dstChain) {
+        const chain2 = chains.find((c2) => c2.chainKey === urlParams.dstChain);
+        if (chain2 && chain2.chainKey !== result.srcChain?.chainKey) {
+          if (result.token) {
+            const tokenOnChain = assetMatrix[result.token.symbol.toUpperCase()]?.[chain2.chainKey];
+            if (tokenOnChain) {
+              result.dstChain = chain2;
+            }
+          } else {
+            result.dstChain = chain2;
+          }
+        }
+      }
+      if (urlParams.amount) {
+        const decimalRegex = /^(\d+([.]\d*)?|[.]\d+)?$/;
+        if (decimalRegex.test(urlParams.amount)) {
+          const numValue = parseFloat(urlParams.amount);
+          if (!isNaN(numValue) && numValue > 0) {
+            result.amount = urlParams.amount;
+          }
+        }
+      }
+      return result;
+    },
+    [chains, tokens, assetMatrix]
+  );
+  const syncStateToUrl = react.useCallback(
+    (includeAmount = false) => {
+      if (!enabled || isSyncingRef.current || !hasInitialized) {
+        return;
+      }
+      isSyncingRef.current = true;
+      const normalizedAmount = inputAmount?.trim();
+      const params = {
+        srcToken: selectedAssetSymbol || void 0,
+        srcChain: fromChain?.chainKey,
+        dstChain: toChain?.chainKey,
+        amount: includeAmount ? normalizedAmount || void 0 : lastSyncedParamsRef.current.amount
+      };
+      lastSyncedParamsRef.current = params;
+      if (onUrlParamsChange) {
+        onUrlParamsChange(params);
+      } else {
+        updateBridgeUrlNative(params);
+      }
+      setTimeout(() => {
+        isSyncingRef.current = false;
+      }, 0);
+    },
+    [
+      enabled,
+      hasInitialized,
+      selectedAssetSymbol,
+      fromChain,
+      toChain,
+      inputAmount,
+      onUrlParamsChange
+    ]
+  );
+  const handleAmountBlur = react.useCallback(() => {
+    if (!enabled || !hasInitialized) return;
+    syncStateToUrl(true);
+  }, [enabled, hasInitialized, syncStateToUrl]);
+  react.useEffect(() => {
+    if (!enabled || !chains?.length || !tokens?.length) {
+      return;
+    }
+    const urlParams = externalUrlParams ? parseBridgeUrlParams(externalUrlParams) : parseBridgeUrlParams();
+    if (!urlParams.srcToken && !urlParams.srcChain && !urlParams.dstChain && !urlParams.amount) {
+      setHasInitialized(true);
+      return;
+    }
+    const validated = validateParams(urlParams);
+    const timeoutId = setTimeout(() => {
+      if (validated.token) {
+        setSelectedAssetSymbol(validated.token.symbol);
+      }
+      if (validated.srcChain) {
+        setFromChain(validated.srcChain);
+      }
+      if (validated.dstChain) {
+        setToChain(validated.dstChain);
+      }
+      if (validated.amount) {
+        setInputAmount(validated.amount);
+      }
+      lastSyncedParamsRef.current = {
+        srcToken: validated.token?.symbol || void 0,
+        srcChain: validated.srcChain?.chainKey,
+        dstChain: validated.dstChain?.chainKey,
+        amount: validated.amount
+      };
+      setHasInitialized(true);
+    }, 0);
+    return () => clearTimeout(timeoutId);
+  }, [
+    enabled,
+    chains,
+    tokens,
+    externalUrlParams,
+    validateParams,
+    setSelectedAssetSymbol,
+    setFromChain,
+    setToChain,
+    setInputAmount
+  ]);
+  react.useEffect(() => {
+    if (!enabled || !hasInitialized) return;
+    syncStateToUrl(false);
+  }, [
+    enabled,
+    hasInitialized,
+    fromChain?.chainKey,
+    toChain?.chainKey,
+    selectedAssetSymbol,
+    syncStateToUrl
+  ]);
+  return {
+    handleAmountBlur
+  };
+}
 const EvaaBridgeWithProviders = (props) => {
   const [tonConnectUI] = uiReact.useTonConnectUI();
   const tonAddress = uiReact.useTonAddress();
@@ -25847,7 +26234,7 @@ const EvaaBridgeWithProviders = (props) => {
     connect: tronConnect,
     disconnect: tronDisconnect
   } = tronwalletAdapterReactHooks.useWallet();
-  useTronWalletConnect(props.walletConnectProjectId);
+  const tronWalletConnect = useTronWalletConnect(props.walletConnectProjectId);
   const { setTonConnected, setMetaMaskConnected, setTronConnected } = useConnectedWalletsStore();
   react.useEffect(() => {
     setTonConnected(!!tonAddress);
@@ -25855,12 +26242,13 @@ const EvaaBridgeWithProviders = (props) => {
   react.useEffect(() => {
     setMetaMaskConnected(!!evmIsConnected);
   }, [evmIsConnected, setMetaMaskConnected]);
+  const isAnyTronConnected = !!tronConnected || !!tronWalletConnect.isConnected;
   react.useEffect(() => {
-    setTronConnected(!!tronConnected);
-  }, [tronConnected, setTronConnected]);
+    setTronConnected(isAnyTronConnected);
+  }, [isAnyTronConnected, setTronConnected]);
   useAutoSelectNetwork({
     tonAddress,
-    tronConnected,
+    tronConnected: isAnyTronConnected,
     evmIsConnected
   });
   return /* @__PURE__ */ jsxRuntime.jsx(BridgeI18nProvider, { defaultLanguage: props.defaultLanguage, children: /* @__PURE__ */ jsxRuntime.jsx(
@@ -25878,11 +26266,21 @@ const EvaaBridgeWithProviders = (props) => {
         address: tonAddress
       },
       tronWallet: {
-        address: tronAddress,
-        connected: tronConnected,
-        select: tronSelect,
-        connect: tronConnect,
-        disconnect: tronDisconnect
+        tronLink: {
+          address: tronAddress,
+          connected: tronConnected,
+          select: tronSelect,
+          connect: tronConnect,
+          disconnect: tronDisconnect
+        },
+        walletConnect: props.walletConnectProjectId ? {
+          address: tronWalletConnect.address,
+          connected: tronWalletConnect.isConnected,
+          connecting: tronWalletConnect.isConnecting,
+          connect: tronWalletConnect.connect,
+          disconnect: tronWalletConnect.disconnect,
+          signTransaction: tronWalletConnect.signTransaction
+        } : void 0
       },
       tonClient: props.tonClient,
       tonApiKey: props.tonApiKey,
@@ -25893,6 +26291,9 @@ const EvaaBridgeWithProviders = (props) => {
 const EvaaBridgeContent = ({
   className,
   transactionIcons,
+  enableUrlSync = true,
+  urlParams,
+  onUrlParamsChange,
   onInitialized,
   onAmountChange,
   onChainChange
@@ -25901,6 +26302,11 @@ const EvaaBridgeContent = ({
   useTokens();
   useChains();
   const swap = useSwapModel();
+  const { handleAmountBlur } = useUrlSync({
+    enabled: enableUrlSync,
+    urlParams,
+    onUrlParamsChange
+  });
   const { fromChain, toChain } = swap;
   const { selectedAssetSymbol, assetMatrix } = useTokensStore();
   const { quote } = useBridgeQuoteStore();
@@ -26010,6 +26416,7 @@ const EvaaBridgeContent = ({
                 amount,
                 isSource: true,
                 onAmountChange: handleAmountChange,
+                onAmountBlur: handleAmountBlur,
                 onSelect: handleFromChainChange
               }
             ),
@@ -26157,4 +26564,4 @@ exports.useSettingsStore = useSettingsStore;
 exports.useSwapModel = useSwapModel;
 exports.useTokensStore = useTokensStore;
 exports.useTransactionStore = useTransactionStore;
-//# sourceMappingURL=index-C0llk2Pm.cjs.map
+//# sourceMappingURL=index-BXUBhn_o.cjs.map