@openfort/react 0.0.2 → 0.0.3

package/README.md

@@ -10,22 +10,18 @@
       Documentation
     </a>
     <span> | </span>
-    <a href="https://www.openfort.io/docs/reference/api/authentication">
-      API Docs
-    </a>
-    <span> | </span>
     <a href="https://x.com/openfort_hq">
       X
     </a>
-        <span> | </span>
-    <a href="https://create-next-app.openfort.xyz/">
+   <span> | </span>
+    <a href="https://playground.openfort.io/">
       Demo
     </a>
   </h4>
 </div>
 
 
-# Openfort Kit
+# Openfort React SDK
 
 [![Downloads](https://img.shields.io/npm/dm/@openfort/react.svg)](https://www.npmjs.com/package/@openfort/react)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
@@ -53,24 +49,24 @@ Get started with `create` Openfortkit + [wagmi](https://wagmi.sh/) + [viem](http
 #### npm
 
 ```sh
-npx create openfortkit
+npx create openfort
 ```
 
 #### yarn
 
 ```sh
-yarn create openfortkit
+yarn create openfort
 ```
 
 #### pnpm
 
 ```sh
-pnpm create openfortkit
+pnpm create openfort
 ```
 
-### Import `OpenfortKit` to your project
+### Import `Openfort` to your project
 
-Add OpenfortKit to your already existing project.
+Add Openfort to your already existing project.
 
 #### npm
 
@@ -90,25 +86,21 @@ yarn add @openfort/react @tanstack/react-query wagmi viem
 pnpm add @openfort/react @tanstack/react-query wagmi viem
 ```
 
-## Documentation
-
-You can find the full OpenfortKit documentation in the Family docs [here]().
-
 ## Examples
 
-There are various runnable examples included in this repository in the [examples folder](https://github.com/openfort-xyz/openfort-kit/tree/main/examples):
+There are various runnable examples included in this repository in the [examples folder](https://github.com/openfort-xyz/openfort-react/tree/main/examples):
 
-- [Create React App Example (TypeScript)](https://github.com/openfort-xyz/openfort-kit/tree/main/examples/cra)
-- [Next.js Example (TypeScript)](https://github.com/openfort-xyz/openfort-kit/tree/main/examples/nextjs)
-- [Vite Example (TypeScript)](https://github.com/openfort-xyz/openfort-kit/tree/main/examples/vite)
+- [Create React App Example (TypeScript)](https://github.com/openfort-xyz/openfort-react/tree/main/examples/cra)
+- [Next.js Example (TypeScript)](https://github.com/openfort-xyz/openfort-react/tree/main/examples/nextjs)
+- [Vite Example (TypeScript)](https://github.com/openfort-xyz/openfort-react/tree/main/examples/vite)
 
 ### Running Examples Locally
 
-Clone the FortKit project and install the necessary dependencies:
+Clone the project and install the necessary dependencies:
 
 ```sh
 $ git clone git@github.com:openfort-xyz/openfort-kit.git
-$ cd openfort-kit
+$ cd openfort
 $ yarn install
 ```
 

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

@@ -1,39 +1,24 @@
 import { OpenfortHookOptions, OpenfortError } from "../../../types";
 import { AuthProvider } from "../../../components/Openfort/types";
-import { UserWallet } from "../useWallets";
-import { type AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
-type CallbackResult = StoreCredentialsResult | EmailVerificationResult;
-type EmailVerificationResult = {
-    type: "verifyEmail";
-    email?: string;
-    error?: OpenfortError;
-};
-type StoreCredentialsResult = {
+import { CreateWalletPostAuthOptions } from "./useCreateWalletPostAuth";
+import { EmailVerificationResult } from "./useEmailAuth";
+import { StoreCredentialsResult } from "./useOAuth";
+type CallbackResult = (StoreCredentialsResult & {
     type: "storeCredentials";
-    user?: OpenfortUser;
-    wallet?: UserWallet;
-    error?: OpenfortError;
-};
-type VerifyEmailOptions = {
-    email: string;
-    state: string;
-} & OpenfortHookOptions<EmailVerificationResult>;
-type StoreCredentialsOptions = {
-    player: string;
-    accessToken: string;
-    refreshToken: string;
-} & OpenfortHookOptions<StoreCredentialsResult>;
+}) | (EmailVerificationResult & {
+    type: "verifyEmail";
+});
 type UseAuthCallbackOptions = {
-    automaticallyHandleCallback?: boolean;
-} & OpenfortHookOptions<CallbackResult>;
-export declare const useAuthCallback: ({ automaticallyHandleCallback, ...hookOptions }?: UseAuthCallbackOptions) => {
+    enabled?: boolean;
+} & OpenfortHookOptions<CallbackResult> & CreateWalletPostAuthOptions;
+export declare const useAuthCallback: ({ enabled, ...hookOptions }?: UseAuthCallbackOptions) => {
+    email: string | null;
+    provider: AuthProvider | null;
+    verifyEmail: ({ email, state, ...options }: import("./useEmailAuth").VerifyEmailOptions) => Promise<EmailVerificationResult>;
+    storeCredentials: ({ player, accessToken, refreshToken, ...options }: import("./useOAuth").StoreCredentialsOptions) => Promise<StoreCredentialsResult>;
     isLoading: boolean;
     isError: boolean;
     isSuccess: boolean;
     error: OpenfortError | null | undefined;
-    email: string | null;
-    provider: AuthProvider | null;
-    verifyEmail: ({ email, state, ...options }: VerifyEmailOptions) => Promise<EmailVerificationResult>;
-    storeCredentials: ({ player, accessToken, refreshToken, ...options }: StoreCredentialsOptions) => Promise<StoreCredentialsResult>;
 };
 export {};

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

@@ -1,5 +1,16 @@
+export type CreateWalletPostAuthOptions = {
+    /**
+     * @default true
+     * It will log out the user if there is an error while trying to create a wallet (automatic recovery).
+     */
+    logoutOnError?: boolean;
+    /**
+     *
+     */
+    automaticRecovery?: boolean;
+};
 export declare const useCreateWalletPostAuth: () => {
-    tryUseWallet: () => Promise<{
+    tryUseWallet: ({ logoutOnError: signOutOnError, automaticRecovery }: CreateWalletPostAuthOptions) => Promise<{
         error?: import("../../..").OpenfortError;
         wallet?: import("../useWallets").UserWallet;
     }>;

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

@@ -1,5 +1,6 @@
 import { type AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
 import { OpenfortHookOptions, OpenfortError } from "../../../types";
+import { CreateWalletPostAuthOptions } from './useCreateWalletPostAuth';
 import { UserWallet } from '../useWallets';
 export type EmailAuthResult = {
     error?: OpenfortError;
@@ -11,13 +12,13 @@ export type SignInEmailOptions = {
     email: string;
     password: string;
     emailVerificationRedirectTo?: string;
-} & OpenfortHookOptions<EmailAuthResult>;
+} & OpenfortHookOptions<EmailAuthResult> & CreateWalletPostAuthOptions;
 export type SignUpEmailOptions = {
     email: string;
     password: string;
     name?: string;
     emailVerificationRedirectTo?: string;
-} & OpenfortHookOptions<EmailAuthResult>;
+} & OpenfortHookOptions<EmailAuthResult> & CreateWalletPostAuthOptions;
 export type RequestResetPasswordOptions = {
     email: string;
     emailVerificationRedirectTo?: string;
@@ -32,9 +33,17 @@ export type LinkEmailOptions = {
     password: string;
     emailVerificationRedirectTo?: string;
 } & OpenfortHookOptions<EmailAuthResult>;
+export type VerifyEmailOptions = {
+    email: string;
+    state: string;
+} & OpenfortHookOptions<EmailVerificationResult>;
+export type EmailVerificationResult = {
+    email?: string;
+    error?: OpenfortError;
+};
 export type UseEmailHookOptions = {
     emailVerificationRedirectTo?: string;
-} & OpenfortHookOptions<EmailAuthResult>;
+} & OpenfortHookOptions<EmailAuthResult | EmailVerificationResult> & CreateWalletPostAuthOptions;
 export declare const useEmailAuth: (hookOptions?: UseEmailHookOptions) => {
     requiresEmailVerification: boolean;
     isAwaitingInput: boolean;
@@ -44,6 +53,7 @@ export declare const useEmailAuth: (hookOptions?: UseEmailHookOptions) => {
     error: OpenfortError | null | undefined;
     signInEmail: (options: SignInEmailOptions) => Promise<EmailAuthResult>;
     signUpEmail: (options: SignUpEmailOptions) => Promise<EmailAuthResult>;
+    verifyEmail: ({ email, state, ...options }: VerifyEmailOptions) => Promise<EmailVerificationResult>;
     linkEmail: (options: LinkEmailOptions) => Promise<EmailAuthResult>;
     requestResetPassword: (options: RequestResetPasswordOptions) => Promise<EmailAuthResult>;
     resetPassword: (options: ResetPasswordOptions) => Promise<EmailAuthResult>;

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

@@ -1,12 +1,13 @@
 import { type AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
 import { OpenfortHookOptions, OpenfortError } from "../../../types";
+import { CreateWalletPostAuthOptions } from "./useCreateWalletPostAuth";
 import { UserWallet } from "../useWallets";
 export type GuestHookResult = {
     error?: OpenfortError;
     user?: OpenfortUser;
     wallet?: UserWallet;
 };
-export type GuestHookOptions = OpenfortHookOptions<OpenfortUser>;
+export type GuestHookOptions = OpenfortHookOptions<OpenfortUser> & CreateWalletPostAuthOptions;
 export declare const useGuestAuth: (hookOptions?: GuestHookOptions) => {
     isLoading: boolean;
     isError: boolean;

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

@@ -1,15 +1,28 @@
 import { AuthProvider } from '../../../components/Openfort/types';
 import { OpenfortHookOptions, OpenfortError } from '../../../types';
+import { CreateWalletPostAuthOptions } from './useCreateWalletPostAuth';
+import { UserWallet } from "../useWallets";
+import { type AuthPlayerResponse as OpenfortUser } from '@openfort/openfort-js';
 export type InitializeOAuthOptions = {
     provider: AuthProvider;
     redirectTo?: string;
 } & OpenfortHookOptions;
-export type AuthHookOptions = {
-    redirectTo?: string;
-} & OpenfortHookOptions;
 export type InitOAuthReturnType = {
     error?: OpenfortError;
 };
+export type StoreCredentialsResult = {
+    user?: OpenfortUser;
+    wallet?: UserWallet;
+    error?: OpenfortError;
+};
+export type StoreCredentialsOptions = {
+    player: string;
+    accessToken: string;
+    refreshToken: string;
+} & OpenfortHookOptions<StoreCredentialsResult> & CreateWalletPostAuthOptions;
+export type AuthHookOptions = {
+    redirectTo?: string;
+} & OpenfortHookOptions<StoreCredentialsResult> & CreateWalletPostAuthOptions;
 export declare const useOAuth: (hookOptions?: AuthHookOptions) => {
     isLoading: boolean;
     isError: boolean;
@@ -17,4 +30,5 @@ export declare const useOAuth: (hookOptions?: AuthHookOptions) => {
     error: OpenfortError | null | undefined;
     initOAuth: (options: InitializeOAuthOptions) => Promise<InitOAuthReturnType>;
     linkOauth: (options: InitializeOAuthOptions) => Promise<InitOAuthReturnType>;
+    storeCredentials: ({ player, accessToken, refreshToken, ...options }: StoreCredentialsOptions) => Promise<StoreCredentialsResult>;
 };

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

@@ -9,7 +9,8 @@ export type UserWallet = {
     connector?: Connector;
     id: string;
     isAvailable: boolean;
-    isActive: boolean;
+    isActive?: boolean;
+    isConnecting?: boolean;
 };
 type SetActiveWalletResult = {
     error?: OpenfortError;
@@ -31,11 +32,21 @@ type CreateWalletOptions = {
 type WalletOptions = OpenfortHookOptions<SetActiveWalletResult | CreateWalletResult>;
 export declare function useWallets(hookOptions?: WalletOptions): {
     exportPrivateKey: () => Promise<string>;
-    isLoading: boolean;
+    error: OpenfortError | null | undefined;
     isError: boolean;
     isSuccess: boolean;
-    error: OpenfortError | null | undefined;
-    wallets: UserWallet[];
+    isCreating: boolean;
+    isConnecting: boolean;
+    wallets: {
+        isConnecting: boolean;
+        isActive: boolean;
+        address?: `0x${string}`;
+        connectorType?: string;
+        walletClientType?: string;
+        connector?: Connector;
+        id: string;
+        isAvailable: boolean;
+    }[];
     availableWallets: import("../../wallets/useWallets").WalletProps[];
     activeWallet: UserWallet | undefined;
     setActiveWallet: (options: SetActiveWalletOptions | string) => Promise<SetActiveWalletResult>;

package/build/index.es.js

@@ -22,7 +22,7 @@ import { createSiweMessage } from 'viem/siwe';
 import { signMessage } from '@wagmi/core';
 import { useQuery, useQueryClient } from '@tanstack/react-query';
 
-const OPENFORTKIT_VERSION = '0.0.2';
+const OPENFORTKIT_VERSION = '0.0.3';
 
 var OpenfortErrorType;
 (function (OpenfortErrorType) {
@@ -10941,15 +10941,6 @@ const Providers = () => {
     return (jsxs(PageContent, { children: [(filteredProviders).map((auth) => (jsx(ProviderButtonSwitch, { provider: auth }, auth))), hasExcessProviders && jsx(SocialProvidersButton, {}), jsx(PoweredByFooter, { showDisclaimer: true })] }));
 };
 
-const mapStatus = (status) => {
-    return {
-        isLoading: status.status === 'loading',
-        isError: status.status === 'error',
-        isSuccess: status.status === 'success',
-        error: status.error
-    };
-};
-
 const onSuccess = ({ hookOptions, options, data, }) => {
     var _a, _b, _c, _d;
     (_a = hookOptions === null || hookOptions === void 0 ? void 0 : hookOptions.onSuccess) === null || _a === void 0 ? void 0 : _a.call(hookOptions, data);
@@ -10969,14 +10960,22 @@ const onError = ({ hookOptions, options, error, }) => {
     return { error };
 };
 
-const createOpenfortWallet = ({ address, isActive, }) => ({
+const createOpenfortWallet = ({ address, }) => ({
     connectorType: "embedded",
     walletClientType: "openfort",
     address,
     id: embeddedWalletId,
     isAvailable: true,
-    isActive,
 });
+const mapStatus$1 = (status) => {
+    return {
+        error: status.error,
+        isError: status.status === 'error',
+        isSuccess: status.status === 'success',
+        isCreating: status.status === 'creating',
+        isConnecting: status.status === 'connecting',
+    };
+};
 function useWallets(hookOptions = {}) {
     const { user, embeddedState, client } = useOpenfortCore();
     const { walletConfig, log, setOpen, setRoute, setConnector, uiConfig } = useOpenfortKit();
@@ -11056,17 +11055,18 @@ function useWallets(hookOptions = {}) {
                 walletClientType: a.walletClientType,
                 id: (wallet === null || wallet === void 0 ? void 0 : wallet.id) || a.walletClientType || "unknown",
                 isAvailable: !!wallet,
-                isActive: (connector === null || connector === void 0 ? void 0 : connector.id) === a.walletClientType && address === a.address,
             };
         }) : [];
         embeddedWallets === null || embeddedWallets === void 0 ? void 0 : embeddedWallets.forEach((wallet) => {
+            // Remove duplicates (different chain ids)
+            if (userWallets.find(w => w.address === (wallet.address)))
+                return;
             userWallets.push(createOpenfortWallet({
                 address: wallet.address,
-                isActive: wallet.address === address,
             }));
         });
         return userWallets;
-    }, [user, address, connector === null || connector === void 0 ? void 0 : connector.id, embeddedWallets]);
+    }, [user === null || user === void 0 ? void 0 : user.linkedAccounts, embeddedWallets]);
     const activeWallet = isConnected && connector ? wallets.find((w) => w.isActive) : undefined;
     useEffect(() => {
         if (connectToConnector)
@@ -11143,7 +11143,8 @@ function useWallets(hookOptions = {}) {
         log("Setting active wallet", { options: optionsObject, chainId });
         if (isOpenfortWallet(optionsObject)) {
             setStatus({
-                status: 'loading',
+                status: 'connecting',
+                address: optionsObject.address,
             });
             const { password } = optionsObject;
             if (!walletConfig) {
@@ -11153,12 +11154,13 @@ function useWallets(hookOptions = {}) {
                     hookOptions
                 });
             }
-            log(`Handling recovery with Openfort: password=${password}, chainId=${chainId}`);
+            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,
@@ -11169,13 +11171,14 @@ function useWallets(hookOptions = {}) {
                         await walletConfig.getEncryptionSession() :
                         await getEncryptionSession(),
                 };
+                log("Shield authentication");
                 const recoveryParams = password ? {
                     recoveryMethod: RecoveryMethod.PASSWORD,
                     password,
                 } : {
                     recoveryMethod: RecoveryMethod.AUTOMATIC,
                 };
-                log("Recovery params", recoveryParams, optionsObject.address);
+                log("Recovery params", optionsObject.address);
                 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;
                     if (!walletId) {
@@ -11212,7 +11215,6 @@ function useWallets(hookOptions = {}) {
                     data: {
                         wallet: createOpenfortWallet({
                             address: optionsObject.address,
-                            isActive: true,
                         }),
                     },
                     options: optionsObject,
@@ -11248,7 +11250,8 @@ function useWallets(hookOptions = {}) {
         }
         else {
             setStatus({
-                status: 'loading',
+                status: 'connecting',
+                address: optionsObject.address,
             });
             setConnectToConnector({
                 address: optionsObject.address,
@@ -11260,8 +11263,9 @@ function useWallets(hookOptions = {}) {
     const createWallet = useCallback(async ({ password, ...options } = {}) => {
         var _a;
         setStatus({
-            status: 'loading',
+            status: 'creating',
         });
+        log("Creating wallet", { password: !!password, options });
         const accessToken = await client.getAccessToken();
         if (!accessToken) {
             return onError({
@@ -11277,10 +11281,7 @@ function useWallets(hookOptions = {}) {
                 options,
             });
         }
-        const shieldAuthentication = password ? {
-            auth: ShieldAuthType.OPENFORT,
-            token: accessToken,
-        } : {
+        const shieldAuthentication = {
             auth: ShieldAuthType.OPENFORT,
             token: accessToken,
             encryptionSession: walletConfig.getEncryptionSession ?
@@ -11308,18 +11309,21 @@ function useWallets(hookOptions = {}) {
             data: {
                 wallet: createOpenfortWallet({
                     address: wallet.address,
-                    isActive: true,
                 })
             }
         });
     }, [refetch, client, uiConfig, chainId]);
     return {
-        wallets,
+        wallets: wallets.map((w) => ({
+            ...w,
+            isConnecting: status.status === 'connecting' && status.address === w.address,
+            isActive: w.address === address && isConnected && (connector === null || connector === void 0 ? void 0 : connector.id) === w.id,
+        })),
         availableWallets: deviceWallets,
         activeWallet,
         setActiveWallet,
         createWallet,
-        ...mapStatus(status),
+        ...mapStatus$1(status),
         exportPrivateKey: client.embeddedWallet.exportPrivateKey,
     };
 }
@@ -11719,6 +11723,7 @@ const OpenfortProvider = ({ children, uiConfig, onConnect, onDisconnect, debugMo
                 }, shieldConfiguration: walletConfig ? {
                     shieldPublishableKey: walletConfig.shieldPublishableKey,
                     shieldEncryptionKey: walletConfig.recoveryMethod === RecoveryMethod.PASSWORD ? walletConfig.shieldEncryptionKey : undefined,
+                    debug: debugMode,
                 } : undefined, overrides: opts.openfortUrlOverrides, 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 })] }) }) }));
 };
 
@@ -12300,17 +12305,72 @@ const buildCallbackUrl = ({ email, callbackUrl, provider, }) => {
     return redirectUrl.toString();
 };
 
+const mapStatus = (status) => {
+    return {
+        isLoading: status.status === 'loading',
+        isError: status.status === 'error',
+        isSuccess: status.status === 'success',
+        error: status.error
+    };
+};
+
+function useSignOut(hookOptions = {}) {
+    const { client, updateUser, user } = useOpenfortCore();
+    const [status, setStatus] = useState({
+        status: "idle",
+    });
+    const { disconnect } = useDisconnect();
+    const signOut = useCallback(async (options = {}) => {
+        if (!user)
+            return;
+        setStatus({
+            status: 'loading',
+        });
+        try {
+            await client.auth.logout();
+            disconnect();
+            updateUser();
+            setStatus({
+                status: 'success',
+            });
+            return onSuccess({
+                hookOptions,
+                options,
+                data: {},
+            });
+        }
+        catch (error) {
+            setStatus({
+                status: 'error',
+                error: new OpenfortError('Failed to sign out', OpenfortErrorType.AUTHENTICATION_ERROR, { error }),
+            });
+            throw error;
+        }
+    }, [client, user, disconnect, updateUser, setStatus, hookOptions]);
+    return {
+        ...mapStatus(status),
+        signOut,
+    };
+}
+
 // this hook is used to create a wallet after the user has authenticated
 const useCreateWalletPostAuth = () => {
     const { setActiveWallet } = useWallets();
     const { walletConfig } = useOpenfortKit();
-    const tryUseWallet = useCallback(async () => {
-        if (!walletConfig || walletConfig.recoveryMethod !== RecoveryMethod.AUTOMATIC)
+    const { signOut } = useSignOut();
+    const tryUseWallet = useCallback(async ({ logoutOnError: signOutOnError = true, automaticRecovery = true }) => {
+        if (!walletConfig || walletConfig.recoveryMethod !== RecoveryMethod.AUTOMATIC || !automaticRecovery) {
             return {};
-        return await setActiveWallet({
+        }
+        const wallet = await setActiveWallet({
             connector: embeddedWalletId,
         });
-    }, [walletConfig]);
+        if (wallet.error && signOutOnError) {
+            // If there was an error and we should log out, we can call the logout function
+            await signOut();
+        }
+        return wallet;
+    }, [walletConfig, setActiveWallet, signOut]);
     return {
         tryUseWallet,
     };
@@ -12361,7 +12421,10 @@ const useEmailAuth = (hookOptions = {}) => {
                 });
             }
             else {
-                const { wallet } = await tryUseWallet();
+                const { wallet } = await tryUseWallet({
+                    logoutOnError: options.logoutOnError || hookOptions.logoutOnError,
+                    automaticRecovery: options.automaticRecovery || hookOptions.automaticRecovery,
+                });
                 setStatus({
                     status: 'success',
                 });
@@ -12491,7 +12554,10 @@ const useEmailAuth = (hookOptions = {}) => {
                 });
             }
             else {
-                const { wallet } = await tryUseWallet();
+                const { wallet } = await tryUseWallet({
+                    logoutOnError: options.logoutOnError || hookOptions.logoutOnError,
+                    automaticRecovery: options.automaticRecovery || hookOptions.automaticRecovery,
+                });
                 setStatus({
                     status: 'success',
                 });
@@ -12582,34 +12648,10 @@ const useEmailAuth = (hookOptions = {}) => {
             });
         }
     }, [client, setStatus, updateUser, log, hookOptions]);
-    return {
-        signInEmail,
-        signUpEmail,
-        linkEmail,
-        requestResetPassword,
-        resetPassword,
-        reset,
-        ...mapStatus(status),
-        requiresEmailVerification,
-        isAwaitingInput: status.status === 'awaiting-input',
-    };
-};
-
-const useAuthCallback = ({ automaticallyHandleCallback = true, // Automatically handle OAuth and email callback
-...hookOptions } = {}) => {
-    const { log } = useOpenfortKit();
-    const [status, setStatus] = useState({
-        status: "idle",
-    });
-    const { client, updateUser } = useOpenfortCore();
-    const [provider, setProvider] = useState(null);
-    const [email, setEmail] = useState(null);
-    const { tryUseWallet } = useCreateWalletPostAuth();
     const verifyEmail = useCallback(async ({ email, state, ...options }) => {
         setStatus({
             status: 'loading',
         });
-        setEmail(email);
         try {
             await client.auth.verifyEmail({
                 email,
@@ -12621,7 +12663,9 @@ const useAuthCallback = ({ automaticallyHandleCallback = true, // Automatically
             return onSuccess({
                 hookOptions,
                 options,
-                data: { email, type: "verifyEmail" },
+                data: {
+                    email,
+                },
             });
         }
         catch (e) {
@@ -12631,14 +12675,48 @@ const useAuthCallback = ({ automaticallyHandleCallback = true, // Automatically
                 error,
             });
             log("Error verifying email", e);
-            onError({
+            return onError({
                 hookOptions,
                 options,
                 error,
             });
-            return { error, type: "verifyEmail" };
         }
     }, [client, log, hookOptions]);
+    return {
+        signInEmail,
+        signUpEmail,
+        verifyEmail,
+        linkEmail,
+        requestResetPassword,
+        resetPassword,
+        reset,
+        ...mapStatus(status),
+        requiresEmailVerification,
+        isAwaitingInput: status.status === 'awaiting-input',
+    };
+};
+
+const providerToAuthProvider = {
+    // [OAuthProvider.APPLE]: AuthProvider.,
+    // [OAuthProvider.DISCORD]: AuthProvider.,
+    // [OAuthProvider.EPIC_GAMES]: AuthProvider.,
+    [AuthProvider.FACEBOOK]: OAuthProvider.FACEBOOK,
+    [AuthProvider.GOOGLE]: OAuthProvider.GOOGLE,
+    // [OAuthProvider.LINE]: AuthProvider.,
+    [AuthProvider.TWITTER]: OAuthProvider.TWITTER,
+};
+function getOAuthProvider(provider) {
+    if (!providerToAuthProvider[provider]) {
+        throw new Error(`Unsupported OAuth provider: ${provider}`);
+    }
+    return providerToAuthProvider[provider];
+}
+const useOAuth = (hookOptions = {}) => {
+    const { client, updateUser } = useOpenfortCore();
+    const [status, setStatus] = useState({
+        status: "idle",
+    });
+    const { tryUseWallet } = useCreateWalletPostAuth();
     const storeCredentials = useCallback(async ({ player, accessToken, refreshToken, ...options }) => {
         setStatus({
             status: 'loading',
@@ -12653,7 +12731,10 @@ const useAuthCallback = ({ automaticallyHandleCallback = true, // Automatically
                 status: 'success',
             });
             const user = await updateUser() || undefined;
-            const { wallet } = await tryUseWallet();
+            const { wallet } = await tryUseWallet({
+                logoutOnError: options.logoutOnError || hookOptions.logoutOnError,
+                automaticRecovery: options.automaticRecovery || hookOptions.automaticRecovery,
+            });
             return onSuccess({
                 data: { user, wallet, type: "storeCredentials" },
                 hookOptions,
@@ -12666,17 +12747,105 @@ const useAuthCallback = ({ automaticallyHandleCallback = true, // Automatically
                 status: 'error',
                 error,
             });
-            log("Error storing credentials", e);
-            onError({
+            return onError({
                 hookOptions,
                 options,
                 error,
             });
-            return { error, type: "storeCredentials" };
         }
-    }, [client, log, hookOptions]);
+    }, [client, hookOptions]);
+    const initOAuth = useCallback(async (options) => {
+        var _a;
+        const authProvider = options.provider;
+        try {
+            setStatus({
+                status: 'loading',
+            });
+            await client.auth.initOAuth({
+                provider: getOAuthProvider(authProvider),
+                options: {
+                    redirectTo: buildCallbackUrl({
+                        provider: authProvider,
+                        callbackUrl: (_a = hookOptions === null || hookOptions === void 0 ? void 0 : hookOptions.redirectTo) !== null && _a !== void 0 ? _a : options === null || options === void 0 ? void 0 : options.redirectTo,
+                    })
+                },
+            });
+            return onSuccess({
+                data: {},
+                hookOptions,
+                options,
+            });
+        }
+        catch (e) {
+            const error = new OpenfortError("Failed to login with OAuth", OpenfortErrorType.AUTHENTICATION_ERROR, { error: e });
+            setStatus({
+                status: 'error',
+                error
+            });
+            return onError({
+                hookOptions,
+                options,
+                error,
+            });
+        }
+    }, [client, setStatus, updateUser, hookOptions]);
+    const linkOauth = useCallback(async (options) => {
+        var _a;
+        const authProvider = options.provider;
+        try {
+            setStatus({
+                status: 'loading',
+            });
+            const authToken = await client.getAccessToken();
+            if (!authToken) {
+                throw new OpenfortError("No auth token found", OpenfortErrorType.AUTHENTICATION_ERROR);
+            }
+            await client.auth.initLinkOAuth({
+                authToken,
+                provider: getOAuthProvider(authProvider),
+                options: {
+                    redirectTo: buildCallbackUrl({
+                        provider: authProvider,
+                        callbackUrl: (_a = options === null || options === void 0 ? void 0 : options.redirectTo) !== null && _a !== void 0 ? _a : hookOptions === null || hookOptions === void 0 ? void 0 : hookOptions.redirectTo,
+                    })
+                },
+            });
+            return onSuccess({
+                data: {},
+                hookOptions,
+                options,
+            });
+        }
+        catch (e) {
+            const error = new OpenfortError("Failed to link OAuth", OpenfortErrorType.AUTHENTICATION_ERROR, { error: e });
+            setStatus({
+                status: 'error',
+                error
+            });
+            return onError({
+                hookOptions,
+                options,
+                error,
+            });
+        }
+    }, [client, setStatus, updateUser, hookOptions]);
+    return {
+        initOAuth,
+        linkOauth,
+        storeCredentials,
+        ...mapStatus(status),
+    };
+};
+
+const useAuthCallback = ({ enabled = true, // Automatically handle OAuth and email callback
+...hookOptions } = {}) => {
+    const { log } = useOpenfortKit();
+    const [provider, setProvider] = useState(null);
+    const [email, setEmail] = useState(null);
+    const { verifyEmail, isSuccess: isEmailSuccess, isLoading: isEmailLoading, isError: isEmailError, error: emailError, } = useEmailAuth();
+    const { storeCredentials, isSuccess: isOAuthSuccess, isLoading: isOAuthLoading, isError: isOAuthError, error: oAuthError, } = useOAuth();
     useEffect(() => {
-        if (!automaticallyHandleCallback)
+        if (!enabled)
             return;
         (async () => {
             // redirectUrl is not working with query params OF-1013
@@ -12705,7 +12874,26 @@ const useAuthCallback = ({ automaticallyHandleCallback = true, // Automatically
                     window.history.replaceState({}, document.title, url.toString());
                 };
                 log("EmailVerification", state, email);
-                await verifyEmail({ email, state });
+                const options = {
+                    onSuccess: (data) => {
+                        var _a;
+                        (_a = hookOptions.onSuccess) === null || _a === void 0 ? void 0 : _a.call(hookOptions, {
+                            ...data,
+                            type: "verifyEmail",
+                        });
+                    },
+                    onSettled: (data, error) => {
+                        var _a;
+                        (_a = hookOptions.onSettled) === null || _a === void 0 ? void 0 : _a.call(hookOptions, {
+                            ...data,
+                            type: "verifyEmail",
+                        }, error);
+                    },
+                    onError: hookOptions.onError,
+                    throwOnError: hookOptions.throwOnError,
+                };
+                await verifyEmail({ email, state, ...options });
+                setEmail(email);
                 removeParams();
             }
             else {
@@ -12736,7 +12924,25 @@ const useAuthCallback = ({ automaticallyHandleCallback = true, // Automatically
                     window.history.replaceState({}, document.title, url.toString());
                 };
                 log("callback", { player, accessToken, refreshToken });
-                await storeCredentials({ player, accessToken, refreshToken });
+                const options = {
+                    onSuccess: (data) => {
+                        var _a;
+                        (_a = hookOptions.onSuccess) === null || _a === void 0 ? void 0 : _a.call(hookOptions, {
+                            ...data,
+                            type: "storeCredentials",
+                        });
+                    },
+                    onSettled: (data, error) => {
+                        var _a;
+                        (_a = hookOptions.onSettled) === null || _a === void 0 ? void 0 : _a.call(hookOptions, {
+                            ...data,
+                            type: "storeCredentials",
+                        }, error);
+                    },
+                    onError: hookOptions.onError,
+                    throwOnError: hookOptions.throwOnError,
+                };
+                await storeCredentials({ player, accessToken, refreshToken, ...options });
                 removeParams();
             }
         })();
@@ -12746,7 +12952,10 @@ const useAuthCallback = ({ automaticallyHandleCallback = true, // Automatically
         provider,
         verifyEmail,
         storeCredentials,
-        ...mapStatus(status),
+        isLoading: isEmailLoading || isOAuthLoading,
+        isError: isEmailError || isOAuthError,
+        isSuccess: isEmailSuccess || isOAuthSuccess,
+        error: emailError || oAuthError,
     };
 };
 
@@ -12764,7 +12973,10 @@ const useGuestAuth = (hookOptions = {}) => {
             const result = await client.auth.signUpGuest();
             const user = result.player;
             await updateUser(user);
-            const { wallet } = await tryUseWallet();
+            const { wallet } = await tryUseWallet({
+                logoutOnError: options.logoutOnError || hookOptions.logoutOnError,
+                automaticRecovery: options.automaticRecovery || hookOptions.automaticRecovery,
+            });
             setStatus({
                 status: 'success',
             });
@@ -12977,146 +13189,5 @@ const useWalletAuth = (hookOptions = {}) => {
     };
 };
 
-const providerToAuthProvider = {
-    // [OAuthProvider.APPLE]: AuthProvider.,
-    // [OAuthProvider.DISCORD]: AuthProvider.,
-    // [OAuthProvider.EPIC_GAMES]: AuthProvider.,
-    [AuthProvider.FACEBOOK]: OAuthProvider.FACEBOOK,
-    [AuthProvider.GOOGLE]: OAuthProvider.GOOGLE,
-    // [OAuthProvider.LINE]: AuthProvider.,
-    [AuthProvider.TWITTER]: OAuthProvider.TWITTER,
-};
-function getOAuthProvider(provider) {
-    if (!providerToAuthProvider[provider]) {
-        throw new Error(`Unsupported OAuth provider: ${provider}`);
-    }
-    return providerToAuthProvider[provider];
-}
-const useOAuth = (hookOptions = {}) => {
-    const { client, updateUser } = useOpenfortCore();
-    const [status, setStatus] = useState({
-        status: "idle",
-    });
-    const initOAuth = useCallback(async (options) => {
-        var _a;
-        const authProvider = options.provider;
-        try {
-            setStatus({
-                status: 'loading',
-            });
-            await client.auth.initOAuth({
-                provider: getOAuthProvider(authProvider),
-                options: {
-                    redirectTo: buildCallbackUrl({
-                        provider: authProvider,
-                        callbackUrl: (_a = hookOptions === null || hookOptions === void 0 ? void 0 : hookOptions.redirectTo) !== null && _a !== void 0 ? _a : options === null || options === void 0 ? void 0 : options.redirectTo,
-                    })
-                },
-            });
-            return onSuccess({
-                data: {},
-                hookOptions,
-                options,
-            });
-        }
-        catch (e) {
-            const error = new OpenfortError("Failed to login with OAuth", OpenfortErrorType.AUTHENTICATION_ERROR, { error: e });
-            setStatus({
-                status: 'error',
-                error
-            });
-            return onError({
-                hookOptions,
-                options,
-                error,
-            });
-        }
-    }, [client, setStatus, updateUser, hookOptions]);
-    const linkOauth = useCallback(async (options) => {
-        var _a;
-        const authProvider = options.provider;
-        try {
-            setStatus({
-                status: 'loading',
-            });
-            const authToken = await client.getAccessToken();
-            if (!authToken) {
-                throw new OpenfortError("No auth token found", OpenfortErrorType.AUTHENTICATION_ERROR);
-            }
-            await client.auth.initLinkOAuth({
-                authToken,
-                provider: getOAuthProvider(authProvider),
-                options: {
-                    redirectTo: buildCallbackUrl({
-                        provider: authProvider,
-                        callbackUrl: (_a = options === null || options === void 0 ? void 0 : options.redirectTo) !== null && _a !== void 0 ? _a : hookOptions === null || hookOptions === void 0 ? void 0 : hookOptions.redirectTo,
-                    })
-                },
-            });
-            return onSuccess({
-                data: {},
-                hookOptions,
-                options,
-            });
-        }
-        catch (e) {
-            const error = new OpenfortError("Failed to link OAuth", OpenfortErrorType.AUTHENTICATION_ERROR, { error: e });
-            setStatus({
-                status: 'error',
-                error
-            });
-            return onError({
-                hookOptions,
-                options,
-                error,
-            });
-        }
-    }, [client, setStatus, updateUser, hookOptions]);
-    return {
-        initOAuth,
-        linkOauth,
-        ...mapStatus(status),
-    };
-};
-
-function useSignOut(hookOptions = {}) {
-    const { client, updateUser, user } = useOpenfortCore();
-    const [status, setStatus] = useState({
-        status: "idle",
-    });
-    const { disconnect } = useDisconnect();
-    const signOut = useCallback(async (options = {}) => {
-        if (!user)
-            return;
-        setStatus({
-            status: 'loading',
-        });
-        try {
-            await client.auth.logout();
-            disconnect();
-            updateUser();
-            setStatus({
-                status: 'success',
-            });
-            return onSuccess({
-                hookOptions,
-                options,
-                data: {},
-            });
-        }
-        catch (error) {
-            setStatus({
-                status: 'error',
-                error: new OpenfortError('Failed to sign out', OpenfortErrorType.AUTHENTICATION_ERROR, { error }),
-            });
-            throw error;
-        }
-    }, [client, user, disconnect, updateUser, setStatus, hookOptions]);
-    return {
-        ...mapStatus(status),
-        signOut,
-    };
-}
-
 export { AuthProvider, Avatar, Chain as ChainIcon, OPENFORTKIT_VERSION, OpenfortError, OpenfortErrorType, OpenfortKitButton, OpenfortKitContext, OpenfortKitStatus, OpenfortProvider, 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/version.d.ts

@@ -1 +1 @@
-export declare const OPENFORTKIT_VERSION = "0.0.2";
+export declare const OPENFORTKIT_VERSION = "0.0.3";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfort/react",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "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.7",
+    "@openfort/openfort-js": "^0.9.8",
     "buffer": "^6.0.3",
     "detect-browser": "^5.3.0",
     "framer-motion": "^6.3.11",