@openfort/react 0.0.4 → 0.0.5

package/build/components/Openfort/OpenfortProvider.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
+import { SDKOverrides, ThirdPartyAuthConfiguration } from '@openfort/openfort-js';
 import { useConnectCallbackProps } from '../../hooks/useConnectCallback';
 import { ContextValue } from './context';
 import { ConnectUIOptions, OpenfortWalletConfig } from './types';
@@ -8,6 +9,8 @@ type OpenfortProviderProps = {
     publishableKey: string;
     uiConfig?: ConnectUIOptions;
     walletConfig?: OpenfortWalletConfig;
+    overrides?: SDKOverrides;
+    thirdPartyAuth?: ThirdPartyAuthConfiguration;
 } & useConnectCallbackProps;
 /**
  * OpenfortProvider component provides context and configuration for Openfort.
@@ -24,5 +27,5 @@ type OpenfortProviderProps = {
  * @param {OpenfortOptions} [openfortOptions] - Options for Openfort integration.
  * @throws Will throw an error if used outside of a WagmiProvider or if nested usages are detected.
  */
-export declare const OpenfortProvider: ({ children, uiConfig, onConnect, onDisconnect, debugMode, publishableKey, walletConfig, }: OpenfortProviderProps) => React.FunctionComponentElement<React.ProviderProps<ContextValue | null>>;
+export declare const OpenfortProvider: ({ children, uiConfig, onConnect, onDisconnect, debugMode, publishableKey, walletConfig, overrides, thirdPartyAuth, }: OpenfortProviderProps) => React.FunctionComponentElement<React.ProviderProps<ContextValue | null>>;
 export {};

package/build/components/Openfort/context.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import { CustomTheme, Languages, Mode, Theme } from '../../types';
-import { OAuthProvider } from '@openfort/openfort-js';
+import { OAuthProvider, SDKOverrides, ThirdPartyAuthConfiguration } from '@openfort/openfort-js';
 import { ValueOf } from 'viem/_types/types/utils';
 import { useConnectCallbackProps } from '../../hooks/useConnectCallback';
 import { OpenfortUIOptionsExtended, OpenfortWalletConfig, routes } from './types';
@@ -33,6 +33,8 @@ export type ContextValue = {
     triggerResize: () => void;
     uiConfig?: OpenfortUIOptionsExtended;
     walletConfig?: OpenfortWalletConfig;
+    overrides?: SDKOverrides;
+    thirdPartyAuth?: ThirdPartyAuthConfiguration;
 } & useConnectCallbackProps;
 export declare const Openfortcontext: React.Context<ContextValue | null>;
 export {};

package/build/components/Openfort/types.d.ts

@@ -1,6 +1,6 @@
 import React, { ReactNode } from 'react';
 import { CustomAvatarProps, CustomTheme, Languages, Mode, Theme } from '../../types';
-import { RecoveryMethod } from '@openfort/openfort-js';
+import { AccountTypeEnum, RecoveryMethod } from '@openfort/openfort-js';
 import { CoreOpenfortProviderProps } from '../../openfort/CoreOpenfortProvider';
 export declare const routes: {
     readonly PROVIDERS: "providers";
@@ -35,6 +35,7 @@ type CommonWalletConfig = {
     shieldPublishableKey: string;
     /** Policy ID (pol_...) for the embedded signer */
     ethereumProviderPolicyId?: string;
+    accountType?: AccountTypeEnum;
     debug?: boolean;
 };
 type EncryptionSession = {
@@ -77,13 +78,15 @@ type PasswordRecoveryWalletConfig = {
  * - `getEncryptionSession.` as a function that returns a promise.
  */
 export type OpenfortWalletConfig = CommonWalletConfig & (AutomaticRecoveryWalletConfig | PasswordRecoveryWalletConfig);
-export type OpenfortOptions = {
+export type OpenfortUIOptions = {
     linkWalletOnSignUp?: boolean;
     authProviders?: AuthProvider[];
     skipEmailVerification?: boolean;
     termsOfServiceUrl?: string;
     privacyPolicyUrl?: string;
     logo?: React.ReactNode;
+};
+export type OpenfortSDKOptions = {
     overrides?: CoreOpenfortProviderProps['overrides'];
 };
 export type ConnectUIOptions = {
@@ -106,7 +109,7 @@ export type ConnectUIOptions = {
     initialChainId?: number;
     enforceSupportedChains?: boolean;
     overlayBlur?: number;
-} & OpenfortOptions;
+} & OpenfortUIOptions;
 export type OpenfortUIOptionsExtended = {
     theme: Theme;
     mode: Mode;
@@ -132,5 +135,5 @@ export type OpenfortUIOptionsExtended = {
     walletOnboardingUrl?: string;
     disableSiweRedirect?: boolean;
     overlayBlur?: number;
-} & OpenfortOptions;
+} & OpenfortUIOptions;
 export {};

package/build/hooks/openfort/auth/useSignOut.d.ts

@@ -1,6 +1,6 @@
 import { OpenfortHookOptions, OpenfortError } from '../../../types';
 export declare function useSignOut(hookOptions?: OpenfortHookOptions): {
-    signOut: (options?: OpenfortHookOptions) => Promise<{} | undefined>;
+    signOut: (options?: OpenfortHookOptions) => Promise<{}>;
     isLoading: boolean;
     isError: boolean;
     isSuccess: boolean;

package/build/hooks/openfort/useWallets.d.ts

@@ -1,10 +1,10 @@
-import { RecoveryMethod } from "@openfort/openfort-js";
+import { AccountTypeEnum, RecoveryParams } from "@openfort/openfort-js";
 import { Hex } from "viem";
 import { Connector } from "wagmi";
 import { embeddedWalletId } from "../../constants/openfort";
 import { OpenfortError, OpenfortHookOptions } from "../../types";
 export type UserWallet = {
-    address?: Hex;
+    address: Hex;
     connectorType?: string;
     walletClientType?: string;
     connector?: Connector;
@@ -31,11 +31,12 @@ type SetActiveWalletOptions = ({
 type CreateWalletResult = SetActiveWalletResult;
 type CreateWalletOptions = {
     password?: string;
+    accountType?: AccountTypeEnum;
 } & OpenfortHookOptions<CreateWalletResult>;
 type RecoverEmbeddedWalletResult = SetActiveWalletResult;
 type SetRecoveryOptions = {
-    recoveryMethod: RecoveryMethod;
-    recoveryPassword?: string;
+    previousRecovery: RecoveryParams;
+    newRecovery: RecoveryParams;
 } & OpenfortHookOptions<CreateWalletResult>;
 type WalletOptions = OpenfortHookOptions<SetActiveWalletResult | CreateWalletResult>;
 export declare function useWallets(hookOptions?: WalletOptions): {
@@ -45,15 +46,14 @@ export declare function useWallets(hookOptions?: WalletOptions): {
     isSuccess: boolean;
     isCreating: boolean;
     isConnecting: boolean;
+    hasWallet: boolean;
+    isLoadingWallets: boolean;
     wallets: UserWallet[];
     availableWallets: import("../../wallets/useWallets").WalletProps[];
     activeWallet: UserWallet | undefined;
     setRecovery: (params: SetRecoveryOptions) => Promise<RecoverEmbeddedWalletResult>;
-    createWallet: ({ password, ...options }?: CreateWalletOptions) => Promise<{
-        error: OpenfortError;
-    } | {
-        wallet: UserWallet;
-    }>;
+    reset: () => void;
+    createWallet: ({ password, ...options }?: CreateWalletOptions) => Promise<CreateWalletResult>;
     setActiveWallet: (options: SetActiveWalletOptions | string) => Promise<SetActiveWalletResult>;
 };
 export {};

package/build/index.d.ts

@@ -4,7 +4,6 @@ export { default as getDefaultConfig } from './defaultConfig';
 export { default as getDefaultConnectors } from './defaultConnectors';
 export { wallets } from './wallets';
 export { AuthProvider, } from './components/Openfort/types';
-export { Openfortcontext, } from './components/Openfort/context';
 export { OpenfortProvider, } from './components/Openfort/OpenfortProvider';
 export { OpenfortButton } from './components/ConnectButton';
 export { default as Avatar } from './components/Common/Avatar';

package/build/index.es.js

@@ -1,12 +1,12 @@
+import { Openfort as Openfort$1, RecoveryMethod, EmbeddedState, AuthActionRequiredActions, OAuthProvider, MissingRecoveryPasswordError, AccountTypeEnum, ChainTypeEnum } from '@openfort/openfort-js';
+export { RecoveryMethod, ThirdPartyOAuthProvider } from '@openfort/openfort-js';
 import { http, useConfig, useConnectors as useConnectors$1, useConnect as useConnect$1, useAccount, useDisconnect, useSwitchChain, createConfig, useEnsAddress, useEnsName, useEnsAvatar, useBalance, useChainId, WagmiContext, useBlockNumber } from 'wagmi';
 import { mainnet, polygon, optimism, arbitrum, sepolia } from 'wagmi/chains';
 import { safe, injected, coinbaseWallet, walletConnect } from '@wagmi/connectors';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
-import React, { createContext, useEffect, useState, useMemo, useRef, useCallback, createElement, useLayoutEffect } from 'react';
+import React, { useEffect, createContext, useState, useMemo, useRef, useCallback, createElement, useLayoutEffect } from 'react';
 import { detect } from 'detect-browser';
 import { Buffer } from 'buffer';
-import { Openfort as Openfort$1, RecoveryMethod, EmbeddedState, AuthActionRequiredActions, OAuthProvider, ShieldAuthType, MissingRecoveryPasswordError, AccountTypeEnum, ChainTypeEnum } from '@openfort/openfort-js';
-export { RecoveryMethod } from '@openfort/openfort-js';
 import { polygonAmoy } from 'viem/chains';
 import { motion, AnimatePresence, MotionConfig } from 'framer-motion';
 import styled$1, { css, keyframes } from 'styled-components';
@@ -22,12 +22,13 @@ import { createSiweMessage } from 'viem/siwe';
 import { signMessage } from '@wagmi/core';
 import { useQuery, useQueryClient } from '@tanstack/react-query';
 
-const OPENFORT_VERSION = '0.0.4';
+const OPENFORT_VERSION = '0.0.5';
 
 var OpenfortErrorType;
 (function (OpenfortErrorType) {
     OpenfortErrorType["AUTHENTICATION_ERROR"] = "AUTHENTICATION_ERROR";
     OpenfortErrorType["WALLET_ERROR"] = "WALLET_ERROR";
+    OpenfortErrorType["CONFIGURATION_ERROR"] = "CONFIGURATION_ERROR";
 })(OpenfortErrorType || (OpenfortErrorType = {}));
 class OpenfortError extends Error {
     constructor(message, type, data) {
@@ -788,8 +789,6 @@ const socialProviders = [
     AuthProvider.FACEBOOK,
 ];
 
-const Openfortcontext = createContext(null);
-
 function useChainIsSupported(chainId) {
     const { chains } = useConfig();
     if (!chainId)
@@ -868,6 +867,8 @@ function useThemeFont(theme) {
     useGoogleFont(font !== null && font !== void 0 ? font : '');
 }
 
+const Openfortcontext = createContext(null);
+
 const useOpenfort = () => {
     const context = React.useContext(Openfortcontext);
     if (!context)
@@ -974,14 +975,8 @@ const useConnectCallback = ({ onConnect, onDisconnect, }) => {
  *
  * const token = await client.getAccessToken();
  */
-function createOpenfortClient({ baseConfiguration, overrides, shieldConfiguration, }) {
-    return new Openfort$1({
-        baseConfiguration,
-        overrides: {
-            ...overrides,
-        },
-        shieldConfiguration
-    });
+function createOpenfortClient(config) {
+    return new Openfort$1(config);
 }
 
 const ConnectCallback = ({ onConnect, onDisconnect }) => {
@@ -1001,7 +996,7 @@ const CoreOpenfortProvider = ({ children, debugMode, onConnect, onDisconnect, ..
     const automaticRecovery = walletConfig && walletConfig.recoveryMethod === RecoveryMethod.AUTOMATIC;
     // ---- Openfort instance ----
     const openfort = useMemo(() => {
-        log('Creating Openfort instance.');
+        log('Creating Openfort instance.', openfortProps);
         if (!openfortProps.baseConfiguration.publishableKey)
             throw Error('CoreOpenfortProvider requires a publishableKey to be set in the baseConfiguration.');
         const newClient = createOpenfortClient(openfortProps);
@@ -1054,6 +1049,7 @@ const CoreOpenfortProvider = ({ children, debugMode, onConnect, onDisconnect, ..
         var _a, _b;
         if (!openfort)
             return null;
+        log("Updating user", { user, logoutOnError });
         if (user) {
             setUser(user);
             return user;
@@ -1113,11 +1109,20 @@ const CoreOpenfortProvider = ({ children, debugMode, onConnect, onDisconnect, ..
                 setIsConnectedWithEmbeddedSigner(false);
                 break;
             case EmbeddedState.READY:
-                if (!user)
-                    updateUser(undefined, true);
-                // We cannot stop polling here because there is a bug on openfort-js
-                // that makes the embedded state to be stuck on CREATING_ACCOUNT
-                // stopPollingEmbeddedState();
+                (async () => {
+                    for (let i = 0; i < 5; i++) {
+                        log("Trying to update user...", i);
+                        try {
+                            const user = await updateUser(undefined, true);
+                            if (user)
+                                break;
+                        }
+                        catch (err) {
+                            console.error("Error updating user, retrying...", err);
+                        }
+                        await new Promise((resolve) => setTimeout(resolve, 250));
+                    }
+                })();
                 break;
             default:
                 throw new Error(`Unknown embedded state: ${embeddedState}`);
@@ -9201,7 +9206,7 @@ var Wallet = ({ ...props }) => {
 
 function useProviders() {
     const { user } = useOpenfortCore();
-    const { uiConfig: options } = useOpenfort();
+    const { uiConfig: options, thirdPartyAuth, setOpen } = useOpenfort();
     const allProviders = (options === null || options === void 0 ? void 0 : options.authProviders) || [];
     const providers = allProviders.filter(p => p !== AuthProvider.GUEST) || [];
     const linkedProviders = user ? providers.filter(p => { var _a; return (_a = user.linkedAccounts) === null || _a === void 0 ? void 0 : _a.find(a => a.provider === p); }) : [];
@@ -9213,6 +9218,12 @@ function useProviders() {
             return !((_a = user.linkedAccounts) === null || _a === void 0 ? void 0 : _a.find(a => a.provider === provider));
         })
         : providers;
+    useEffect(() => {
+        if (thirdPartyAuth) {
+            setOpen(false);
+            console.error(new OpenfortError('When using external third party auth providers, openfort Auth providers are not available. Either remove the `thirdPartyAuth` or authenticate your users using Auth hooks.', OpenfortErrorType.CONFIGURATION_ERROR));
+        }
+    }, []);
     return {
         availableProviders,
         linkedProviders,
@@ -10480,14 +10491,14 @@ const EmailLogin = () => {
             setLoginLoading(false);
             setLoginError("Invalid email or password.");
         }).then((user) => {
-            // console.log("User", user);
+            // log("User", user);
             if (!user) {
                 setLoginLoading(false);
                 setLoginError("Invalid email or password.");
                 return;
             }
             if ("action" in user && user.action === AuthActionRequiredActions.ACTION_VERIFY_EMAIL) {
-                console.log("User needs to verify email");
+                log("User needs to verify email");
                 localStorage.setItem(emailToVerifyLocalStorageKey, email);
                 setRoute(routes.EMAIL_VERIFICATION);
             }
@@ -10959,6 +10970,56 @@ const onError = ({ hookOptions, options, error, }) => {
     return { error };
 };
 
+var OpenfortStatus;
+(function (OpenfortStatus) {
+    OpenfortStatus[OpenfortStatus["DISCONNECTED"] = 0] = "DISCONNECTED";
+    OpenfortStatus[OpenfortStatus["NEEDS_RECOVERY"] = 1] = "NEEDS_RECOVERY";
+    OpenfortStatus[OpenfortStatus["LOADING"] = 2] = "LOADING";
+    OpenfortStatus[OpenfortStatus["CONNECTED"] = 3] = "CONNECTED";
+})(OpenfortStatus || (OpenfortStatus = {}));
+function useStatus() {
+    const { embeddedState } = useOpenfortCore();
+    const { isConnected, isConnecting } = useAccount();
+    const getStatus = () => {
+        if (embeddedState === EmbeddedState.READY)
+            return OpenfortStatus.CONNECTED;
+        if (embeddedState === EmbeddedState.NONE)
+            return OpenfortStatus.LOADING;
+        // if (needsRecovery) return OpenfortStatus.NEEDS_RECOVERY;
+        if (embeddedState === EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED) {
+            if (isConnected)
+                return OpenfortStatus.CONNECTED;
+            else
+                return OpenfortStatus.NEEDS_RECOVERY;
+        }
+        return OpenfortStatus.DISCONNECTED;
+    };
+    const status = getStatus();
+    return {
+        isLoading: status === OpenfortStatus.LOADING,
+        isConnected: status === OpenfortStatus.CONNECTED,
+        isDisconnected: status === OpenfortStatus.DISCONNECTED,
+        isConnecting: isConnecting || embeddedState === EmbeddedState.CREATING_ACCOUNT,
+        isAuthenticated: embeddedState !== EmbeddedState.NONE && embeddedState !== EmbeddedState.UNAUTHENTICATED,
+    };
+}
+
+function useUser() {
+    const { user, client } = useOpenfortCore();
+    const { isAuthenticated } = useStatus();
+    const getAccessTokenAndUpdate = useCallback(async () => {
+        await client.validateAndRefreshToken();
+        const token = await client.getAccessToken();
+        return token;
+    }, [client]);
+    return {
+        user,
+        isAuthenticated,
+        getAccessToken: getAccessTokenAndUpdate,
+        validateAndRefreshToken: async () => await client.validateAndRefreshToken(),
+    };
+}
+
 const createOpenfortWallet = ({ address, }) => ({
     connectorType: "embedded",
     walletClientType: "openfort",
@@ -10976,7 +11037,8 @@ const mapWalletStatus = (status) => {
     };
 };
 function useWallets(hookOptions = {}) {
-    const { user, embeddedState, client } = useOpenfortCore();
+    const { client } = useOpenfortCore();
+    const { user } = useUser();
     const { walletConfig, log, setOpen, setRoute, setConnector, uiConfig } = useOpenfort();
     const { connector, isConnected, address } = useAccount();
     const chainId = useChainId();
@@ -11017,14 +11079,16 @@ function useWallets(hookOptions = {}) {
             }
         }
     });
-    const { data: embeddedWallets, refetch } = useQuery({
+    // will reset on logout
+    const { data: embeddedWallets, refetch, isPending: isLoadingWallets } = useQuery({
         queryKey: ['openfortEmbeddedWalletList'],
-        queryFn: () => !!user ? client.embeddedWallet.list() : Promise.resolve([]),
+        queryFn: () => client.embeddedWallet.list(),
+        refetchOnMount: false,
+        refetchOnWindowFocus: false,
     });
-    useEffect(() => {
-        log("Refetching embedded wallets");
-        refetch();
-    }, [!!user, refetch]);
+    // useEffect(() => {
+    //   queryClient.resetQueries({ queryKey: ['openfortEmbeddedWalletList'] })
+    // }, [!!user, refetch]);
     const getEncryptionSession = useCallback(async () => {
         if (!walletConfig || !walletConfig.createEncryptedSessionEndpoint) {
             throw new Error("No createEncryptedSessionEndpoint set in walletConfig");
@@ -11065,9 +11129,8 @@ function useWallets(hookOptions = {}) {
         return userWallets;
     }, [user === null || user === void 0 ? void 0 : user.linkedAccounts, embeddedWallets]);
     const wallets = useMemo(() => {
-        if (!isConnected || !address)
-            return rawWallets;
-        console.log("Mapping wallets", { rawWallets, status, address, isConnected, connector });
+        // if (!isConnected || !address) return rawWallets;
+        log("Mapping wallets", { rawWallets, status, address, isConnected, connector });
         return rawWallets.map((w) => ({
             ...w,
             isConnecting: status.status === 'connecting' && status.address === w.address,
@@ -11148,34 +11211,22 @@ function useWallets(hookOptions = {}) {
             }
             log(`Handling recovery with Openfort: ${password ? "with password" : "without password"}, chainId=${chainId}`);
             try {
-                const accessToken = await client.getAccessToken();
-                if (!accessToken) {
-                    throw new Error("Openfort access token not found");
-                }
-                log("Access token");
-                const shieldAuthentication = password ? {
-                    auth: ShieldAuthType.OPENFORT,
-                    token: accessToken,
-                } : {
-                    auth: ShieldAuthType.OPENFORT,
-                    token: accessToken,
-                    encryptionSession: walletConfig.getEncryptionSession ?
-                        await walletConfig.getEncryptionSession() :
-                        await getEncryptionSession(),
-                };
-                log("Shield authentication");
                 const recoveryParams = password ? {
                     recoveryMethod: RecoveryMethod.PASSWORD,
                     password,
                 } : {
                     recoveryMethod: RecoveryMethod.AUTOMATIC,
+                    encryptionSession: walletConfig.getEncryptionSession ?
+                        await walletConfig.getEncryptionSession() :
+                        await getEncryptionSession()
                 };
                 // Ensure that the embedded wallet is listed
                 const embeddedWallets = await client.embeddedWallet.list();
                 log("Recovery params", optionsObject.address);
                 log("Embedded wallets", embeddedWallets, chainId);
-                if (optionsObject.address) {
-                    const walletId = (_a = embeddedWallets === null || embeddedWallets === void 0 ? void 0 : embeddedWallets.find((w) => w.address === optionsObject.address && w.chainId === chainId)) === null || _a === void 0 ? void 0 : _a.id;
+                let walletAddress = optionsObject.address;
+                if (walletAddress) {
+                    const walletId = (_a = embeddedWallets === null || embeddedWallets === void 0 ? void 0 : embeddedWallets.find((w) => w.address === walletAddress && w.chainId === chainId)) === null || _a === void 0 ? void 0 : _a.id;
                     if (!walletId) {
                         return onError({
                             error: new OpenfortError("Embedded wallet not found for address", OpenfortErrorType.WALLET_ERROR),
@@ -11185,23 +11236,27 @@ function useWallets(hookOptions = {}) {
                     }
                     await client.embeddedWallet.recover({
                         account: walletId,
-                        shieldAuthentication,
                         recoveryParams,
                     });
                 }
                 else {
                     // Check if the embedded wallet is already created in the current chain
                     if (embeddedWallets.some((w) => w.chainId === chainId)) {
+                        const walletToRecover = embeddedWallets.find((w) => w.chainId === chainId);
                         await client.embeddedWallet.recover({
-                            account: embeddedWallets[0].id,
-                            shieldAuthentication,
+                            account: walletToRecover.id,
                             recoveryParams,
                         });
+                        walletAddress = walletToRecover.address;
                     }
                     else {
-                        await createWallet({
+                        const wallet = await createWallet({
                             password,
                         });
+                        if (!wallet.wallet) {
+                            return { error: wallet.error || new OpenfortError("Failed to create embedded wallet", OpenfortErrorType.WALLET_ERROR) };
+                        }
+                        walletAddress = wallet.wallet.address;
                     }
                 }
                 setStatus({
@@ -11210,7 +11265,7 @@ function useWallets(hookOptions = {}) {
                 return onSuccess({
                     data: {
                         wallet: createOpenfortWallet({
-                            address: optionsObject.address,
+                            address: walletAddress,
                         }),
                     },
                     options: optionsObject,
@@ -11220,25 +11275,36 @@ function useWallets(hookOptions = {}) {
             catch (err) {
                 log('Error handling recovery with Openfort:', err);
                 if (err instanceof MissingRecoveryPasswordError) {
+                    const error = new OpenfortError("Missing recovery password", OpenfortErrorType.WALLET_ERROR);
+                    setStatus({
+                        status: 'error',
+                        error,
+                    });
                     return onError({
-                        error: new OpenfortError("Missing recovery password", OpenfortErrorType.WALLET_ERROR),
+                        error,
                         options: optionsObject,
                         hookOptions
                     });
                 }
                 if (typeof err === 'string') {
+                    const error = new OpenfortError(err, OpenfortErrorType.WALLET_ERROR);
+                    setStatus({
+                        status: 'error',
+                        error,
+                    });
                     return onError({
-                        error: new OpenfortError(err, OpenfortErrorType.WALLET_ERROR),
+                        error,
                         options: optionsObject,
                         hookOptions
                     });
                 }
-                // setStatus({
-                //   status: 'error',
-                //   error: new Error("Failed to connect with embedded wallet: " + err),
-                // });
+                const error = new OpenfortError("The recovery phrase you entered is incorrect.", OpenfortErrorType.WALLET_ERROR);
+                setStatus({
+                    status: 'error',
+                    error,
+                });
                 return onError({
-                    error: new OpenfortError("The recovery phrase you entered is incorrect.", OpenfortErrorType.WALLET_ERROR),
+                    error,
                     options: optionsObject,
                     hookOptions
                 });
@@ -11262,52 +11328,62 @@ function useWallets(hookOptions = {}) {
             status: 'creating',
         });
         log("Creating wallet", { password: !!password, options });
-        const accessToken = await client.getAccessToken();
-        if (!accessToken) {
-            return onError({
-                error: new OpenfortError("Openfort access token not found", OpenfortErrorType.WALLET_ERROR),
-                hookOptions,
-                options,
+        try {
+            const accessToken = await client.getAccessToken();
+            if (!accessToken) {
+                return onError({
+                    error: new OpenfortError("Openfort access token not found", OpenfortErrorType.WALLET_ERROR),
+                    hookOptions,
+                    options,
+                });
+            }
+            if (!walletConfig) {
+                return onError({
+                    error: new OpenfortError("Embedded signer not enabled", OpenfortErrorType.WALLET_ERROR),
+                    hookOptions,
+                    options,
+                });
+            }
+            const recoveryParams = password ? {
+                recoveryMethod: RecoveryMethod.PASSWORD,
+                password,
+            } : {
+                recoveryMethod: RecoveryMethod.AUTOMATIC,
+                encryptionSession: walletConfig.getEncryptionSession ?
+                    await walletConfig.getEncryptionSession() :
+                    await getEncryptionSession()
+            };
+            const wallet = await client.embeddedWallet.create({
+                chainId: (_a = uiConfig === null || uiConfig === void 0 ? void 0 : uiConfig.initialChainId) !== null && _a !== void 0 ? _a : chainId,
+                accountType: (options === null || options === void 0 ? void 0 : options.accountType) || (walletConfig === null || walletConfig === void 0 ? void 0 : walletConfig.accountType) || AccountTypeEnum.SMART_ACCOUNT,
+                chainType: ChainTypeEnum.EVM,
+                recoveryParams,
+            });
+            setStatus({
+                status: 'success',
+            });
+            refetch();
+            return onSuccess({
+                data: {
+                    wallet: createOpenfortWallet({
+                        address: wallet.address,
+                    })
+                }
             });
         }
-        if (!walletConfig) {
+        catch (e) {
+            const errorObj = e instanceof Error ? e : new Error('Failed to create wallet');
+            const error = new OpenfortError('Failed to create wallet', OpenfortErrorType.WALLET_ERROR, { error: errorObj });
+            setStatus({
+                status: 'error',
+                error,
+            });
             return onError({
-                error: new OpenfortError("Embedded signer not enabled", OpenfortErrorType.WALLET_ERROR),
+                error,
                 hookOptions,
                 options,
             });
         }
-        const shieldAuthentication = {
-            auth: ShieldAuthType.OPENFORT,
-            token: accessToken,
-            encryptionSession: walletConfig.getEncryptionSession ?
-                await walletConfig.getEncryptionSession() :
-                await getEncryptionSession(),
-        };
-        const recoveryParams = password ? {
-            recoveryMethod: RecoveryMethod.PASSWORD,
-            password,
-        } : {
-            recoveryMethod: RecoveryMethod.AUTOMATIC,
-        };
-        const wallet = await client.embeddedWallet.create({
-            chainId: (_a = uiConfig === null || uiConfig === void 0 ? void 0 : uiConfig.initialChainId) !== null && _a !== void 0 ? _a : chainId,
-            accountType: AccountTypeEnum.SMART_ACCOUNT,
-            chainType: ChainTypeEnum.EVM,
-            recoveryParams,
-            shieldAuthentication
-        });
-        setStatus({
-            status: 'success',
-        });
-        refetch();
-        return onSuccess({
-            data: {
-                wallet: createOpenfortWallet({
-                    address: wallet.address,
-                })
-            }
-        });
     }, [refetch, client, uiConfig, chainId]);
     const setRecovery = useCallback(async (params) => {
         try {
@@ -11315,17 +11391,7 @@ function useWallets(hookOptions = {}) {
                 status: 'loading',
             });
             // Set embedded wallet recovery method
-            if (params.recoveryMethod === 'password') {
-                await client.embeddedWallet.setEmbeddedRecovery({
-                    recoveryMethod: RecoveryMethod.PASSWORD,
-                    recoveryPassword: params.recoveryPassword
-                });
-            }
-            else {
-                await client.embeddedWallet.setEmbeddedRecovery({
-                    recoveryMethod: RecoveryMethod.AUTOMATIC
-                });
-            }
+            await client.embeddedWallet.setRecoveryMethod(params.previousRecovery, params.newRecovery);
             // Get the updated embedded account
             const embeddedAccount = await client.embeddedWallet.get();
             setStatus({ status: 'success' });
@@ -11349,10 +11415,13 @@ function useWallets(hookOptions = {}) {
         }
     }, [client, setStatus, hookOptions]);
     return {
+        hasWallet: wallets.length > 0,
+        isLoadingWallets,
         wallets,
         availableWallets: deviceWallets,
         activeWallet,
         setRecovery,
+        reset: () => setStatus({ status: 'idle' }),
         createWallet,
         setActiveWallet,
         ...mapWalletStatus(status),
@@ -11623,8 +11692,8 @@ const ConnectModal = ({ mode = 'auto', theme = 'auto', customTheme = customTheme
  * @param {OpenfortOptions} [openfortOptions] - Options for Openfort integration.
  * @throws Will throw an error if used outside of a WagmiProvider or if nested usages are detected.
  */
-const OpenfortProvider = ({ children, uiConfig, onConnect, onDisconnect, debugMode = false, publishableKey, walletConfig, }) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+const OpenfortProvider = ({ children, uiConfig, onConnect, onDisconnect, debugMode = false, publishableKey, walletConfig, overrides, thirdPartyAuth, }) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     // OpenfortProvider must be within a WagmiProvider
     if (!React.useContext(WagmiContext)) {
         throw Error('OpenfortProvider must be within a WagmiProvider');
@@ -11664,7 +11733,7 @@ const OpenfortProvider = ({ children, uiConfig, onConnect, onDisconnect, debugMo
         authProviders: [],
     };
     const opts = Object.assign({}, defaultOptions, uiConfig);
-    if (((_b = opts.authProviders) === null || _b === void 0 ? void 0 : _b.length) === 0) {
+    if (!opts.authProviders || opts.authProviders.length === 0) {
         opts.authProviders = [
             AuthProvider.GUEST,
             AuthProvider.EMAIL,
@@ -11674,7 +11743,7 @@ const OpenfortProvider = ({ children, uiConfig, onConnect, onDisconnect, debugMo
     if (typeof window !== 'undefined') {
         // Buffer Polyfill, needed for bundlers that don't provide Node polyfills (e.g CRA, Vite, etc.)
         if (opts.bufferPolyfill)
-            window.Buffer = (_c = window.Buffer) !== null && _c !== void 0 ? _c : Buffer;
+            window.Buffer = (_b = window.Buffer) !== null && _b !== void 0 ? _b : Buffer;
         // Some bundlers may need `global` and `process.env` polyfills as well
         // Not implemented here to avoid unexpected behaviors, but leaving example here for future reference
         /*
@@ -11682,9 +11751,9 @@ const OpenfortProvider = ({ children, uiConfig, onConnect, onDisconnect, debugMo
          * window.process = window.process ?? { env: {} };
          */
     }
-    const [ckTheme, setTheme] = useState((_e = (_d = uiConfig === null || uiConfig === void 0 ? void 0 : uiConfig.theme) !== null && _d !== void 0 ? _d : defaultOptions.theme) !== null && _e !== void 0 ? _e : "auto");
-    const [ckMode, setMode] = useState((_g = (_f = uiConfig === null || uiConfig === void 0 ? void 0 : uiConfig.mode) !== null && _f !== void 0 ? _f : defaultOptions.mode) !== null && _g !== void 0 ? _g : 'auto');
-    const [ckCustomTheme, setCustomTheme] = useState((_h = uiConfig === null || uiConfig === void 0 ? void 0 : uiConfig.customTheme) !== null && _h !== void 0 ? _h : {});
+    const [ckTheme, setTheme] = useState((_d = (_c = uiConfig === null || uiConfig === void 0 ? void 0 : uiConfig.theme) !== null && _c !== void 0 ? _c : defaultOptions.theme) !== null && _d !== void 0 ? _d : "auto");
+    const [ckMode, setMode] = useState((_f = (_e = uiConfig === null || uiConfig === void 0 ? void 0 : uiConfig.mode) !== null && _e !== void 0 ? _e : defaultOptions.mode) !== null && _f !== void 0 ? _f : 'auto');
+    const [ckCustomTheme, setCustomTheme] = useState((_g = uiConfig === null || uiConfig === void 0 ? void 0 : uiConfig.customTheme) !== null && _g !== void 0 ? _g : {});
     const [ckLang, setLang] = useState('en-US');
     const [open, setOpen] = useState(false);
     const [connector, setConnector] = useState({
@@ -11733,6 +11802,7 @@ const OpenfortProvider = ({ children, uiConfig, onConnect, onDisconnect, debugMo
         connector,
         setConnector,
         onConnect,
+        onDisconnect,
         // Other configuration
         uiConfig: opts,
         errorMessage,
@@ -11749,6 +11819,8 @@ const OpenfortProvider = ({ children, uiConfig, onConnect, onDisconnect, debugMo
         resize,
         triggerResize: () => onResize((prev) => prev + 1),
         walletConfig,
+        overrides,
+        thirdPartyAuth,
     };
     return createElement(Openfortcontext.Provider, { value }, jsx(Fragment, { children: jsx(Web3ContextProvider, { enabled: open, children: jsxs(CoreOpenfortProvider, { baseConfiguration: {
                     publishableKey,
@@ -11756,7 +11828,7 @@ const OpenfortProvider = ({ children, uiConfig, onConnect, onDisconnect, debugMo
                     shieldPublishableKey: walletConfig.shieldPublishableKey,
                     shieldEncryptionKey: walletConfig.recoveryMethod === RecoveryMethod.PASSWORD ? walletConfig.shieldEncryptionKey : undefined,
                     debug: debugMode,
-                } : undefined, overrides: opts.overrides, debugMode: debugMode, onConnect: onConnect, onDisconnect: onDisconnect, children: [children, jsx(ConnectModal, { lang: ckLang, theme: ckTheme, mode: (_j = uiConfig === null || uiConfig === void 0 ? void 0 : uiConfig.mode) !== null && _j !== void 0 ? _j : ckMode, customTheme: ckCustomTheme })] }) }) }));
+                } : undefined, overrides: overrides, thirdPartyAuth: thirdPartyAuth, debugMode: debugMode, onConnect: onConnect, onDisconnect: onDisconnect, children: [children, jsx(ConnectModal, { lang: ckLang, theme: ckTheme, mode: (_h = uiConfig === null || uiConfig === void 0 ? void 0 : uiConfig.mode) !== null && _h !== void 0 ? _h : ckMode, customTheme: ckCustomTheme })] }) }) }));
 };
 
 const Container$1 = styled(motion.div) `
@@ -12270,56 +12342,6 @@ onClick, }) {
 }
 OpenfortButton.Custom = ConnectButtonRenderer;
 
-var OpenfortStatus;
-(function (OpenfortStatus) {
-    OpenfortStatus[OpenfortStatus["DISCONNECTED"] = 0] = "DISCONNECTED";
-    OpenfortStatus[OpenfortStatus["NEEDS_RECOVERY"] = 1] = "NEEDS_RECOVERY";
-    OpenfortStatus[OpenfortStatus["LOADING"] = 2] = "LOADING";
-    OpenfortStatus[OpenfortStatus["CONNECTED"] = 3] = "CONNECTED";
-})(OpenfortStatus || (OpenfortStatus = {}));
-function useStatus() {
-    const { embeddedState } = useOpenfortCore();
-    const { isConnected, isConnecting } = useAccount();
-    const getStatus = () => {
-        if (embeddedState === EmbeddedState.READY)
-            return OpenfortStatus.CONNECTED;
-        if (embeddedState === EmbeddedState.NONE)
-            return OpenfortStatus.LOADING;
-        // if (needsRecovery) return OpenfortStatus.NEEDS_RECOVERY;
-        if (embeddedState === EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED) {
-            if (isConnected)
-                return OpenfortStatus.CONNECTED;
-            else
-                return OpenfortStatus.NEEDS_RECOVERY;
-        }
-        return OpenfortStatus.DISCONNECTED;
-    };
-    const status = getStatus();
-    return {
-        isLoading: status === OpenfortStatus.LOADING,
-        isConnected: status === OpenfortStatus.CONNECTED,
-        isDisconnected: status === OpenfortStatus.DISCONNECTED,
-        isConnecting: isConnecting || embeddedState === EmbeddedState.CREATING_ACCOUNT,
-        isAuthenticated: embeddedState !== EmbeddedState.NONE && embeddedState !== EmbeddedState.UNAUTHENTICATED,
-    };
-}
-
-function useUser() {
-    const { user, client } = useOpenfortCore();
-    const { isAuthenticated } = useStatus();
-    const getAccessTokenAndUpdate = useCallback(async () => {
-        await client.validateAndRefreshToken();
-        const token = await client.getAccessToken();
-        return token;
-    }, [client]);
-    return {
-        user,
-        isAuthenticated,
-        getAccessToken: getAccessTokenAndUpdate,
-        validateAndRefreshToken: async () => await client.validateAndRefreshToken(),
-    };
-}
-
 function useWallet() {
     const { activeWallet } = useWallets();
     return activeWallet;
@@ -12352,14 +12374,14 @@ function useSignOut(hookOptions = {}) {
         status: "idle",
     });
     const { disconnect } = useDisconnect();
+    const queryClient = useQueryClient();
     const signOut = useCallback(async (options = {}) => {
-        if (!user)
-            return;
         setStatus({
             status: 'loading',
         });
         try {
             await client.auth.logout();
+            queryClient.resetQueries({ queryKey: ['openfortEmbeddedWalletList'] });
             disconnect();
             updateUser();
             setStatus({
@@ -13218,5 +13240,5 @@ const useWalletAuth = (hookOptions = {}) => {
     };
 };
 
-export { AuthProvider, Avatar, Chain as ChainIcon, OPENFORT_VERSION, OpenfortButton, OpenfortError, OpenfortErrorType, OpenfortProvider, OpenfortStatus, Openfortcontext, embeddedWalletId, defaultConfig as getDefaultConfig, defaultConnectors as getDefaultConnectors, useAuthCallback, useChainIsSupported, useChains, useConnectWithSiwe, useEmailAuth, useGuestAuth, useOAuth, useOpenfortCore as useOpenfort, useSignOut, useStatus, useUI, useUser, useWallet, useWalletAuth, useWallets, wallets };
+export { AuthProvider, Avatar, Chain as ChainIcon, OPENFORT_VERSION, OpenfortButton, OpenfortError, OpenfortErrorType, OpenfortProvider, OpenfortStatus, embeddedWalletId, defaultConfig as getDefaultConfig, defaultConnectors as getDefaultConnectors, useAuthCallback, useChainIsSupported, useChains, useConnectWithSiwe, useEmailAuth, useGuestAuth, useOAuth, useOpenfortCore as useOpenfort, useSignOut, useStatus, useUI, useUser, useWallet, useWalletAuth, useWallets, wallets };
 //# sourceMappingURL=index.es.js.map

package/build/index.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.es.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/openfort/CoreOpenfortProvider.d.ts

@@ -1,4 +1,4 @@
-import { Openfort, AuthPlayerResponse, EmbeddedState } from '@openfort/openfort-js';
+import { AuthPlayerResponse, EmbeddedState, Openfort } from '@openfort/openfort-js';
 import React, { PropsWithChildren } from 'react';
 import { useConnectCallbackProps } from '../hooks/useConnectCallback';
 export type ContextValue = {

package/build/openfort/core/client.d.ts

@@ -11,7 +11,7 @@ import { Openfort as OpenfortClient, OpenfortSDKConfiguration } from '@openfort/
  *
  * const token = await client.getAccessToken();
  */
-export declare function createOpenfortClient({ baseConfiguration, overrides, shieldConfiguration, }: OpenfortSDKConfiguration): OpenfortClient;
+export declare function createOpenfortClient(config: OpenfortSDKConfiguration): OpenfortClient;
 /**
  * Gets or creates the default Openfort client instance
  * @internal

package/build/openfort/core/index.d.ts

@@ -1,3 +1 @@
 export { createOpenfortClient, getDefaultClient, setDefaultClient } from './client';
-export { RecoveryMethod } from '@openfort/openfort-js';
-export type { SDKOverrides } from '@openfort/openfort-js';

package/build/types.d.ts

@@ -13,7 +13,8 @@ export type { ConnectUIOptions as OpenfortOptions, OpenfortWalletConfig } from '
 export type { CustomAvatarProps } from './components/Common/Avatar';
 export declare enum OpenfortErrorType {
     AUTHENTICATION_ERROR = "AUTHENTICATION_ERROR",
-    WALLET_ERROR = "WALLET_ERROR"
+    WALLET_ERROR = "WALLET_ERROR",
+    CONFIGURATION_ERROR = "CONFIGURATION_ERROR"
 }
 interface Data {
     [key: string]: any;
@@ -31,3 +32,4 @@ export type OpenfortHookOptions<T = {
     onSettled?: (data: T | undefined | null, error: OpenfortError | null) => void;
     throwOnError?: boolean;
 };
+export { SDKOverrides, RecoveryMethod, ThirdPartyOAuthProvider, } from '@openfort/openfort-js';

package/build/version.d.ts

@@ -1 +1 @@
-export declare const OPENFORT_VERSION = "0.0.4";
+export declare const OPENFORT_VERSION = "0.0.5";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfort/react",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "author": "Openfort (https://www.openfort.io)",
   "license": "BSD-2-Clause license",
   "description": "The easiest way to integrate Openfort to your project.",
@@ -38,7 +38,7 @@
     "react"
   ],
   "dependencies": {
-    "@openfort/openfort-js": "^0.9.8",
+    "@openfort/openfort-js": "^0.10.4",
     "buffer": "^6.0.3",
     "detect-browser": "^5.3.0",
     "framer-motion": "^6.3.11",