@trimble-oss/trimble-id-react 0.0.1-rc.1

package/dist/trimble-id-react.es.js

@@ -0,0 +1,1457 @@
+var kt = Object.defineProperty;
+var Rt = (a, t, n) => t in a ? kt(a, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : a[t] = n;
+var p = (a, t, n) => (Rt(a, typeof t != "symbol" ? t + "" : t, n), n);
+import { OpenIdEndpointProvider as Tt, AuthorizationCodeGrantTokenProvider as Fe, AnalyticsHttpClient as wt, BearerTokenHttpClientProvider as bt } from "@trimble-oss/trimble-id";
+import * as le from "es-cookie";
+import Ct from "jwt-decode";
+import Ye, { createContext as Pt, useContext as Je, useState as Ot, useReducer as It, useRef as xt, useMemo as Le, useEffect as Ge, useCallback as X } from "react";
+class At {
+  constructor() {
+    /**
+     * This function generate a encapsulation function to store
+     * the user and token information in a secure way disabled the
+     * access from the outside
+     * @see {https://medium.com/javascript-scene/encapsulation-in-javascript-26be60e325b4} Encapsulation
+     * @return {CacheStorage} Key for the token
+     */
+    p(this, "generateCache", function() {
+      const t = {
+        token: void 0,
+        user: void 0
+      };
+      return {
+        /**
+         * Get token store in cache
+         * @return {Promise<TIDAuthToken | undefined>} Token store in memory
+         */
+        async getToken() {
+          return t.token;
+        },
+        /**
+         * Get user store in cache
+         * @return {Promise<TIDUser | undefined>} User store in memory
+         */
+        async getUser() {
+          return t.user;
+        },
+        /**
+         * Store token in cache
+         * @param {TIDAuthToken} token - Token that you want to store in cache
+         * @return {Promise<void>} Empty promise
+         */
+        async storeToken(n) {
+          t.token = n;
+        },
+        /**
+         * Store user in cache
+         * @param {TIDUser} user - User that you want to store in cache
+         * @return {Promise<void>} Empty promise
+         */
+        async storeUser(n) {
+          t.user = n;
+        },
+        /**
+         * The clear the cache from the storage
+         * @return {Promise<void>} Empty promise
+         */
+        clear() {
+          return t.token = void 0, t.user = void 0, Promise.resolve(void 0);
+        }
+      };
+    }());
+  }
+}
+class Kt {
+  /**
+   * Initialized configuration to store information into local storage
+   * @param {LocalStorageCacheOptions} options - Configuration for caching in localstorage
+   */
+  constructor(t) {
+    /**
+     * Local storage from the browser
+     * @type {Storage}
+     */
+    p(this, "localStorage");
+    /**
+     * The cache key represents the keys for storing and retrieving user and token from auth
+     * @type {CacheKey}
+     */
+    p(this, "cacheKey");
+    this.localStorage = window.localStorage, this.cacheKey = t.cacheKey;
+  }
+  /**
+   * Get token store in localstorage
+   * @return {Promise<TIDAuthToken | undefined>} - Token store in localstorage
+   */
+  async getToken() {
+    const t = this.getAuthKey(), n = localStorage.getItem(t);
+    return n ? JSON.parse(n) : void 0;
+  }
+  /**
+   * Get user store in localstorage
+   * @return {Promise<TIDUser | undefined>}  - User store in localstorage
+   */
+  async getUser() {
+    const t = this.getUserKey(), n = localStorage.getItem(t);
+    return n ? JSON.parse(n) : void 0;
+  }
+  /**
+   * Store token in localstorage
+   * @param {TIDAuthToken} token - Token that you want to store in localstorage
+   * @return {Promise<void>} Empty promise
+   */
+  async storeToken(t) {
+    const n = this.getAuthKey(), o = JSON.stringify(t);
+    localStorage.setItem(n, o);
+  }
+  /**
+   * Store user in cache
+   * @param {TIDUser} user - User that you want to store in localstorage
+   * @return {Promise<void>} Empty promise
+   */
+  async storeUser(t) {
+    const n = this.getUserKey(), o = JSON.stringify(t);
+    localStorage.setItem(n, o);
+  }
+  /**
+   * Get the full key from the cachekey for the user
+   * @return {string} - Full key to get the token from the localstorage
+   */
+  getUserKey() {
+    return this.cacheKey.getUserKey();
+  }
+  /**
+   * Get the full key from the cachekey for the token
+   * @return {string} - Full key to get the token from the localstorage
+   */
+  getAuthKey() {
+    return this.cacheKey.getAuthKey();
+  }
+  /**
+   * The clear the cache from the localstorage
+   * @return {Promise<void>} Empty promise
+   */
+  clear() {
+    return this.localStorage.removeItem(this.getAuthKey()), this.localStorage.removeItem(this.getUserKey()), Promise.resolve(void 0);
+  }
+}
+const he = "@TID", Ut = `${he}_AUTH_KEY`, Dt = `${he}_USER_KEY`;
+class Mt {
+  /**
+   * Initialized the cache key
+   * @param {CacheKeyOptions} cacheKeyOptions - Cache key options to edit the default values
+   */
+  constructor(t) {
+    /**
+     * Client id of the application created in trimble developer console
+     * @type {string}
+     */
+    p(this, "clientId");
+    /**
+     * Prefix value of the key, by default the prefix is based on the constant PREFIX_KEY
+     * @type {string}
+     */
+    p(this, "prefix", he);
+    /**
+     * Suffix value use it to generate the key to store and retrieve the token, by default the prefix is based on the constant AUTH_KEY
+     * @type {string}
+     */
+    p(this, "authSuffix", Ut);
+    /**
+     * Suffix value use it to generate the key to store and retrieve the user, by default the prefix is based on the constant USER_KEY
+     * @type {string}
+     */
+    p(this, "userSuffix", Dt);
+    this.clientId = t.client_id;
+  }
+  /**
+   * Get key to store/retrieve user
+   * @return {string} Key for the user
+   */
+  getUserKey() {
+    return `${this.prefix}_${this.userSuffix}_${this.clientId}`;
+  }
+  /**
+   * Get key to store/retrieve token
+   * @return {string} Key for the token
+   */
+  getAuthKey() {
+    return `${this.prefix}_${this.authSuffix}_${this.clientId}`;
+  }
+}
+class jt {
+  /**
+   * Initialized configuration to store information into session storage
+   * @param {SessionStorageCacheOptions} options - Configuration for caching in session storage
+   */
+  constructor(t) {
+    /**
+     * Session storage from the browser
+     * @type {Storage}
+     */
+    p(this, "sessionStorage");
+    /**
+     * The cache key represents the keys for storing and retrieving user and token from auth
+     * @type {CacheKey}
+     */
+    p(this, "cacheKey");
+    this.sessionStorage = window.sessionStorage, this.cacheKey = t.cacheKey;
+  }
+  /**
+   * Get token store in session storage
+   * @return {Promise<TIDAuthToken | undefined>} - Token store in session storage
+   */
+  async getToken() {
+    const t = this.getAuthKey(), n = sessionStorage.getItem(t);
+    return n ? JSON.parse(n) : void 0;
+  }
+  /**
+   * Get user store in session storage
+   * @return {Promise<TIDUser | undefined>}  - User store in session storage
+   */
+  async getUser() {
+    const t = this.getUserKey(), n = sessionStorage.getItem(t);
+    return n ? JSON.parse(n) : void 0;
+  }
+  /**
+   * Store token in session storage
+   * @param {TIDAuthToken} authToken - Token that you want to store in session storage
+   * @return {Promise<void>} Empty promise
+   */
+  async storeToken(t) {
+    const n = this.getAuthKey(), o = JSON.stringify(t);
+    sessionStorage.setItem(n, o);
+  }
+  /**
+   * Store user in cache
+   * @param {TIDUser} user - User that you want to store in session storage
+   * @return {Promise<void>} Empty promise
+   */
+  async storeUser(t) {
+    const n = this.getUserKey(), o = JSON.stringify(t);
+    sessionStorage.setItem(n, o);
+  }
+  /**
+   * Get the full key from the cachekey for the user
+   * @return {string} - Full key to get the token from the session storage
+   */
+  getUserKey() {
+    return this.cacheKey.getUserKey();
+  }
+  /**
+   * Get the full key from the cachekey for the token
+   * @return {string} - Full key to get the token from the session storage
+   */
+  getAuthKey() {
+    return this.cacheKey.getAuthKey();
+  }
+  /**
+   * The clear the cache from the session storage
+   * @return {Promise<void>} Empty promise
+   */
+  clear() {
+    return this.sessionStorage.removeItem(this.getAuthKey()), this.sessionStorage.removeItem(this.getUserKey()), Promise.resolve(void 0);
+  }
+}
+class Ft {
+  /**
+   * Create a cache manager to extract or save the user, and token
+   * @param {CacheManagerOptions} options - Configuration for the managing the caching
+   */
+  constructor(t) {
+    /**
+     * Type persistent you want the user and token to be store
+     * in-memory - This one will only persist will the user stays in the page
+     * localStorage - This persistent doesn't have expiration date
+     * sessionStorage - This one is cleared when the page session ends
+     * @type {PersistentStore}
+     */
+    p(this, "persistentStore");
+    /**
+     * Cache option selected
+     * @type {CacheStorage}
+     */
+    p(this, "cacheStorage");
+    /**
+     * The cache key represents the keys for storing and retrieving user and token from auth
+     * @type {CacheKey}
+     */
+    p(this, "cacheKey");
+    this.persistentStore = t.persistentStore, this.cacheKey = new Mt({
+      client_id: t.clientId
+    }), this.persistentStore === "localStorage" ? this.cacheStorage = new Kt({
+      cacheKey: this.cacheKey
+    }) : this.persistentStore === "sessionStorage" ? this.cacheStorage = new jt({
+      cacheKey: this.cacheKey
+    }) : this.cacheStorage = new At().generateCache;
+  }
+  /**
+   * Store token in cache
+   * @param {TIDAuthToken} token - Token that you want to store in cache
+   * @return {Promise<void>} Empty promise
+   */
+  async setToken(t) {
+    await this.cacheStorage.storeToken(t);
+  }
+  /**
+   * Store user in cache
+   * @param {TIDUser} user - User that you want to store in cache
+   * @return {Promise<void>} Empty promise
+   */
+  async setUser(t) {
+    await this.cacheStorage.storeUser(t);
+  }
+  /**
+   * Get user store in cache
+   * @return {Promise<TIDUser | undefined>} Key for the user
+   */
+  async getUser() {
+    return this.cacheStorage.getUser();
+  }
+  /**
+   * Get token store in cache
+   * @return {Promise<TIDAuthToken | undefined>} Key for the user
+   */
+  async getToken() {
+    return this.cacheStorage.getToken();
+  }
+  /**
+   * The clear the cache from the storage
+   * @return {Promise<void>} Empty promise
+   */
+  async clear() {
+    await this.cacheStorage.clear();
+  }
+}
+const Lt = 5 * 6e4, Wt = ["code", "state"], We = (a) => a.split("?")[0], Nt = (a) => a.split("?")[1], Be = (a) => {
+  let t = a;
+  if (!a.startsWith("?"))
+    try {
+      t = new URL(a).search;
+    } catch {
+    }
+  return new URLSearchParams(t);
+}, $t = (a = window.location.href, t) => {
+  if (t != null) {
+    const o = We(t), c = We(a ?? "");
+    if (o !== c)
+      return !1;
+  }
+  const n = Be(a);
+  for (const o of Wt)
+    if (!n.has(o))
+      return !1;
+  return !0;
+}, Vt = (a) => ({
+  name: `${a.given_name} ${a.family_name}`,
+  given_name: a.given_name,
+  family_name: a.family_name,
+  picture: a.picture,
+  email: a.email,
+  email_verified: a.email_verified,
+  phone_number_verified: !1
+}), Yt = "@TID_COOKIE";
+class Jt {
+  /**
+   * Retrieve a cookie from the browser
+   * @param {string} key - Key to retrieve the cookies
+   */
+  get(t) {
+    const n = le.get(t);
+    if (n == null)
+      throw new Error("Cookie not found");
+    return JSON.parse(n);
+  }
+  /**
+   * Store cookies in the browser
+   * @param {string} key - Key to save and retrieve the cookies
+   * @param {any} value - Information you want to store in cookies
+   * @param {CookiesOptions} options - Additional options you want to add to the cookies.
+   * @example Save cookies with one day of expiration
+   * cookiesStorage.set('key',{data:{...}},{expires:1})
+   * @example Save cookies with a custom domain
+   * cookiesStorage.set('key',{data:{...}},{domain:'https://example.com/subpath'})
+   */
+  set(t, n, o) {
+    let c = {};
+    window.location.protocol === "https:" && (c = {
+      secure: !0,
+      sameSite: "none"
+    }), o != null && o.expires && (c.expires = o.expires), o != null && o.domain && (c.domain = o.domain), le.set(t, JSON.stringify(n), c);
+  }
+  /**
+   * Remove a cookie from the browser
+   * @param {string} key - Key to remove the cookies from the browser
+   * @param {CookiesOptions} options - Additional options used when the cookie was declared
+   * @example Remove cookies without additional information
+   * cookiesStorage.remove('key')
+   * @example Remove cookies with custom domain
+   * cookiesStorage.remove('key',{domain:'https://example.com/subpath'})
+   */
+  remove(t, n) {
+    const o = {};
+    n != null && n.domain && (o.domain = n.domain), le.remove(t, o);
+  }
+}
+class Gt {
+  /**
+   * Create a cookies manager to extract or save cookies in the browser
+   * @param {CookiesManagerOptions} options - Configuration for the managing the cookies
+   */
+  constructor(t) {
+    /**
+     * Cookie full key to store and retrieve the information from cookies
+     * @type {string}
+     */
+    p(this, "cookieKey");
+    /**
+     * Cookie storage. This object contain all functions necessary to retrieve and store tokens using cookies
+     * @type {CookiesStorage}
+     */
+    p(this, "cookiesStorage");
+    this.cookieKey = `${Yt}.${t.clientId}`, this.cookiesStorage = new Jt();
+  }
+  /**
+   * Store cookies in the browser
+   * @param {CookieValue} value - information to store
+   */
+  save(t) {
+    this.cookiesStorage.set(this.cookieKey, t, {
+      expires: 1
+    });
+  }
+  /**
+   * Retrieve cookies in the browser
+   * @return {CookieValue | undefined}  - Cookies from the browser
+   */
+  get() {
+    try {
+      return this.cookiesStorage.get(this.cookieKey);
+    } catch {
+      return;
+    }
+  }
+  /**
+   * Clear information about the cookies stored in the browser
+   */
+  clear() {
+    this.cookiesStorage.remove(this.cookieKey);
+  }
+}
+class Bt extends Error {
+}
+class zt extends Error {
+}
+class Ht extends Error {
+}
+const D = "@trimble-oss/trimble-id-react", M = "0.0.1-rc.1", qt = {
+  configurationEndpoint: "",
+  clientId: "",
+  redirectUrl: "",
+  logoutRedirectUrl: "",
+  scopes: []
+}, Xt = {
+  persistentStore: "in-memory"
+};
+class Qt {
+  /**
+   * Create a TID client to handle manage all user authentication functions and information
+   * @param {CacheManagerOptions} props - TID client configuration
+   */
+  constructor(t) {
+    /**
+     * Token provider SDK. This object handles all necessary communication with TID
+     * @type {AuthorizationCodeGrantTokenProvider}
+     */
+    p(this, "tokenProvider");
+    /**
+     * This object manage all caching, and all configurations necessary
+     * @type {CacheManager}
+     */
+    p(this, "cacheManager");
+    /**
+     * This object manage all cookies administration, and all configurations necessary
+     * @type {CookiesManager}
+     */
+    p(this, "cookiesManager");
+    /**
+     * Client id of the application created in trimble developer console
+     * @type {string}
+     */
+    p(this, "clientId");
+    /**
+     * Callback url to redirect the user after the authentication is successful
+     * @type {string}
+     */
+    p(this, "redirectUrl");
+    /**
+      * AnalyticsHttpClient for sending events
+      * @type {AnalyticsHttpClient}
+      */
+    p(this, "analyticshttpclient");
+    const { config: n = qt, persistentOptions: o = Xt } = t;
+    if (this.redirectUrl = n.redirectUrl, n.configurationEndpoint == null || n.configurationEndpoint == "")
+      throw new Error("Configuration endpoint not defined");
+    if (n.clientId == null || n.clientId == "")
+      throw new Error("Consumer key is not defined");
+    this.cookiesManager = new Gt({
+      clientId: n.clientId
+    });
+    const c = this.cookiesManager.get(), k = new Tt(n.configurationEndpoint);
+    let _ = new Fe(
+      k,
+      n.clientId,
+      n.redirectUrl
+    ).WithScopes(n.scopes);
+    n.logoutRedirectUrl && (_ = _.WithLogoutRedirect(n.logoutRedirectUrl)), (c == null ? void 0 : c.code_verifier) != null && (_ = _.WithProofKeyForCodeExchange(c.code_verifier)), this.tokenProvider = _, this.cacheManager = new Ft({
+      clientId: n.clientId,
+      persistentStore: o.persistentStore
+    }), this.clientId = n.clientId, this.analyticshttpclient = new wt(), this.analyticshttpclient.sendInitEvent("TIDClient", D, M, this.clientId);
+  }
+  /**
+   * Redirect the user to TID using the browser
+   * @param {LoginWithRedirectOptions} options - Custom configuration for the redirection
+   * @return {Promise<void>} Empty promise
+   * @example No configuration
+   * loginWithRedirect()
+   * // Automatically redirects the user to TID with all necessary parameters
+   * @example Custom redirect
+   * loginWithRedirect({onRedirect: (url) => router.navigate(url)})
+   * // Redirect calls onRedirect with the log-out url for TID
+   * // So it can be handled by the developer
+   */
+  async loginWithRedirect(t) {
+    this.analyticshttpclient.sendMethodEvent(this.loginWithRedirect.name, D, M, this.clientId);
+    const { onRedirect: n } = t || {}, o = Fe.GenerateCodeVerifier();
+    this.cookiesManager.save({ code_verifier: o }), this.tokenProvider = this.tokenProvider.WithProofKeyForCodeExchange(o);
+    const c = await this.tokenProvider.GetOAuthRedirect("state");
+    n != null ? n(c) : window.location.assign(c);
+  }
+  /**
+   * Authenticated the user using the url callback params
+   * @param {string} url - Custom configuration for the redirection
+   * @return {Promise<AuthState>} Object contain the state returned from TID
+   * @throws {CodeVerifierNotFoundException} Will throw an exception if the session doesn't contain the code verifier
+   * @example No configuration
+   * handleCallback()
+   * // Will automatically take the url from the browser and try to log in the user
+   * @example Custom url
+   * handleCallback('https://example.com?code=code....')
+   * // Will try to log in the user with the url assign by the developer
+   */
+  async handleCallback(t = window.location.href) {
+    const n = this.cookiesManager.get();
+    if (n == null || (n == null ? void 0 : n.code_verifier) == null)
+      throw new Ht("Code verifier not available");
+    const o = Nt(t), c = Be(t), k = c.get("identity_provider") ?? "", _ = c.get("state") ?? "";
+    return await this.tokenProvider.ValidateQuery(o), await this.generateToken(k), {
+      authState: _
+    };
+  }
+  /**
+   * Function to generate and store the access token
+   * @param {string} identityProvider - Type of identity provider used
+   * @return {Promise<void>} Empty promise
+   */
+  async generateToken(t) {
+    var T, d;
+    const n = await this.tokenProvider.RetrieveToken(), o = await this.tokenProvider.RetrieveRefreshToken(), c = await this.tokenProvider.RetrieveIdToken(), k = await this.tokenProvider.RetrieveTokenExpiry(), w = new Date(k).getTime(), g = (d = (T = this.tokenProvider) == null ? void 0 : T._scopes) == null ? void 0 : d.join(" ");
+    await this.cacheManager.setToken({
+      scope: g,
+      state: "",
+      session_state: "",
+      identity_provider: t,
+      token_type: "bearer",
+      access_token: n,
+      refresh_token: o,
+      id_token: c,
+      expires_at: w
+    });
+    const C = Ct(c), S = Vt(C);
+    await this.cacheManager.setUser(S), await this.reloadCodeVerifier();
+  }
+  async reloadCodeVerifier() {
+    const t = await this.tokenProvider.RetrieveCodeVerifier();
+    this.cookiesManager.save({ code_verifier: t }), this.tokenProvider = this.tokenProvider.WithProofKeyForCodeExchange(t);
+  }
+  /**
+   * Return the user stored in cache
+   * @return {Promise<TIDUser | undefined>} User in cache
+   */
+  async getUser() {
+    return this.analyticshttpclient.sendMethodEvent(this.getUser.name, D, M, this.clientId), await this.cacheManager.getUser();
+  }
+  /**
+   * Gets the access token from cache. If the token already expired,
+   * will try to refresh it using the refresh token
+   * @return {Promise<string>} Access token
+   * @throws {TokenNotFoundException} Will throw an exception if the access token is not in cache
+   * @throws {TokenExpiredException} Will throw an exception if the user token expired
+   */
+  async getAccessTokenSilently() {
+    this.analyticshttpclient.sendMethodEvent(this.getAccessTokenSilently.name, D, M, this.clientId);
+    let t = await this.cacheManager.getToken();
+    if (t == null)
+      throw this.analyticshttpclient.sendExceptionEvent(this.getAccessTokenSilently.name, D, M, "No token available", this.clientId), new zt("No token available");
+    const n = new Date((/* @__PURE__ */ new Date()).getTime() + Lt);
+    if ((t == null ? void 0 : t.expires_at) == null || (t == null ? void 0 : t.expires_at) < n.getTime()) {
+      try {
+        await this.tokenProvider.RetrieveToken();
+      } catch (o) {
+        throw this.analyticshttpclient.sendExceptionEvent(this.getAccessTokenSilently.name, D, M, o.message, this.clientId), new Bt(o.message);
+      }
+      await this.generateToken((t == null ? void 0 : t.identity_provider) ?? ""), t = await this.cacheManager.getToken();
+    }
+    return (t == null ? void 0 : t.access_token) || "";
+  }
+  /**
+   * Redirect the user to TID using the browser
+   * @param {LogoutOptions} options - Custom configuration for teh redirection
+   * @return {Promise<void>} Empty promise
+   * @example No configuration
+   * logout()
+   * // Automatically redirects the user to TID to log out
+   * @example Custom redirect
+   * logout({onRedirect: (url) => router.navigate(url)})
+   * // Redirect calls onRedirect with the log-out url for TID
+   * // So it can be handled by the developer
+   */
+  async logout(t) {
+    this.analyticshttpclient.sendMethodEvent(this.logout.name, D, M, this.clientId);
+    const { onRedirect: n, disabledAutoRedirect: o } = t || {};
+    this.cacheManager && await this.cacheManager.clear(), this.cookiesManager && this.cookiesManager.clear();
+    const c = await this.tokenProvider.GetOAuthLogoutRedirect("state");
+    if (n != null)
+      return n(c);
+    o || window.location.assign(c);
+  }
+  /**
+   * Check if the user still has a valid session
+   * @return {Promise<boolean>} True or false depending on if the user is session is valid or not
+   */
+  async checkSession() {
+    try {
+      await this.getAccessTokenSilently();
+    } catch {
+      return !1;
+    }
+    return !0;
+  }
+  /**
+   * Check if the user has a session valid after a refresh
+   * @return {Promise<void>} Empty promise
+   */
+  async loadUserSession() {
+    await this.loadCacheSessionIntoSDK(), await this.checkSession() || await this.cacheManager.clear();
+  }
+  /**
+   * Load the user session from cache into the SDK
+   * @return {Promise<void>} Empty promise
+   */
+  async loadCacheSessionIntoSDK() {
+    const t = await this.cacheManager.getToken();
+    if (t == null)
+      return;
+    const n = t.access_token, o = t.refresh_token || "", c = t.id_token, k = t.expires_at;
+    this.tokenProvider = this.tokenProvider.WithAccessToken(n, k).WithRefreshToken(o).WithIdToken(c);
+  }
+  /**
+   * Get a http bearer token client to use it for another SDK (Ex: Processing framework)
+   * @return {any} - BearerTokenHttpClientProvider
+   */
+  getBearerTokenHttpClient(t) {
+    return new bt(this.tokenProvider, t);
+  }
+  /**
+   * Get the redirect url to TID
+   * @return {string} - Callback redirect url
+   */
+  getRedirectUrl() {
+    return this.redirectUrl;
+  }
+}
+const ue = Pt(null), ze = () => Je(ue) ?? {};
+var fe = { exports: {} }, N = {};
+/**
+ * @license React
+ * react-jsx-runtime.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Ne;
+function Zt() {
+  if (Ne)
+    return N;
+  Ne = 1;
+  var a = Ye, t = Symbol.for("react.element"), n = Symbol.for("react.fragment"), o = Object.prototype.hasOwnProperty, c = a.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, k = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function _(w, g, C) {
+    var S, T = {}, d = null, K = null;
+    C !== void 0 && (d = "" + C), g.key !== void 0 && (d = "" + g.key), g.ref !== void 0 && (K = g.ref);
+    for (S in g)
+      o.call(g, S) && !k.hasOwnProperty(S) && (T[S] = g[S]);
+    if (w && w.defaultProps)
+      for (S in g = w.defaultProps, g)
+        T[S] === void 0 && (T[S] = g[S]);
+    return { $$typeof: t, type: w, key: d, ref: K, props: T, _owner: c.current };
+  }
+  return N.Fragment = n, N.jsx = _, N.jsxs = _, N;
+}
+var $ = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var $e;
+function er() {
+  return $e || ($e = 1, process.env.NODE_ENV !== "production" && function() {
+    var a = Ye, t = Symbol.for("react.element"), n = Symbol.for("react.portal"), o = Symbol.for("react.fragment"), c = Symbol.for("react.strict_mode"), k = Symbol.for("react.profiler"), _ = Symbol.for("react.provider"), w = Symbol.for("react.context"), g = Symbol.for("react.forward_ref"), C = Symbol.for("react.suspense"), S = Symbol.for("react.suspense_list"), T = Symbol.for("react.memo"), d = Symbol.for("react.lazy"), K = Symbol.for("react.offscreen"), A = Symbol.iterator, V = "@@iterator";
+    function Q(e) {
+      if (e === null || typeof e != "object")
+        return null;
+      var r = A && e[A] || e[V];
+      return typeof r == "function" ? r : null;
+    }
+    var O = a.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function E(e) {
+      {
+        for (var r = arguments.length, i = new Array(r > 1 ? r - 1 : 0), s = 1; s < r; s++)
+          i[s - 1] = arguments[s];
+        Y("error", e, i);
+      }
+    }
+    function Y(e, r, i) {
+      {
+        var s = O.ReactDebugCurrentFrame, f = s.getStackAddendum();
+        f !== "" && (r += "%s", i = i.concat([f]));
+        var h = i.map(function(u) {
+          return String(u);
+        });
+        h.unshift("Warning: " + r), Function.prototype.apply.call(console[e], console, h);
+      }
+    }
+    var J = !1, Z = !1, v = !1, P = !1, ee = !1, ge;
+    ge = Symbol.for("react.module.reference");
+    function He(e) {
+      return !!(typeof e == "string" || typeof e == "function" || e === o || e === k || ee || e === c || e === C || e === S || P || e === K || J || Z || v || typeof e == "object" && e !== null && (e.$$typeof === d || e.$$typeof === T || e.$$typeof === _ || e.$$typeof === w || e.$$typeof === g || // This needs to include all possible module reference object
+      // types supported by any Flight configuration anywhere since
+      // we don't know which Flight build this will end up being used
+      // with.
+      e.$$typeof === ge || e.getModuleId !== void 0));
+    }
+    function qe(e, r, i) {
+      var s = e.displayName;
+      if (s)
+        return s;
+      var f = r.displayName || r.name || "";
+      return f !== "" ? i + "(" + f + ")" : i;
+    }
+    function ve(e) {
+      return e.displayName || "Context";
+    }
+    function I(e) {
+      if (e == null)
+        return null;
+      if (typeof e.tag == "number" && E("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof e == "function")
+        return e.displayName || e.name || null;
+      if (typeof e == "string")
+        return e;
+      switch (e) {
+        case o:
+          return "Fragment";
+        case n:
+          return "Portal";
+        case k:
+          return "Profiler";
+        case c:
+          return "StrictMode";
+        case C:
+          return "Suspense";
+        case S:
+          return "SuspenseList";
+      }
+      if (typeof e == "object")
+        switch (e.$$typeof) {
+          case w:
+            var r = e;
+            return ve(r) + ".Consumer";
+          case _:
+            var i = e;
+            return ve(i._context) + ".Provider";
+          case g:
+            return qe(e, e.render, "ForwardRef");
+          case T:
+            var s = e.displayName || null;
+            return s !== null ? s : I(e.type) || "Memo";
+          case d: {
+            var f = e, h = f._payload, u = f._init;
+            try {
+              return I(u(h));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var U = Object.assign, L = 0, ye, pe, me, Ee, _e, Se, ke;
+    function Re() {
+    }
+    Re.__reactDisabledLog = !0;
+    function Xe() {
+      {
+        if (L === 0) {
+          ye = console.log, pe = console.info, me = console.warn, Ee = console.error, _e = console.group, Se = console.groupCollapsed, ke = console.groupEnd;
+          var e = {
+            configurable: !0,
+            enumerable: !0,
+            value: Re,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: e,
+            log: e,
+            warn: e,
+            error: e,
+            group: e,
+            groupCollapsed: e,
+            groupEnd: e
+          });
+        }
+        L++;
+      }
+    }
+    function Qe() {
+      {
+        if (L--, L === 0) {
+          var e = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: U({}, e, {
+              value: ye
+            }),
+            info: U({}, e, {
+              value: pe
+            }),
+            warn: U({}, e, {
+              value: me
+            }),
+            error: U({}, e, {
+              value: Ee
+            }),
+            group: U({}, e, {
+              value: _e
+            }),
+            groupCollapsed: U({}, e, {
+              value: Se
+            }),
+            groupEnd: U({}, e, {
+              value: ke
+            })
+          });
+        }
+        L < 0 && E("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var te = O.ReactCurrentDispatcher, re;
+    function G(e, r, i) {
+      {
+        if (re === void 0)
+          try {
+            throw Error();
+          } catch (f) {
+            var s = f.stack.trim().match(/\n( *(at )?)/);
+            re = s && s[1] || "";
+          }
+        return `
+` + re + e;
+      }
+    }
+    var ne = !1, B;
+    {
+      var Ze = typeof WeakMap == "function" ? WeakMap : Map;
+      B = new Ze();
+    }
+    function Te(e, r) {
+      if (!e || ne)
+        return "";
+      {
+        var i = B.get(e);
+        if (i !== void 0)
+          return i;
+      }
+      var s;
+      ne = !0;
+      var f = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var h;
+      h = te.current, te.current = null, Xe();
+      try {
+        if (r) {
+          var u = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(u.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(u, []);
+            } catch (x) {
+              s = x;
+            }
+            Reflect.construct(e, [], u);
+          } else {
+            try {
+              u.call();
+            } catch (x) {
+              s = x;
+            }
+            e.call(u.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            s = x;
+          }
+          e();
+        }
+      } catch (x) {
+        if (x && s && typeof x.stack == "string") {
+          for (var l = x.stack.split(`
+`), R = s.stack.split(`
+`), y = l.length - 1, m = R.length - 1; y >= 1 && m >= 0 && l[y] !== R[m]; )
+            m--;
+          for (; y >= 1 && m >= 0; y--, m--)
+            if (l[y] !== R[m]) {
+              if (y !== 1 || m !== 1)
+                do
+                  if (y--, m--, m < 0 || l[y] !== R[m]) {
+                    var b = `
+` + l[y].replace(" at new ", " at ");
+                    return e.displayName && b.includes("<anonymous>") && (b = b.replace("<anonymous>", e.displayName)), typeof e == "function" && B.set(e, b), b;
+                  }
+                while (y >= 1 && m >= 0);
+              break;
+            }
+        }
+      } finally {
+        ne = !1, te.current = h, Qe(), Error.prepareStackTrace = f;
+      }
+      var F = e ? e.displayName || e.name : "", je = F ? G(F) : "";
+      return typeof e == "function" && B.set(e, je), je;
+    }
+    function et(e, r, i) {
+      return Te(e, !1);
+    }
+    function tt(e) {
+      var r = e.prototype;
+      return !!(r && r.isReactComponent);
+    }
+    function z(e, r, i) {
+      if (e == null)
+        return "";
+      if (typeof e == "function")
+        return Te(e, tt(e));
+      if (typeof e == "string")
+        return G(e);
+      switch (e) {
+        case C:
+          return G("Suspense");
+        case S:
+          return G("SuspenseList");
+      }
+      if (typeof e == "object")
+        switch (e.$$typeof) {
+          case g:
+            return et(e.render);
+          case T:
+            return z(e.type, r, i);
+          case d: {
+            var s = e, f = s._payload, h = s._init;
+            try {
+              return z(h(f), r, i);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var H = Object.prototype.hasOwnProperty, we = {}, be = O.ReactDebugCurrentFrame;
+    function q(e) {
+      if (e) {
+        var r = e._owner, i = z(e.type, e._source, r ? r.type : null);
+        be.setExtraStackFrame(i);
+      } else
+        be.setExtraStackFrame(null);
+    }
+    function rt(e, r, i, s, f) {
+      {
+        var h = Function.call.bind(H);
+        for (var u in e)
+          if (h(e, u)) {
+            var l = void 0;
+            try {
+              if (typeof e[u] != "function") {
+                var R = Error((s || "React class") + ": " + i + " type `" + u + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof e[u] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw R.name = "Invariant Violation", R;
+              }
+              l = e[u](r, u, s, i, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (y) {
+              l = y;
+            }
+            l && !(l instanceof Error) && (q(f), E("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", s || "React class", i, u, typeof l), q(null)), l instanceof Error && !(l.message in we) && (we[l.message] = !0, q(f), E("Failed %s type: %s", i, l.message), q(null));
+          }
+      }
+    }
+    var nt = Array.isArray;
+    function ie(e) {
+      return nt(e);
+    }
+    function it(e) {
+      {
+        var r = typeof Symbol == "function" && Symbol.toStringTag, i = r && e[Symbol.toStringTag] || e.constructor.name || "Object";
+        return i;
+      }
+    }
+    function at(e) {
+      try {
+        return Ce(e), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function Ce(e) {
+      return "" + e;
+    }
+    function Pe(e) {
+      if (at(e))
+        return E("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", it(e)), Ce(e);
+    }
+    var W = O.ReactCurrentOwner, ot = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, Oe, Ie, ae;
+    ae = {};
+    function st(e) {
+      if (H.call(e, "ref")) {
+        var r = Object.getOwnPropertyDescriptor(e, "ref").get;
+        if (r && r.isReactWarning)
+          return !1;
+      }
+      return e.ref !== void 0;
+    }
+    function ct(e) {
+      if (H.call(e, "key")) {
+        var r = Object.getOwnPropertyDescriptor(e, "key").get;
+        if (r && r.isReactWarning)
+          return !1;
+      }
+      return e.key !== void 0;
+    }
+    function lt(e, r) {
+      if (typeof e.ref == "string" && W.current && r && W.current.stateNode !== r) {
+        var i = I(W.current.type);
+        ae[i] || (E('Component "%s" contains the string ref "%s". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref', I(W.current.type), e.ref), ae[i] = !0);
+      }
+    }
+    function ut(e, r) {
+      {
+        var i = function() {
+          Oe || (Oe = !0, E("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", r));
+        };
+        i.isReactWarning = !0, Object.defineProperty(e, "key", {
+          get: i,
+          configurable: !0
+        });
+      }
+    }
+    function ft(e, r) {
+      {
+        var i = function() {
+          Ie || (Ie = !0, E("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", r));
+        };
+        i.isReactWarning = !0, Object.defineProperty(e, "ref", {
+          get: i,
+          configurable: !0
+        });
+      }
+    }
+    var dt = function(e, r, i, s, f, h, u) {
+      var l = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: t,
+        // Built-in properties that belong on the element
+        type: e,
+        key: r,
+        ref: i,
+        props: u,
+        // Record the component responsible for creating this element.
+        _owner: h
+      };
+      return l._store = {}, Object.defineProperty(l._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(l, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: s
+      }), Object.defineProperty(l, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: f
+      }), Object.freeze && (Object.freeze(l.props), Object.freeze(l)), l;
+    };
+    function ht(e, r, i, s, f) {
+      {
+        var h, u = {}, l = null, R = null;
+        i !== void 0 && (Pe(i), l = "" + i), ct(r) && (Pe(r.key), l = "" + r.key), st(r) && (R = r.ref, lt(r, f));
+        for (h in r)
+          H.call(r, h) && !ot.hasOwnProperty(h) && (u[h] = r[h]);
+        if (e && e.defaultProps) {
+          var y = e.defaultProps;
+          for (h in y)
+            u[h] === void 0 && (u[h] = y[h]);
+        }
+        if (l || R) {
+          var m = typeof e == "function" ? e.displayName || e.name || "Unknown" : e;
+          l && ut(u, m), R && ft(u, m);
+        }
+        return dt(e, l, R, f, s, W.current, u);
+      }
+    }
+    var oe = O.ReactCurrentOwner, xe = O.ReactDebugCurrentFrame;
+    function j(e) {
+      if (e) {
+        var r = e._owner, i = z(e.type, e._source, r ? r.type : null);
+        xe.setExtraStackFrame(i);
+      } else
+        xe.setExtraStackFrame(null);
+    }
+    var se;
+    se = !1;
+    function ce(e) {
+      return typeof e == "object" && e !== null && e.$$typeof === t;
+    }
+    function Ae() {
+      {
+        if (oe.current) {
+          var e = I(oe.current.type);
+          if (e)
+            return `
+
+Check the render method of \`` + e + "`.";
+        }
+        return "";
+      }
+    }
+    function gt(e) {
+      {
+        if (e !== void 0) {
+          var r = e.fileName.replace(/^.*[\\\/]/, ""), i = e.lineNumber;
+          return `
+
+Check your code at ` + r + ":" + i + ".";
+        }
+        return "";
+      }
+    }
+    var Ke = {};
+    function vt(e) {
+      {
+        var r = Ae();
+        if (!r) {
+          var i = typeof e == "string" ? e : e.displayName || e.name;
+          i && (r = `
+
+Check the top-level render call using <` + i + ">.");
+        }
+        return r;
+      }
+    }
+    function Ue(e, r) {
+      {
+        if (!e._store || e._store.validated || e.key != null)
+          return;
+        e._store.validated = !0;
+        var i = vt(r);
+        if (Ke[i])
+          return;
+        Ke[i] = !0;
+        var s = "";
+        e && e._owner && e._owner !== oe.current && (s = " It was passed a child from " + I(e._owner.type) + "."), j(e), E('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', i, s), j(null);
+      }
+    }
+    function De(e, r) {
+      {
+        if (typeof e != "object")
+          return;
+        if (ie(e))
+          for (var i = 0; i < e.length; i++) {
+            var s = e[i];
+            ce(s) && Ue(s, r);
+          }
+        else if (ce(e))
+          e._store && (e._store.validated = !0);
+        else if (e) {
+          var f = Q(e);
+          if (typeof f == "function" && f !== e.entries)
+            for (var h = f.call(e), u; !(u = h.next()).done; )
+              ce(u.value) && Ue(u.value, r);
+        }
+      }
+    }
+    function yt(e) {
+      {
+        var r = e.type;
+        if (r == null || typeof r == "string")
+          return;
+        var i;
+        if (typeof r == "function")
+          i = r.propTypes;
+        else if (typeof r == "object" && (r.$$typeof === g || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        r.$$typeof === T))
+          i = r.propTypes;
+        else
+          return;
+        if (i) {
+          var s = I(r);
+          rt(i, e.props, "prop", s, e);
+        } else if (r.PropTypes !== void 0 && !se) {
+          se = !0;
+          var f = I(r);
+          E("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", f || "Unknown");
+        }
+        typeof r.getDefaultProps == "function" && !r.getDefaultProps.isReactClassApproved && E("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function pt(e) {
+      {
+        for (var r = Object.keys(e.props), i = 0; i < r.length; i++) {
+          var s = r[i];
+          if (s !== "children" && s !== "key") {
+            j(e), E("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", s), j(null);
+            break;
+          }
+        }
+        e.ref !== null && (j(e), E("Invalid attribute `ref` supplied to `React.Fragment`."), j(null));
+      }
+    }
+    function Me(e, r, i, s, f, h) {
+      {
+        var u = He(e);
+        if (!u) {
+          var l = "";
+          (e === void 0 || typeof e == "object" && e !== null && Object.keys(e).length === 0) && (l += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
+          var R = gt(f);
+          R ? l += R : l += Ae();
+          var y;
+          e === null ? y = "null" : ie(e) ? y = "array" : e !== void 0 && e.$$typeof === t ? (y = "<" + (I(e.type) || "Unknown") + " />", l = " Did you accidentally export a JSX literal instead of a component?") : y = typeof e, E("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", y, l);
+        }
+        var m = ht(e, r, i, f, h);
+        if (m == null)
+          return m;
+        if (u) {
+          var b = r.children;
+          if (b !== void 0)
+            if (s)
+              if (ie(b)) {
+                for (var F = 0; F < b.length; F++)
+                  De(b[F], e);
+                Object.freeze && Object.freeze(b);
+              } else
+                E("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+            else
+              De(b, e);
+        }
+        return e === o ? pt(m) : yt(m), m;
+      }
+    }
+    function mt(e, r, i) {
+      return Me(e, r, i, !0);
+    }
+    function Et(e, r, i) {
+      return Me(e, r, i, !1);
+    }
+    var _t = Et, St = mt;
+    $.Fragment = o, $.jsx = _t, $.jsxs = St;
+  }()), $;
+}
+process.env.NODE_ENV === "production" ? fe.exports = Zt() : fe.exports = er();
+var de = fe.exports;
+const tr = (a, t) => {
+  switch (t.type) {
+    case "INIT":
+      return {
+        ...a,
+        isLoading: !1,
+        isAuthenticated: t.user != null,
+        user: t.user,
+        error: void 0
+      };
+    case "HANDLE_CALLBACK_COMPLETE":
+    case "GET_ACCESS_TOKEN_COMPLETE":
+      return {
+        ...a,
+        isLoading: !1,
+        isAuthenticated: t.user != null,
+        user: t.user,
+        error: void 0
+      };
+    case "LOGOUT":
+      return {
+        ...a,
+        isAuthenticated: !1,
+        user: void 0
+      };
+    case "ERROR":
+      return {
+        ...a,
+        isLoading: !1,
+        error: t.error
+      };
+  }
+}, rr = {
+  isLoading: !0,
+  isAuthenticated: !1
+}, Ve = (a) => {
+  if (a == null || Object.keys(a).length <= 0)
+    return !0;
+  const t = Object.keys(a);
+  for (const n of t)
+    if (a[n] != null && a[n] !== "")
+      return !1;
+  return !0;
+}, nr = (a) => {
+  const t = Ve(a.config), n = Ve(a.persistentOptions);
+  return !t || !n;
+}, ir = (a) => {
+  const {
+    children: t,
+    configurationEndpoint: n,
+    clientId: o,
+    redirectUrl: c,
+    logoutRedirectUrl: k,
+    scopes: _,
+    persistentStore: w,
+    onRedirectCallback: g,
+    checkRedirectUrlMatch: C
+  } = a;
+  if (Je(ue) != null)
+    throw new Error("TID Provider already defined");
+  const T = {
+    config: {
+      configurationEndpoint: n ?? "",
+      clientId: o ?? "",
+      redirectUrl: c ?? "",
+      logoutRedirectUrl: k ?? "",
+      scopes: _ ?? [""]
+    },
+    persistentOptions: {
+      persistentStore: w ?? "in-memory"
+    }
+  }, [d] = Ot(a.tidClient ?? new Qt(T)), [K, A] = It(tr, rr), V = xt(!1), Q = Le(
+    () => C ? d.getRedirectUrl() : void 0,
+    [C, d]
+  );
+  Ge(() => {
+    V.current || (a.tidClient != null && nr({
+      config: {
+        configurationEndpoint: n,
+        clientId: o,
+        redirectUrl: c,
+        logoutRedirectUrl: k,
+        scopes: _
+      },
+      persistentOptions: {
+        persistentStore: w
+      }
+    }) && console.warn(
+      "When TID client is pass as prop, any client configuration property sent directly to the TID Provider component will be ignored"
+    ), V.current = !0, (async () => {
+      try {
+        let v;
+        if ($t(void 0, Q)) {
+          const { authState: P } = await d.handleCallback();
+          v = await d.getUser(), g != null && g(P);
+        } else
+          await d.loadUserSession(), v = await d.getUser();
+        A({ type: "INIT", user: v });
+      } catch (v) {
+        let P = v;
+        typeof v == "string" && (P = new Error(v)), A({ type: "ERROR", error: P });
+      }
+    })());
+  }, [d, g]);
+  const O = X(async () => {
+    const v = await d.getAccessTokenSilently(), P = await d.getUser();
+    return A({
+      type: "GET_ACCESS_TOKEN_COMPLETE",
+      user: P
+    }), v;
+  }, [d]), E = X(
+    async (v) => {
+      await d.loginWithRedirect(v);
+    },
+    [d]
+  ), Y = X(
+    async (v) => {
+      await d.logout(v), (v == null ? void 0 : v.disabledAutoRedirect) != null && v.disabledAutoRedirect && A({
+        type: "LOGOUT"
+      });
+    },
+    [d]
+  ), J = X(
+    async (v) => {
+      const { authState: P } = await d.handleCallback(v), ee = await d.getUser();
+      return A({
+        type: "HANDLE_CALLBACK_COMPLETE",
+        user: ee
+      }), {
+        authState: P
+      };
+    },
+    [d]
+  ), Z = Le(
+    () => ({
+      ...K,
+      getAccessTokenSilently: O,
+      loginWithRedirect: E,
+      handleCallback: J,
+      logout: Y
+    }),
+    [K, O, E, J, Y]
+  );
+  return /* @__PURE__ */ de.jsx(ue.Provider, { value: Z, children: t });
+}, lr = ze, ur = ir, fr = ({ renderComponent: a, loader: t }) => {
+  const { isAuthenticated: n, isLoading: o, loginWithRedirect: c } = ze();
+  return Ge(() => {
+    !o && !n && (async () => await c())();
+  }, [o, n, c]), n ? a : t || /* @__PURE__ */ de.jsx(de.Fragment, {});
+};
+export {
+  fr as AuthenticationGuard,
+  Qt as TIDClient,
+  ue as TIDContext,
+  ur as TIDProvider,
+  lr as useAuth
+};