@axa-fr/oidc-client 6.26.6

package/dist/index.js

@@ -0,0 +1,1236 @@
+const x = console;
+class _e {
+  constructor(e, t, s, i = 2e3, o = !0) {
+    this._callback = e, this._client_id = t, this._url = s, this._interval = i || 2e3, this._stopOnError = o;
+    const r = s.indexOf("/", s.indexOf("//") + 2);
+    this._frame_origin = s.substr(0, r), this._frame = window.document.createElement("iframe"), this._frame.style.visibility = "hidden", this._frame.style.position = "absolute", this._frame.style.display = "none", this._frame.width = 0, this._frame.height = 0, this._frame.src = s;
+  }
+  load() {
+    return new Promise((e) => {
+      this._frame.onload = () => {
+        e();
+      }, window.document.body.appendChild(this._frame), this._boundMessageEvent = this._message.bind(this), window.addEventListener("message", this._boundMessageEvent, !1);
+    });
+  }
+  _message(e) {
+    e.origin === this._frame_origin && e.source === this._frame.contentWindow && (e.data === "error" ? (x.error("CheckSessionIFrame: error message from check session op iframe"), this._stopOnError && this.stop()) : e.data === "changed" ? (x.debug(e), x.debug("CheckSessionIFrame: changed message from check session op iframe"), this.stop(), this._callback()) : x.debug("CheckSessionIFrame: " + e.data + " message from check session op iframe"));
+  }
+  start(e) {
+    x.debug("CheckSessionIFrame.start :" + e), this.stop();
+    const t = () => {
+      this._frame.contentWindow.postMessage(this._client_id + " " + e, this._frame_origin);
+    };
+    t(), this._timer = window.setInterval(t, this._interval);
+  }
+  stop() {
+    this._timer && (x.debug("CheckSessionIFrame.stop"), window.clearInterval(this._timer), this._timer = null);
+  }
+}
+const m = {
+  service_worker_not_supported_by_browser: "service_worker_not_supported_by_browser",
+  token_aquired: "token_aquired",
+  logout_from_another_tab: "logout_from_another_tab",
+  logout_from_same_tab: "logout_from_same_tab",
+  token_renewed: "token_renewed",
+  token_timer: "token_timer",
+  loginAsync_begin: "loginAsync_begin",
+  loginAsync_error: "loginAsync_error",
+  loginCallbackAsync_begin: "loginCallbackAsync_begin",
+  loginCallbackAsync_end: "loginCallbackAsync_end",
+  loginCallbackAsync_error: "loginCallbackAsync_error",
+  refreshTokensAsync_begin: "refreshTokensAsync_begin",
+  refreshTokensAsync: "refreshTokensAsync",
+  refreshTokensAsync_end: "refreshTokensAsync_end",
+  refreshTokensAsync_error: "refreshTokensAsync_error",
+  refreshTokensAsync_silent_error: "refreshTokensAsync_silent_error",
+  tryKeepExistingSessionAsync_begin: "tryKeepExistingSessionAsync_begin",
+  tryKeepExistingSessionAsync_end: "tryKeepExistingSessionAsync_end",
+  tryKeepExistingSessionAsync_error: "tryKeepExistingSessionAsync_error",
+  silentLoginAsync_begin: "silentLoginAsync_begin",
+  silentLoginAsync: "silentLoginAsync",
+  silentLoginAsync_end: "silentLoginAsync_end",
+  silentLoginAsync_error: "silentLoginAsync_error",
+  syncTokensAsync_begin: "syncTokensAsync_begin",
+  syncTokensAsync_end: "syncTokensAsync_end",
+  syncTokensAsync_error: "syncTokensAsync_error"
+}, I = (n, e = sessionStorage) => {
+  const t = (k) => (e[`oidc.${n}`] = JSON.stringify({ tokens: null, status: k }), Promise.resolve()), s = async () => {
+    if (!e[`oidc.${n}`])
+      return e[`oidc.${n}`] = JSON.stringify({ tokens: null, status: null }), { tokens: null, status: null };
+    const k = JSON.parse(e[`oidc.${n}`]);
+    return Promise.resolve({ tokens: k.tokens, status: k.status });
+  }, i = (k) => {
+    e[`oidc.${n}`] = JSON.stringify({ tokens: k });
+  }, o = async (k) => {
+    e[`oidc.session_state.${n}`] = k;
+  }, r = async () => e[`oidc.session_state.${n}`], l = (k) => {
+    localStorage[`oidc.nonce.${n}`] = k.nonce;
+  }, c = async () => ({ nonce: localStorage[`oidc.nonce.${n}`] }), d = () => e[`oidc.${n}`] ? JSON.stringify({ tokens: JSON.parse(e[`oidc.${n}`]).tokens }) : null;
+  let a = null;
+  return {
+    clearAsync: t,
+    initAsync: s,
+    setTokens: i,
+    getTokens: d,
+    setSessionStateAsync: o,
+    getSessionStateAsync: r,
+    setNonceAsync: l,
+    getNonceAsync: c,
+    setLoginParams: (k, p) => {
+      a = p, e[`oidc.login.${k}`] = JSON.stringify(p);
+    },
+    getLoginParams: (k) => {
+      const p = e[`oidc.login.${k}`];
+      return a || (a = JSON.parse(p)), a;
+    },
+    getStateAsync: async () => e[`oidc.state.${n}`],
+    setStateAsync: async (k) => {
+      e[`oidc.state.${n}`] = k;
+    },
+    getCodeVerifierAsync: async () => e[`oidc.code_verifier.${n}`],
+    setCodeVerifierAsync: async (k) => {
+      e[`oidc.code_verifier.${n}`] = k;
+    }
+  };
+}, fe = (n) => decodeURIComponent(Array.prototype.map.call(atob(n), (e) => "%" + ("00" + e.charCodeAt(0).toString(16)).slice(-2)).join("")), ye = (n) => JSON.parse(fe(n.split(".")[1].replace("-", "+").replace("_", "/"))), Q = (n) => {
+  try {
+    return n && ge(n, ".") === 2 ? ye(n) : null;
+  } catch (e) {
+    console.warn(e);
+  }
+  return null;
+}, ge = (n, e) => n.split(e).length - 1, j = {
+  access_token_or_id_token_invalid: "access_token_or_id_token_invalid",
+  access_token_invalid: "access_token_invalid",
+  id_token_invalid: "id_token_invalid"
+}, oe = (n, e = null, t) => {
+  if (!n)
+    return null;
+  let s;
+  if (!n.issuedAt) {
+    const d = (/* @__PURE__ */ new Date()).getTime() / 1e3;
+    n.issuedAt = d;
+  }
+  n.accessTokenPayload !== void 0 ? s = n.accessTokenPayload : s = Q(n.accessToken);
+  const i = n.idTokenPayload ? n.idTokenPayload : Q(n.idToken), o = i && i.exp ? i.exp : Number.MAX_VALUE, r = s && s.exp ? s.exp : n.issuedAt + n.expiresIn;
+  let l;
+  t === j.access_token_invalid ? l = r : t === j.id_token_invalid ? l = o : l = o < r ? o : r;
+  const c = { ...n, idTokenPayload: i, accessTokenPayload: s, expiresAt: l };
+  if (e != null && "refreshToken" in e && !("refreshToken" in n)) {
+    const d = e.refreshToken;
+    return { ...c, refreshToken: d };
+  }
+  return c;
+}, z = (n, e, t) => {
+  if (!n)
+    return null;
+  if (!n.issued_at) {
+    const i = (/* @__PURE__ */ new Date()).getTime() / 1e3;
+    n.issued_at = i;
+  }
+  const s = {
+    accessToken: n.access_token,
+    expiresIn: n.expires_in,
+    idToken: n.id_token,
+    scope: n.scope,
+    tokenType: n.token_type,
+    issuedAt: n.issued_at
+  };
+  return "refresh_token" in n && (s.refreshToken = n.refresh_token), n.accessTokenPayload !== void 0 && (s.accessTokenPayload = n.accessTokenPayload), n.idTokenPayload !== void 0 && (s.idTokenPayload = n.idTokenPayload), oe(s, e, t);
+}, D = (n, e) => {
+  const t = (/* @__PURE__ */ new Date()).getTime() / 1e3;
+  return Math.round(e - n - t);
+}, q = (n) => n ? D(0, n.expiresAt) > 0 : !1, ke = async (n, e = 200, t = 50) => {
+  let s = t;
+  if (!n.tokens)
+    return null;
+  for (; !q(n.tokens) && s > 0; )
+    await $(e), s = s - 1;
+  return {
+    isTokensValid: q(n.tokens),
+    tokens: n.tokens,
+    numberWaited: s - t
+  };
+}, ie = (n, e, t) => {
+  if (n.idTokenPayload) {
+    const s = n.idTokenPayload;
+    if (t.issuer !== s.iss)
+      return { isValid: !1, reason: "Issuer does not match" };
+    const i = (/* @__PURE__ */ new Date()).getTime() / 1e3;
+    if (s.exp && s.exp < i)
+      return { isValid: !1, reason: "Token expired" };
+    const o = 60 * 60 * 24 * 7;
+    if (s.iat && s.iat + o < i)
+      return { isValid: !1, reason: "Token is used from too long time" };
+    if (s.nonce && s.nonce !== e)
+      return { isValid: !1, reason: "Nonce does not match" };
+  }
+  return { isValid: !0, reason: "" };
+}, V = function() {
+  const n = function() {
+    let c, d;
+    const a = (function() {
+      const y = {}, u = {
+        setTimeout: function(_, g, k) {
+          y[g] = setTimeout(function() {
+            _.postMessage(g), y[g] = null;
+          }, k);
+        },
+        setInterval: function(_, g, k) {
+          y[g] = setInterval(function() {
+            _.postMessage(g);
+          }, k);
+        },
+        clearTimeout: function(_, g) {
+          clearTimeout(y[g]), y[g] = null;
+        },
+        clearInterval: function(_, g) {
+          clearInterval(y[g]), y[g] = null;
+        }
+      };
+      function f(_, g) {
+        const k = g.data[0], p = g.data[1], S = g.data[2];
+        u[k] && u[k](_, p, S);
+      }
+      this.onmessage = function(_) {
+        f(self, _);
+      }, this.onconnect = function(_) {
+        const g = _.ports[0];
+        g.onmessage = function(k) {
+          f(g, k);
+        };
+      };
+    }).toString();
+    try {
+      const y = new Blob(["(", a, ")()"], { type: "application/javascript" });
+      d = URL.createObjectURL(y);
+    } catch {
+      return null;
+    }
+    const h = typeof process > "u";
+    try {
+      if (SharedWorker)
+        return c = new SharedWorker(d), c.port;
+    } catch {
+      h && console.warn("SharedWorker not available");
+    }
+    try {
+      if (Worker)
+        return c = new Worker(d), c;
+    } catch {
+      h && console.warn("Worker not available");
+    }
+    return null;
+  }();
+  if (!n) {
+    const c = typeof window > "u" ? global : window;
+    return {
+      setTimeout: setTimeout.bind(c),
+      clearTimeout: clearTimeout.bind(c),
+      setInterval: setInterval.bind(c),
+      clearInterval: clearInterval.bind(c)
+    };
+  }
+  const e = function() {
+    let c = 0;
+    return function() {
+      return c++, c;
+    };
+  }(), t = {}, s = {};
+  n.onmessage = function(c) {
+    const d = c.data, a = t[d];
+    if (a) {
+      a(), t[d] = null;
+      return;
+    }
+    const h = s[d];
+    h && h();
+  };
+  function i(c, d) {
+    const a = e();
+    return n.postMessage(["setTimeout", a, d]), t[a] = c, a;
+  }
+  function o(c) {
+    n.postMessage(["clearTimeout", c]), t[c] = null;
+  }
+  function r(c, d) {
+    const a = e();
+    return n.postMessage(["setInterval", a, d]), s[a] = c, a;
+  }
+  function l(c) {
+    n.postMessage(["clearInterval", c]), s[c] = null;
+  }
+  return {
+    setTimeout: i,
+    clearTimeout: o,
+    setInterval: r,
+    clearInterval: l
+  };
+}(), re = (n) => {
+  const e = n.appVersion, t = n.userAgent, s = "-";
+  let i = s;
+  const o = [
+    { s: "Windows 10", r: /(Windows 10.0|Windows NT 10.0)/ },
+    { s: "Windows 8.1", r: /(Windows 8.1|Windows NT 6.3)/ },
+    { s: "Windows 8", r: /(Windows 8|Windows NT 6.2)/ },
+    { s: "Windows 7", r: /(Windows 7|Windows NT 6.1)/ },
+    { s: "Windows Vista", r: /Windows NT 6.0/ },
+    { s: "Windows Server 2003", r: /Windows NT 5.2/ },
+    { s: "Windows XP", r: /(Windows NT 5.1|Windows XP)/ },
+    { s: "Windows 2000", r: /(Windows NT 5.0|Windows 2000)/ },
+    { s: "Windows ME", r: /(Win 9x 4.90|Windows ME)/ },
+    { s: "Windows 98", r: /(Windows 98|Win98)/ },
+    { s: "Windows 95", r: /(Windows 95|Win95|Windows_95)/ },
+    { s: "Windows NT 4.0", r: /(Windows NT 4.0|WinNT4.0|WinNT|Windows NT)/ },
+    { s: "Windows CE", r: /Windows CE/ },
+    { s: "Windows 3.11", r: /Win16/ },
+    { s: "Android", r: /Android/ },
+    { s: "Open BSD", r: /OpenBSD/ },
+    { s: "Sun OS", r: /SunOS/ },
+    { s: "Chrome OS", r: /CrOS/ },
+    { s: "Linux", r: /(Linux|X11(?!.*CrOS))/ },
+    { s: "iOS", r: /(iPhone|iPad|iPod)/ },
+    { s: "Mac OS X", r: /Mac OS X/ },
+    { s: "Mac OS", r: /(Mac OS|MacPPC|MacIntel|Mac_PowerPC|Macintosh)/ },
+    { s: "QNX", r: /QNX/ },
+    { s: "UNIX", r: /UNIX/ },
+    { s: "BeOS", r: /BeOS/ },
+    { s: "OS/2", r: /OS\/2/ },
+    { s: "Search Bot", r: /(nuhk|Googlebot|Yammybot|Openbot|Slurp|MSNBot|Ask Jeeves\/Teoma|ia_archiver)/ }
+  ];
+  for (const l in o) {
+    const c = o[l];
+    if (c.r.test(t)) {
+      i = c.s;
+      break;
+    }
+  }
+  let r = s;
+  switch (/Windows/.test(i) && (r = /Windows (.*)/.exec(i)[1], i = "Windows"), i) {
+    case "Mac OS":
+    case "Mac OS X":
+    case "Android":
+      r = /(?:Android|Mac OS|Mac OS X|MacPPC|MacIntel|Mac_PowerPC|Macintosh) ([._\d]+)/.exec(t)[1];
+      break;
+    case "iOS": {
+      const l = /OS (\d+)_(\d+)_?(\d+)?/.exec(e);
+      r = l[1] + "." + l[2] + "." + (parseInt(l[3]) | 0);
+      break;
+    }
+  }
+  return {
+    os: i,
+    osVersion: r
+  };
+};
+function me() {
+  const n = navigator.userAgent;
+  let e, t = n.match(/(opera|chrome|safari|firefox|msie|trident(?=\/))\/?\s*(\d+)/i) || [];
+  if (/trident/i.test(t[1]))
+    return e = /\brv[ :]+(\d+)/g.exec(n) || [], { name: "ie", version: e[1] || "" };
+  if (t[1] === "Chrome" && (e = n.match(/\bOPR|Edge\/(\d+)/), e != null)) {
+    let s = e[1];
+    if (!s) {
+      const i = n.split(e[0] + "/");
+      i.length > 1 && (s = i[1]);
+    }
+    return { name: "opera", version: s };
+  }
+  return t = t[2] ? [t[1], t[2]] : [navigator.appName, navigator.appVersion, "-?"], (e = n.match(/version\/(\d+)/i)) != null && t.splice(1, 1, e[1]), {
+    name: t[0].toLowerCase(),
+    version: t[1]
+  };
+}
+let Z = null;
+const $ = (n) => new Promise((e) => V.setTimeout(e, n)), ae = () => {
+  try {
+    const e = re(navigator).os === "Android" ? 240 : 150;
+    fetch(`/OidcKeepAliveServiceWorker.json?minSleepSeconds=${e}`).catch((s) => {
+      console.log(s);
+    }), $(e * 1e3).then(ae);
+  } catch (n) {
+    console.log(n);
+  }
+}, we = () => fetch("/OidcKeepAliveServiceWorker.json", {
+  headers: {
+    "oidc-vanilla": "true"
+  }
+}).then((n) => n.statusText === "oidc-service-worker").catch((n) => {
+  console.log(n);
+}), pe = (n) => !!(n.os === "iOS" && n.osVersion.startsWith("12") || n.os === "Mac OS X" && n.osVersion.startsWith("10_15_6")), b = (n) => (e) => new Promise(function(t, s) {
+  const i = new MessageChannel();
+  i.port1.onmessage = function(o) {
+    o.data && o.data.error ? s(o.data.error) : t(o.data);
+  }, n.active.postMessage(e, [i.port2]);
+}), P = async (n, e) => {
+  if (typeof window > "u" || typeof navigator > "u" || !navigator.serviceWorker || !n)
+    return null;
+  const { name: t, version: s } = me();
+  if (t === "chrome" && parseInt(s) < 90 || t === "opera" && (!s || parseInt(s.split(".")[0]) < 80) || t === "ie")
+    return null;
+  const i = re(navigator);
+  if (pe(i))
+    return null;
+  const o = await navigator.serviceWorker.register(n);
+  try {
+    await navigator.serviceWorker.ready;
+  } catch {
+    return null;
+  }
+  const r = async () => await o.unregister();
+  o.addEventListener("updatefound", () => {
+    const w = o.installing;
+    w.addEventListener("statechange", () => {
+      switch (w.state) {
+        case "installed":
+          navigator.serviceWorker.controller && o.unregister().then(() => {
+            window.location.reload();
+          });
+          break;
+      }
+    });
+  });
+  const l = async (w) => b(o)({ type: "clear", data: { status: w }, configurationName: e }), c = async (w, A, v) => {
+    const O = await b(o)({
+      type: "init",
+      data: {
+        oidcServerConfiguration: w,
+        where: A,
+        oidcConfiguration: {
+          token_renew_mode: v.token_renew_mode,
+          service_worker_convert_all_requests_to_cors: v.service_worker_convert_all_requests_to_cors
+        }
+      },
+      configurationName: e
+    });
+    return { tokens: z(O.tokens, null, v.token_renew_mode), status: O.status };
+  }, d = () => {
+    Z == null && (Z = "not_null", ae());
+  }, a = (w) => b(o)({ type: "setSessionState", data: { sessionState: w }, configurationName: e }), h = async () => (await b(o)({ type: "getSessionState", data: null, configurationName: e })).sessionState, y = (w) => (sessionStorage["oidc.nonce"] = w.nonce, b(o)({ type: "setNonce", data: { nonce: w }, configurationName: e })), u = async () => {
+    let A = (await b(o)({ type: "getNonce", data: null, configurationName: e })).nonce;
+    return A || (A = sessionStorage["oidc.nonce"], console.warn("nonce not found in service worker, using sessionStorage")), { nonce: A };
+  };
+  let f = null;
+  return {
+    clearAsync: l,
+    initAsync: c,
+    startKeepAliveServiceWorker: d,
+    isServiceWorkerProxyActiveAsync: we,
+    setSessionStateAsync: a,
+    getSessionStateAsync: h,
+    setNonceAsync: y,
+    getNonceAsync: u,
+    unregisterAsync: r,
+    setLoginParams: (w, A) => {
+      f = A, localStorage[`oidc.login.${w}`] = JSON.stringify(A);
+    },
+    getLoginParams: (w) => {
+      const A = localStorage[`oidc.login.${w}`];
+      return f || (f = JSON.parse(A)), f;
+    },
+    getStateAsync: async () => {
+      let A = (await b(o)({ type: "getState", data: null, configurationName: e })).state;
+      return A || (A = sessionStorage[`oidc.state.${e}`], console.warn("state not found in service worker, using sessionStorage")), A;
+    },
+    setStateAsync: async (w) => (sessionStorage[`oidc.state.${e}`] = w, b(o)({ type: "setState", data: { state: w }, configurationName: e })),
+    getCodeVerifierAsync: async () => {
+      let A = (await b(o)({ type: "getCodeVerifier", data: null, configurationName: e })).codeVerifier;
+      return A || (A = sessionStorage[`oidc.code_verifier.${e}`], console.warn("codeVerifier not found in service worker, using sessionStorage")), A;
+    },
+    setCodeVerifierAsync: async (w) => (sessionStorage[`oidc.code_verifier.${e}`] = w, b(o)({ type: "setCodeVerifier", data: { codeVerifier: w }, configurationName: e }))
+  };
+};
+async function ce(n, e, t = !1, s = null) {
+  const i = (c) => {
+    n.tokens = c;
+  }, { tokens: o, status: r } = await n.synchroniseTokensAsync(e, 0, t, s, i);
+  if (await P(n.configuration.service_worker_relative_url, n.configurationName) || await I(n.configurationName, n.configuration.storage).setTokens(n.tokens), !n.tokens) {
+    await n.destroyAsync(r);
+    return;
+  }
+  return n.timeoutId && (n.timeoutId = M(n, o.refreshToken, n.tokens.expiresAt, s)), n.tokens;
+}
+const M = (n, e, t, s = null) => {
+  const i = n.configuration.refresh_time_before_tokens_expiration_in_second;
+  return V.setTimeout(async () => {
+    const r = { timeLeft: D(i, t) };
+    n.publishEvent(N.eventNames.token_timer, r), await ce(n, e, !1, s);
+  }, 1e3);
+}, Y = (n, e, t) => (s = null, i = null, o = null) => {
+  if (!e.silent_redirect_uri || !e.silent_login_uri)
+    return Promise.resolve(null);
+  try {
+    t(m.silentLoginAsync_begin, {});
+    let r = "";
+    if (i && (s == null && (s = {}), s.state = i), o && (s == null && (s = {}), s.scope = o), s != null)
+      for (const [h, y] of Object.entries(s))
+        r === "" ? r = `?${encodeURIComponent(h)}=${encodeURIComponent(y)}` : r += `&${encodeURIComponent(h)}=${encodeURIComponent(y)}`;
+    const l = e.silent_login_uri + r, c = l.indexOf("/", l.indexOf("//") + 2), d = l.substr(0, c), a = document.createElement("iframe");
+    return a.width = "0px", a.height = "0px", a.id = `${n}_oidc_iframe`, a.setAttribute("src", l), document.body.appendChild(a), new Promise((h, y) => {
+      try {
+        let u = !1;
+        window.onmessage = (_) => {
+          if (_.origin === d && _.source === a.contentWindow) {
+            const g = `${n}_oidc_tokens:`, k = `${n}_oidc_error:`, p = _.data;
+            if (p && typeof p == "string" && !u) {
+              if (p.startsWith(g)) {
+                const S = JSON.parse(_.data.replace(g, ""));
+                t(m.silentLoginAsync_end, {}), a.remove(), u = !0, h(S);
+              } else if (p.startsWith(k)) {
+                const S = JSON.parse(_.data.replace(k, ""));
+                t(m.silentLoginAsync_error, S), a.remove(), u = !0, y(new Error("oidc_" + S.error));
+              }
+            }
+          }
+        };
+        const f = e.silent_login_timeout;
+        setTimeout(() => {
+          u || (t(m.silentLoginAsync_error, { reason: "timeout" }), a.remove(), u = !0, y(new Error("timeout")));
+        }, f);
+      } catch (u) {
+        a.remove(), t(m.silentLoginAsync_error, u), y(u);
+      }
+    });
+  } catch (r) {
+    throw t(m.silentLoginAsync_error, r), r;
+  }
+}, Ae = (n, e, t, s, i) => (o = null, r = void 0) => {
+  o = { ...o };
+  const l = (d, a, h) => Y(e, t, s.bind(i))(d, a, h);
+  return (async () => {
+    i.timeoutId && V.clearTimeout(i.timeoutId);
+    let d;
+    o && "state" in o && (d = o.state, delete o.state);
+    try {
+      const a = t.extras ? { ...t.extras, ...o } : o, h = await l({
+        ...a,
+        prompt: "none"
+      }, d, r);
+      if (h)
+        return i.tokens = h.tokens, s(m.token_aquired, {}), i.timeoutId = M(i, i.tokens.refreshToken, i.tokens.expiresAt, o), {};
+    } catch (a) {
+      return a;
+    }
+  })();
+}, ve = (n, e, t) => (s, i, o, r = !1) => {
+  const l = (c, d = void 0, a = void 0) => Y(n.configurationName, t, n.publishEvent.bind(n))(c, d, a);
+  return new Promise((c, d) => {
+    if (t.silent_login_uri && t.silent_redirect_uri && t.monitor_session && s && o && !r) {
+      const a = () => {
+        n.checkSessionIFrame.stop();
+        const h = n.tokens;
+        if (h === null)
+          return;
+        const y = h.idToken, u = h.idTokenPayload;
+        return l({
+          prompt: "none",
+          id_token_hint: y,
+          scope: t.scope || "openid"
+        }).then((f) => {
+          const _ = f.tokens.idTokenPayload;
+          if (u.sub === _.sub) {
+            const g = f.sessionState;
+            n.checkSessionIFrame.start(f.sessionState), u.sid === _.sid ? console.debug("SessionMonitor._callback: Same sub still logged in at OP, restarting check session iframe; session_state:", g) : console.debug("SessionMonitor._callback: Same sub still logged in at OP, session state has changed, restarting check session iframe; session_state:", g);
+          } else
+            console.debug("SessionMonitor._callback: Different subject signed into OP:", _.sub);
+        }).catch(async (f) => {
+          console.warn("SessionMonitor._callback: Silent login failed, logging out other tabs:", f);
+          for (const [_, g] of Object.entries(e))
+            await g.logoutOtherTabAsync(t.client_id, u.sub);
+        });
+      };
+      n.checkSessionIFrame = new _e(a, i, s), n.checkSessionIFrame.load().then(() => {
+        n.checkSessionIFrame.start(o), c(n.checkSessionIFrame);
+      }).catch((h) => {
+        d(h);
+      });
+    } else
+      c(null);
+  });
+};
+var Se = Pe, E = [], ee = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+for (var U = 0, Te = ee.length; U < Te; ++U)
+  E[U] = ee[U];
+function be(n) {
+  return E[n >> 18 & 63] + E[n >> 12 & 63] + E[n >> 6 & 63] + E[n & 63];
+}
+function Ee(n, e, t) {
+  for (var s, i = [], o = e; o < t; o += 3)
+    s = (n[o] << 16 & 16711680) + (n[o + 1] << 8 & 65280) + (n[o + 2] & 255), i.push(be(s));
+  return i.join("");
+}
+function Pe(n) {
+  for (var e, t = n.length, s = t % 3, i = [], o = 16383, r = 0, l = t - s; r < l; r += o)
+    i.push(Ee(n, r, r + o > l ? l : r + o));
+  return s === 1 ? (e = n[t - 1], i.push(
+    E[e >> 2] + E[e << 4 & 63] + "=="
+  )) : s === 2 && (e = (n[t - 2] << 8) + n[t - 1], i.push(
+    E[e >> 10] + E[e >> 4 & 63] + E[e << 2 & 63] + "="
+  )), i.join("");
+}
+const le = () => {
+  const n = typeof window < "u" && !!window.crypto, e = n && !!window.crypto.subtle;
+  return { hasCrypto: n, hasSubtleCrypto: e };
+}, G = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", Ie = (n) => {
+  const e = [];
+  for (let t = 0; t < n.byteLength; t += 1) {
+    const s = n[t] % G.length;
+    e.push(G[s]);
+  }
+  return e.join("");
+}, Oe = (n) => Se(new Uint8Array(n)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, ""), J = (n) => {
+  const e = new Uint8Array(n), { hasCrypto: t } = le();
+  if (t)
+    window.crypto.getRandomValues(e);
+  else
+    for (let s = 0; s < n; s += 1)
+      e[s] = Math.random() * G.length | 0;
+  return Ie(e);
+};
+function Ce(n) {
+  const e = new ArrayBuffer(n.length), t = new Uint8Array(e);
+  for (let s = 0; s < n.length; s++)
+    t[s] = n.charCodeAt(s);
+  return t;
+}
+const Le = (n) => {
+  if (n.length < 43 || n.length > 128)
+    return Promise.reject(new Error("Invalid code length."));
+  const { hasSubtleCrypto: e } = le();
+  return e ? new Promise((t, s) => {
+    crypto.subtle.digest("SHA-256", Ce(n)).then((i) => t(Oe(new Uint8Array(i))), (i) => s(i));
+  }) : Promise.reject(new Error("window.crypto.subtle is unavailable."));
+}, F = {}, Ne = (n, e = window.sessionStorage, t) => {
+  if (!F[n] && e) {
+    const i = e.getItem(n);
+    i && (F[n] = JSON.parse(i));
+  }
+  const s = 1e3 * t;
+  return F[n] && F[n].timestamp + s > Date.now() ? F[n].result : null;
+}, We = (n, e, t = window.sessionStorage) => {
+  const s = Date.now();
+  F[n] = { result: e, timestamp: s }, t && t.setItem(n, JSON.stringify({ result: e, timestamp: s }));
+}, xe = 60 * 60, Fe = (n) => async (e, t = xe, s = window.sessionStorage, i = 1e4) => {
+  const o = `${e}/.well-known/openid-configuration`, r = `oidc.server:${e}`, l = Ne(r, s, t);
+  if (l)
+    return new X(l);
+  const c = await K(n)(o, {}, i);
+  if (c.status !== 200)
+    return null;
+  const d = await c.json();
+  return We(r, d, s), new X(d);
+}, K = (n) => async (e, t = {}, s = 1e4, i = 0) => {
+  let o;
+  try {
+    const r = new AbortController();
+    setTimeout(() => r.abort(), s), o = await n(e, { ...t, signal: r.signal });
+  } catch (r) {
+    if (r.name === "AbortError" || r.message === "Network request failed") {
+      if (i <= 1)
+        return await K(n)(e, t, s, i + 1);
+      throw r;
+    } else
+      throw console.error(r.message), r;
+  }
+  return o;
+}, H = {
+  refresh_token: "refresh_token",
+  access_token: "access_token"
+}, ne = (n) => async (e, t, s = H.refresh_token, i, o = 1e4) => {
+  const r = {
+    token: t,
+    token_type_hint: s,
+    client_id: i
+  }, l = [];
+  for (const a in r) {
+    const h = encodeURIComponent(a), y = encodeURIComponent(r[a]);
+    l.push(`${h}=${y}`);
+  }
+  const c = l.join("&");
+  return (await K(n)(e, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8"
+    },
+    body: c
+  }, o)).status !== 200 ? { success: !1 } : {
+    success: !0
+  };
+}, Re = (n) => async (e, t, s, i, o, r = 1e4) => {
+  for (const [h, y] of Object.entries(s))
+    t[h] === void 0 && (t[h] = y);
+  const l = [];
+  for (const h in t) {
+    const y = encodeURIComponent(h), u = encodeURIComponent(t[h]);
+    l.push(`${y}=${u}`);
+  }
+  const c = l.join("&"), d = await K(n)(e, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8"
+    },
+    body: c
+  }, r);
+  if (d.status !== 200)
+    return { success: !1, status: d.status };
+  const a = await d.json();
+  return {
+    success: !0,
+    data: z(a, i, o)
+  };
+}, $e = (n) => async (e, t) => {
+  t = t ? { ...t } : {};
+  const s = J(128), i = await Le(s);
+  await n.setCodeVerifierAsync(s), await n.setStateAsync(t.state), t.code_challenge = i, t.code_challenge_method = "S256";
+  let o = "";
+  if (t)
+    for (const [r, l] of Object.entries(t))
+      o === "" ? o += "?" : o += "&", o += `${r}=${encodeURIComponent(l)}`;
+  window.location.href = `${e}${o}`;
+}, De = (n) => async (e, t, s, i = 1e4) => {
+  t = t ? { ...t } : {}, t.code_verifier = await n.getCodeVerifierAsync();
+  const o = [];
+  for (const d in t) {
+    const a = encodeURIComponent(d), h = encodeURIComponent(t[d]);
+    o.push(`${a}=${h}`);
+  }
+  const r = o.join("&"), l = await K(fetch)(e, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8"
+    },
+    body: r
+  }, i);
+  if (await Promise.all([n.setCodeVerifierAsync(null), n.setStateAsync(null)]), l.status !== 200)
+    return { success: !1, status: l.status };
+  const c = await l.json();
+  return {
+    success: !0,
+    data: {
+      state: t.state,
+      tokens: z(c, null, s)
+    }
+  };
+}, ue = (n) => {
+  const e = n.match(
+    // eslint-disable-next-line no-useless-escape
+    /^([a-z][\w-]+\:)\/\/(([^:\/?#]*)(?:\:([0-9]+))?)([\/]{0,1}[^?#]*)(\?[^#]*|)(#.*|)$/
+  );
+  if (!e)
+    throw new Error("Invalid URL");
+  let t = e[6], s = e[7];
+  if (s) {
+    const i = s.split("?");
+    i.length === 2 && (s = i[0], t = i[1]);
+  }
+  return t.startsWith("?") && (t = t.slice(1)), e && {
+    href: n,
+    protocol: e[1],
+    host: e[2],
+    hostname: e[3],
+    port: e[4],
+    path: e[5],
+    search: t,
+    hash: s
+  };
+}, Xe = (n) => {
+  const e = ue(n);
+  let { path: t } = e;
+  t.endsWith("/") && (t = t.slice(0, -1));
+  let { hash: s } = e;
+  return s === "#_=_" && (s = ""), s && (t += s), t;
+}, B = (n) => {
+  const e = ue(n), { search: t } = e;
+  return Me(t);
+}, Me = (n) => {
+  const e = {};
+  let t, s, i;
+  const o = n.split("&");
+  for (s = 0, i = o.length; s < i; s++)
+    t = o[s].split("="), e[decodeURIComponent(t[0])] = decodeURIComponent(t[1]);
+  return e;
+}, Ve = (n, e, t, s, i) => (o = void 0, r = null, l = !1, c = void 0) => {
+  const d = r;
+  return r = { ...r }, (async () => {
+    const h = n.location, y = o || h.pathname + (h.search || "") + (h.hash || "");
+    if ("state" in r || (r.state = J(16)), s(m.loginAsync_begin, {}), r)
+      for (const u of Object.keys(r))
+        u.endsWith(":token_request") && delete r[u];
+    try {
+      const u = l ? t.silent_redirect_uri : t.redirect_uri;
+      c || (c = t.scope);
+      const f = t.extras ? { ...t.extras, ...r } : r;
+      f.nonce || (f.nonce = J(12));
+      const _ = { nonce: f.nonce }, g = await P(t.service_worker_relative_url, e), k = await i(t.authority, t.authority_configuration);
+      let p;
+      if (g)
+        g.setLoginParams(e, { callbackPath: y, extras: d }), g.startKeepAliveServiceWorker(), await g.initAsync(k, "loginAsync", t), await g.setNonceAsync(_), p = g;
+      else {
+        const T = I(e, t.storage ?? sessionStorage);
+        T.setLoginParams(e, { callbackPath: y, extras: d }), await T.setNonceAsync(_), p = T;
+      }
+      const S = {
+        client_id: t.client_id,
+        redirect_uri: u,
+        scope: c,
+        response_type: "code",
+        ...f
+      };
+      await $e(p)(k.authorizationEndpoint, S);
+    } catch (u) {
+      throw s(m.loginAsync_error, u), u;
+    }
+  })();
+}, Ke = (n) => async (e = !1) => {
+  try {
+    n.publishEvent(m.loginCallbackAsync_begin, {});
+    const t = n.configuration, s = t.client_id, i = e ? t.silent_redirect_uri : t.redirect_uri, o = t.authority, r = t.token_request_timeout, l = await n.initAsync(o, t.authority_configuration), d = B(window.location.href).session_state, a = await P(t.service_worker_relative_url, n.configurationName);
+    let h, y, u, f;
+    if (a)
+      a.startKeepAliveServiceWorker(), await a.initAsync(l, "loginCallbackAsync", t), await a.setSessionStateAsync(d), y = await a.getNonceAsync(), u = a.getLoginParams(n.configurationName), f = await a.getStateAsync(), h = a;
+    else {
+      const v = I(n.configurationName, t.storage ?? sessionStorage);
+      await v.setSessionStateAsync(d), y = await v.getNonceAsync(), u = v.getLoginParams(n.configurationName), f = await v.getStateAsync(), h = v;
+    }
+    const _ = B(window.location.toString());
+    if (_.iss && _.iss !== l.issuer)
+      throw new Error("issuer not valid");
+    if (_.state && _.state !== f)
+      throw new Error("state not valid");
+    const g = {
+      code: _.code,
+      grant_type: "authorization_code",
+      client_id: t.client_id,
+      redirect_uri: i
+    }, k = {};
+    if (t.token_request_extras)
+      for (const [v, O] of Object.entries(t.token_request_extras))
+        k[v] = O;
+    if (u && u.extras)
+      for (const [v, O] of Object.entries(u.extras))
+        v.endsWith(":token_request") && (k[v.replace(":token_request", "")] = O);
+    const p = await De(h)(l.tokenEndpoint, { ...g, ...k }, n.configuration.token_renew_mode, r);
+    if (!p.success)
+      throw new Error("Token request failed");
+    let S;
+    const T = p.data.tokens;
+    if (a ? (await a.initAsync(i, "syncTokensAsync", t), S = a.getLoginParams(n.configurationName)) : S = I(n.configurationName, t.storage).getLoginParams(n.configurationName), p.data.state !== k.state)
+      throw new Error("state is not valid");
+    const { isValid: w, reason: A } = ie(T, y.nonce, l);
+    if (!w)
+      throw new Error(`Tokens are not OpenID valid, reason: ${A}`);
+    return await n.startCheckSessionAsync(l.checkSessionIframe, s, d, e), n.publishEvent(m.loginCallbackAsync_end, {}), {
+      tokens: T,
+      state: "request.state",
+      callbackPath: S.callbackPath
+    };
+  } catch (t) {
+    throw console.error(t), n.publishEvent(m.loginCallbackAsync_error, t), t;
+  }
+}, te = {
+  access_token: "access_token",
+  refresh_token: "refresh_token"
+}, Ue = (n) => async (e) => {
+  V.clearTimeout(n.timeoutId), n.timeoutId = null, n.checkSessionIFrame && n.checkSessionIFrame.stop();
+  const t = await P(n.configuration.service_worker_relative_url, n.configurationName);
+  t ? await t.clearAsync(e) : await I(n.configurationName, n.configuration.storage).clearAsync(e), n.tokens = null, n.userInfo = null;
+}, Be = (n, e, t, s, i) => async (o = void 0, r = null) => {
+  const l = n.configuration, c = await n.initAsync(l.authority, l.authority_configuration);
+  o && typeof o != "string" && (o = void 0, i.warn("callbackPathOrUrl path is not a string"));
+  const d = o ?? location.pathname + (location.search || "") + (location.hash || "");
+  let a = !1;
+  o && (a = o.includes("https://") || o.includes("http://"));
+  const h = a ? o : s.location.origin + d, y = n.tokens ? n.tokens.idToken : "";
+  try {
+    const f = c.revocationEndpoint;
+    if (f) {
+      const _ = [], g = n.tokens.accessToken;
+      if (g && l.logout_tokens_to_invalidate.includes(te.access_token)) {
+        const p = ne(t)(f, g, H.access_token, l.client_id);
+        _.push(p);
+      }
+      const k = n.tokens.refreshToken;
+      if (k && l.logout_tokens_to_invalidate.includes(te.refresh_token)) {
+        const p = ne(t)(f, k, H.refresh_token, l.client_id);
+        _.push(p);
+      }
+      _.length > 0 && await Promise.all(_);
+    }
+  } catch (f) {
+    i.warn("logoutAsync: error when revoking tokens, if the error persist, you ay configure property logout_tokens_to_invalidate from configuration to avoid this error"), i.warn(f);
+  }
+  const u = n.tokens && n.tokens.idTokenPayload ? n.tokens.idTokenPayload.sub : null;
+  await n.destroyAsync("LOGGED_OUT");
+  for (const [f, _] of Object.entries(e))
+    _ !== n && await n.logoutSameTabAsync(n.configuration.client_id, u);
+  if (c.endSessionEndpoint) {
+    r || (r = {
+      id_token_hint: y
+    }, o !== null && (r.post_logout_redirect_uri = h));
+    let f = "";
+    if (r)
+      for (const [_, g] of Object.entries(r))
+        f === "" ? f += "?" : f += "&", f += `${_}=${encodeURIComponent(g)}`;
+    s.location.href = `${c.endSessionEndpoint}${f}`;
+  } else
+    s.location.reload();
+}, je = (n) => async (e = !1) => {
+  if (n.userInfo != null && !e)
+    return n.userInfo;
+  for (; n.tokens && !q(n.tokens); )
+    await $(200);
+  if (!n.tokens)
+    return null;
+  const t = n.tokens.accessToken;
+  if (!t)
+    return null;
+  const i = (await n.initAsync(n.configuration.authority, n.configuration.authority_configuration)).userInfoEndpoint, r = await (async (l) => {
+    const c = await fetch(i, {
+      headers: {
+        authorization: `Bearer ${l}`
+      }
+    });
+    return c.status !== 200 ? null : c.json();
+  })(t);
+  return n.userInfo = r, r;
+}, qe = () => fetch;
+class X {
+  constructor(e) {
+    this.authorizationEndpoint = e.authorization_endpoint, this.tokenEndpoint = e.token_endpoint, this.revocationEndpoint = e.revocation_endpoint, this.userInfoEndpoint = e.userinfo_endpoint, this.checkSessionIframe = e.check_session_iframe, this.issuer = e.issuer, this.endSessionEndpoint = e.end_session_endpoint;
+  }
+}
+const L = {}, Ge = (n) => (e, t = "default") => (L[t] || (L[t] = new N(e, t, n)), L[t]), Je = async (n) => {
+  const { parsedTokens: e, callbackPath: t } = await n.loginCallbackAsync();
+  return n.timeoutId = M(n, e.refreshToken, e.expiresAt), { callbackPath: t };
+}, He = (n) => Math.floor(Math.random() * n), C = class C {
+  constructor(e, t = "default", s) {
+    this.initPromise = null, this.tryKeepExistingSessionPromise = null, this.loginPromise = null, this.loginCallbackPromise = null, this.loginCallbackWithAutoTokensRenewPromise = null, this.userInfoPromise = null, this.renewTokensPromise = null, this.logoutPromise = null;
+    let i = e.silent_login_uri;
+    e.silent_redirect_uri && !e.silent_login_uri && (i = `${e.silent_redirect_uri.replace("-callback", "").replace("callback", "")}-login`);
+    let o = e.refresh_time_before_tokens_expiration_in_second ?? 120;
+    o > 60 && (o = o - Math.floor(Math.random() * 40)), e.logout_tokens_to_invalidate || (e.logout_tokens_to_invalidate = ["access_token", "refresh_token"]), e.authority_timeout_wellknowurl_in_millisecond || (e.authority_timeout_wellknowurl_in_millisecond = 1e4), this.configuration = {
+      ...e,
+      silent_login_uri: i,
+      monitor_session: e.monitor_session ?? !1,
+      refresh_time_before_tokens_expiration_in_second: o,
+      silent_login_timeout: e.silent_login_timeout ?? 12e3,
+      token_renew_mode: e.token_renew_mode ?? j.access_token_or_id_token_invalid
+    }, this.getFetch = s ?? qe, this.configurationName = t, this.tokens = null, this.userInfo = null, this.events = [], this.timeoutId = null, this.synchroniseTokensAsync.bind(this), this.loginCallbackWithAutoTokensRenewAsync.bind(this), this.initAsync.bind(this), this.loginCallbackAsync.bind(this), this.subscribeEvents.bind(this), this.removeEventSubscription.bind(this), this.publishEvent.bind(this), this.destroyAsync.bind(this), this.logoutAsync.bind(this), this.renewTokensAsync.bind(this), this.initAsync(this.configuration.authority, this.configuration.authority_configuration);
+  }
+  subscribeEvents(e) {
+    const t = He(9999999999999).toString();
+    return this.events.push({ id: t, func: e }), t;
+  }
+  removeEventSubscription(e) {
+    const t = this.events.filter((s) => s.id !== e);
+    this.events = t;
+  }
+  publishEvent(e, t) {
+    this.events.forEach((s) => {
+      s.func(e, t);
+    });
+  }
+  static get(e = "default") {
+    const t = typeof process > "u";
+    if (!Object.prototype.hasOwnProperty.call(L, e) && t)
+      throw Error(`OIDC library does seem initialized.
+Please checkout that you are using OIDC hook inside a <OidcProvider configurationName="${e}"></OidcProvider> compoment.`);
+    return L[e];
+  }
+  _silentLoginCallbackFromIFrame() {
+    if (this.configuration.silent_redirect_uri && this.configuration.silent_login_uri) {
+      const e = B(window.location.href);
+      window.top.postMessage(`${this.configurationName}_oidc_tokens:${JSON.stringify({ tokens: this.tokens, sessionState: e.session_state })}`, window.location.origin);
+    }
+  }
+  _silentLoginErrorCallbackFromIFrame() {
+    if (this.configuration.silent_redirect_uri && this.configuration.silent_login_uri) {
+      const e = B(window.location.href);
+      window.top.postMessage(`${this.configurationName}_oidc_error:${JSON.stringify({ error: e.error })}`, window.location.origin);
+    }
+  }
+  async silentLoginCallbackAsync() {
+    try {
+      await this.loginCallbackAsync(!0), this._silentLoginCallbackFromIFrame();
+    } catch (e) {
+      console.error(e), this._silentLoginErrorCallbackFromIFrame();
+    }
+  }
+  async initAsync(e, t) {
+    if (this.initPromise !== null)
+      return this.initPromise;
+    const s = async () => {
+      if (t != null)
+        return new X({
+          authorization_endpoint: t.authorization_endpoint,
+          end_session_endpoint: t.end_session_endpoint,
+          revocation_endpoint: t.revocation_endpoint,
+          token_endpoint: t.token_endpoint,
+          userinfo_endpoint: t.userinfo_endpoint,
+          check_session_iframe: t.check_session_iframe,
+          issuer: t.issuer
+        });
+      const o = await P(this.configuration.service_worker_relative_url, this.configurationName) ? window.localStorage : null;
+      return await Fe(this.getFetch())(e, this.configuration.authority_time_cache_wellknowurl_in_second ?? 60 * 60, o, this.configuration.authority_timeout_wellknowurl_in_millisecond);
+    };
+    return this.initPromise = s(), this.initPromise.then((i) => (this.initPromise = null, i));
+  }
+  async tryKeepExistingSessionAsync() {
+    if (this.tryKeepExistingSessionPromise !== null)
+      return this.tryKeepExistingSessionPromise;
+    const e = async () => {
+      let t;
+      if (this.tokens != null)
+        return !1;
+      this.publishEvent(m.tryKeepExistingSessionAsync_begin, {});
+      try {
+        const s = this.configuration, i = await this.initAsync(s.authority, s.authority_configuration);
+        if (t = await P(s.service_worker_relative_url, this.configurationName), t) {
+          const { tokens: o } = await t.initAsync(i, "tryKeepExistingSessionAsync", s);
+          if (o) {
+            t.startKeepAliveServiceWorker(), this.tokens = o;
+            const r = t.getLoginParams(this.configurationName);
+            this.timeoutId = M(this, this.tokens.refreshToken, this.tokens.expiresAt, r.extras);
+            const l = await t.getSessionStateAsync();
+            return await this.startCheckSessionAsync(i.check_session_iframe, s.client_id, l), this.publishEvent(m.tryKeepExistingSessionAsync_end, {
+              success: !0,
+              message: "tokens inside ServiceWorker are valid"
+            }), !0;
+          }
+          this.publishEvent(m.tryKeepExistingSessionAsync_end, {
+            success: !1,
+            message: "no exiting session found"
+          });
+        } else {
+          s.service_worker_relative_url && this.publishEvent(m.service_worker_not_supported_by_browser, {
+            message: "service worker is not supported by this browser"
+          });
+          const o = I(this.configurationName, s.storage ?? sessionStorage), { tokens: r } = await o.initAsync();
+          if (r) {
+            this.tokens = oe(r, null, s.token_renew_mode);
+            const l = o.getLoginParams(this.configurationName);
+            this.timeoutId = M(this, r.refreshToken, this.tokens.expiresAt, l.extras);
+            const c = await o.getSessionStateAsync();
+            return await this.startCheckSessionAsync(i.check_session_iframe, s.client_id, c), this.publishEvent(m.tryKeepExistingSessionAsync_end, {
+              success: !0,
+              message: "tokens inside storage are valid"
+            }), !0;
+          }
+        }
+        return this.publishEvent(m.tryKeepExistingSessionAsync_end, {
+          success: !1,
+          message: t ? "service worker sessions not retrieved" : "session storage sessions not retrieved"
+        }), !1;
+      } catch (s) {
+        return console.error(s), t && await t.clearAsync(), this.publishEvent(m.tryKeepExistingSessionAsync_error, "tokens inside ServiceWorker are invalid"), !1;
+      }
+    };
+    return this.tryKeepExistingSessionPromise = e(), this.tryKeepExistingSessionPromise.then((t) => (this.tryKeepExistingSessionPromise = null, t));
+  }
+  async startCheckSessionAsync(e, t, s, i = !1) {
+    await ve(this, L, this.configuration)(e, t, s, i);
+  }
+  async loginAsync(e = void 0, t = null, s = !1, i = void 0, o = !1) {
+    return this.loginPromise !== null ? this.loginPromise : o ? Ae(window, this.configurationName, this.configuration, this.publishEvent.bind(this), this)(t, i) : (this.loginPromise = Ve(window, this.configurationName, this.configuration, this.publishEvent.bind(this), this.initAsync.bind(this))(e, t, s, i), this.loginPromise.then((r) => (this.loginPromise = null, r)));
+  }
+  async loginCallbackAsync(e = !1) {
+    if (this.loginCallbackPromise !== null)
+      return this.loginCallbackPromise;
+    const t = async () => {
+      const s = await Ke(this)(e), i = s.tokens;
+      return this.tokens = i, await P(this.configuration.service_worker_relative_url, this.configurationName) || I(this.configurationName, this.configuration.storage).setTokens(i), this.publishEvent(C.eventNames.token_aquired, i), { parsedTokens: i, state: s.state, callbackPath: s.callbackPath };
+    };
+    return this.loginCallbackPromise = t(), this.loginCallbackPromise.then((s) => (this.loginCallbackPromise = null, s));
+  }
+  async synchroniseTokensAsync(e, t = 0, s = !1, i = null, o) {
+    for (; !navigator.onLine && document.hidden; )
+      await $(1e3), this.publishEvent(m.refreshTokensAsync, { message: "wait because navigator is offline and hidden" });
+    let r = 6;
+    for (; !navigator.onLine && r > 0; )
+      await $(1e3), r--, this.publishEvent(m.refreshTokensAsync, { message: `wait because navigator is offline try ${r}` });
+    let l = Math.floor(Math.random() * 15) + 10;
+    for (; document.hidden && l > 0; )
+      await $(1e3), l--, this.publishEvent(m.refreshTokensAsync, { message: `wait because navigator is hidden try ${l}` });
+    const d = document.hidden ? t : t + 1;
+    i || (i = {});
+    const a = this.configuration, h = (u, f, _ = null) => Y(this.configurationName, this.configuration, this.publishEvent.bind(this))(u, f, _), y = async () => {
+      try {
+        let u;
+        const f = await P(a.service_worker_relative_url, this.configurationName);
+        f ? u = f.getLoginParams(this.configurationName) : u = I(this.configurationName, a.storage).getLoginParams(this.configurationName);
+        const _ = await h({
+          ...u.extras,
+          ...i,
+          prompt: "none"
+        }, u.state);
+        if (_)
+          return o(_.tokens), this.publishEvent(C.eventNames.token_renewed, {}), { tokens: _.tokens, status: "LOGGED" };
+      } catch (u) {
+        if (console.error(u), this.publishEvent(m.refreshTokensAsync_silent_error, { message: "exceptionSilent", exception: u.message }), u && u.message && u.message.startsWith("oidc"))
+          return o(null), this.publishEvent(m.refreshTokensAsync_error, { message: "refresh token silent" }), { tokens: null, status: "SESSION_LOST" };
+      }
+      return this.publishEvent(m.refreshTokensAsync_error, { message: "refresh token silent return" }), await this.synchroniseTokensAsync(null, d, s, i, o);
+    };
+    if (t > 4)
+      return o(null), this.publishEvent(m.refreshTokensAsync_error, { message: "refresh token" }), { tokens: null, status: "SESSION_LOST" };
+    try {
+      const { status: u, tokens: f, nonce: _ } = await this.syncTokensInfoAsync(a, this.configurationName, this.tokens, s);
+      switch (u) {
+        case "SESSION_LOST":
+          return o(null), this.publishEvent(m.refreshTokensAsync_error, { message: "refresh token session lost" }), { tokens: null, status: "SESSION_LOST" };
+        case "NOT_CONNECTED":
+          return o(null), { tokens: null, status: null };
+        case "TOKENS_VALID":
+          return o(f), { tokens: f, status: "LOGGED_IN" };
+        case "TOKEN_UPDATED_BY_ANOTHER_TAB_TOKENS_VALID":
+          return o(f), this.publishEvent(C.eventNames.token_renewed, { reason: "TOKEN_UPDATED_BY_ANOTHER_TAB_TOKENS_VALID" }), { tokens: f, status: "LOGGED_IN" };
+        case "LOGOUT_FROM_ANOTHER_TAB":
+          return o(null), this.publishEvent(m.logout_from_another_tab, { status: "session syncTokensAsync" }), { tokens: null, status: "LOGGED_OUT" };
+        case "REQUIRE_SYNC_TOKENS":
+          return this.publishEvent(m.refreshTokensAsync_begin, { refreshToken: e, status: u, tryNumber: t }), await y();
+        default: {
+          if (this.publishEvent(m.refreshTokensAsync_begin, { refreshToken: e, status: u, tryNumber: t }), !e)
+            return await y();
+          const g = a.client_id, k = a.redirect_uri, p = a.authority, T = { ...a.token_request_extras ? a.token_request_extras : {} };
+          for (const [A, v] of Object.entries(i))
+            A.endsWith(":token_request") && (T[A.replace(":token_request", "")] = v);
+          return await (async () => {
+            const A = {
+              client_id: g,
+              redirect_uri: k,
+              grant_type: "refresh_token",
+              refresh_token: f.refreshToken
+            }, v = await this.initAsync(p, a.authority_configuration), O = document.hidden ? 1e4 : 3e4 * 10, W = await Re(this.getFetch())(v.tokenEndpoint, A, T, f, a.token_renew_mode, O);
+            if (W.success) {
+              const { isValid: de, reason: he } = ie(W.data, _.nonce, v);
+              return de ? (o(W.data), this.publishEvent(m.refreshTokensAsync_end, { success: W.success }), this.publishEvent(C.eventNames.token_renewed, { reason: "REFRESH_TOKEN" }), { tokens: W.data, status: "LOGGED_IN" }) : (o(null), this.publishEvent(m.refreshTokensAsync_error, { message: `refresh token return not valid tokens, reason: ${he}` }), { tokens: null, status: "SESSION_LOST" });
+            } else
+              return this.publishEvent(m.refreshTokensAsync_silent_error, {
+                message: "bad request",
+                tokenResponse: W
+              }), await this.synchroniseTokensAsync(e, d, s, i, o);
+          })();
+        }
+      }
+    } catch (u) {
+      return console.error(u), this.publishEvent(m.refreshTokensAsync_silent_error, { message: "exception", exception: u.message }), this.synchroniseTokensAsync(e, d, s, i, o);
+    }
+  }
+  async syncTokensInfoAsync(e, t, s, i = !1) {
+    const o = { nonce: null };
+    if (!s)
+      return { tokens: null, status: "NOT_CONNECTED", nonce: o };
+    let r = o;
+    const l = await this.initAsync(e.authority, e.authority_configuration), c = await P(e.service_worker_relative_url, t);
+    if (c) {
+      const { status: h, tokens: y } = await c.initAsync(l, "syncTokensAsync", e);
+      if (h === "LOGGED_OUT")
+        return { tokens: null, status: "LOGOUT_FROM_ANOTHER_TAB", nonce: o };
+      if (h === "SESSIONS_LOST")
+        return { tokens: null, status: "SESSIONS_LOST", nonce: o };
+      if (!h || !y)
+        return { tokens: null, status: "REQUIRE_SYNC_TOKENS", nonce: o };
+      if (y.issuedAt !== s.issuedAt) {
+        const f = D(e.refresh_time_before_tokens_expiration_in_second, y.expiresAt) > 0 ? "TOKEN_UPDATED_BY_ANOTHER_TAB_TOKENS_VALID" : "TOKEN_UPDATED_BY_ANOTHER_TAB_TOKENS_INVALID", _ = await c.getNonceAsync();
+        return { tokens: y, status: f, nonce: _ };
+      }
+      r = await c.getNonceAsync();
+    } else {
+      const h = I(t, e.storage ?? sessionStorage), { tokens: y, status: u } = await h.initAsync();
+      if (y) {
+        if (u === "SESSIONS_LOST")
+          return { tokens: null, status: "SESSIONS_LOST", nonce: o };
+        if (y.issuedAt !== s.issuedAt) {
+          const _ = D(e.refresh_time_before_tokens_expiration_in_second, y.expiresAt) > 0 ? "TOKEN_UPDATED_BY_ANOTHER_TAB_TOKENS_VALID" : "TOKEN_UPDATED_BY_ANOTHER_TAB_TOKENS_INVALID", g = await h.getNonceAsync();
+          return { tokens: y, status: _, nonce: g };
+        }
+      } else
+        return { tokens: null, status: "LOGOUT_FROM_ANOTHER_TAB", nonce: o };
+      r = await h.getNonceAsync();
+    }
+    const a = D(e.refresh_time_before_tokens_expiration_in_second, s.expiresAt) > 0 ? "TOKENS_VALID" : "TOKENS_INVALID";
+    return i ? { tokens: s, status: "FORCE_REFRESH", nonce: r } : { tokens: s, status: a, nonce: r };
+  }
+  loginCallbackWithAutoTokensRenewAsync() {
+    return this.loginCallbackWithAutoTokensRenewPromise !== null ? this.loginCallbackWithAutoTokensRenewPromise : (this.loginCallbackWithAutoTokensRenewPromise = Je(this), this.loginCallbackWithAutoTokensRenewPromise.then((e) => (this.loginCallbackWithAutoTokensRenewPromise = null, e)));
+  }
+  userInfoAsync(e = !1) {
+    return this.userInfoPromise !== null ? this.userInfoPromise : (this.userInfoPromise = je(this)(e), this.userInfoPromise.then((t) => (this.userInfoPromise = null, t)));
+  }
+  async renewTokensAsync(e = null) {
+    if (this.renewTokensPromise !== null)
+      return this.renewTokensPromise;
+    if (this.timeoutId)
+      return V.clearTimeout(this.timeoutId), this.renewTokensPromise = ce(this, this.tokens.refreshToken, !0, e), this.renewTokensPromise.then((t) => (this.renewTokensPromise = null, t));
+  }
+  async destroyAsync(e) {
+    return await Ue(this)(e);
+  }
+  async logoutSameTabAsync(e, t) {
+    this.configuration.monitor_session && this.configuration.client_id === e && t && this.tokens && this.tokens.idTokenPayload && this.tokens.idTokenPayload.sub === t && (this.publishEvent(m.logout_from_same_tab, { message: t }), await this.destroyAsync("LOGGED_OUT"));
+  }
+  async logoutOtherTabAsync(e, t) {
+    this.configuration.monitor_session && this.configuration.client_id === e && t && this.tokens && this.tokens.idTokenPayload && this.tokens.idTokenPayload.sub === t && (await this.destroyAsync("LOGGED_OUT"), this.publishEvent(m.logout_from_another_tab, { message: "SessionMonitor", sub: t }));
+  }
+  async logoutAsync(e = void 0, t = null) {
+    return this.logoutPromise ? this.logoutPromise : (this.logoutPromise = Be(this, L, this.getFetch(), window, console)(e, t), this.logoutPromise.then((s) => (this.logoutPromise = null, s)));
+  }
+};
+C.getOrCreate = (e) => (t, s = "default") => Ge(e)(t, s), C.eventNames = m;
+let N = C;
+const R = class R {
+  constructor(e) {
+    this._oidc = e;
+  }
+  subscribeEvents(e) {
+    return this._oidc.subscribeEvents(e);
+  }
+  removeEventSubscription(e) {
+    this._oidc.removeEventSubscription(e);
+  }
+  publishEvent(e, t) {
+    this._oidc.publishEvent(e, t);
+  }
+  static get(e = "default") {
+    return new R(N.get(e));
+  }
+  tryKeepExistingSessionAsync() {
+    return this._oidc.tryKeepExistingSessionAsync();
+  }
+  loginAsync(e = void 0, t = null, s = !1, i = void 0, o = !1) {
+    return this._oidc.loginAsync(e, t, s, i, o);
+  }
+  logoutAsync(e = void 0, t = null) {
+    return this._oidc.logoutAsync(e, t);
+  }
+  silentLoginCallbackAsync() {
+    return this._oidc.silentLoginCallbackAsync();
+  }
+  renewTokensAsync(e = null) {
+    return this._oidc.renewTokensAsync(e);
+  }
+  loginCallbackAsync() {
+    return this._oidc.loginCallbackWithAutoTokensRenewAsync();
+  }
+  get tokens() {
+    return this._oidc.tokens;
+  }
+  get configuration() {
+    return this._oidc.configuration;
+  }
+  async getValidTokenAsync(e = 200, t = 50) {
+    return ke(this._oidc, e, t);
+  }
+  async userInfoAsync(e = !1) {
+    return this._oidc.userInfoAsync(e);
+  }
+};
+R.getOrCreate = (e) => (t, s = "default") => new R(N.getOrCreate(e)(t, s)), R.eventNames = N.eventNames;
+let se = R;
+export {
+  j as TokenRenewMode,
+  se as VanillaOidc,
+  qe as getFetchDefault,
+  B as getParseQueryStringFromLocation,
+  Xe as getPath
+};