@jetbrains/ring-ui-built 6.0.31 → 6.0.32

package/components/auth/auth__core.js

@@ -1,49 +1,22 @@
-import { _ as _defineProperty, b as _createClass, d as _objectSpread2, f as _classCallCheck, k as _toConsumableArray, h as _asyncToGenerator, i as _regeneratorRuntime } from '../_helpers/_rollupPluginBabelHelpers.js';
-import 'core-js/modules/es.array.concat.js';
-import 'core-js/modules/es.array.filter.js';
-import 'core-js/modules/es.array.includes.js';
-import 'core-js/modules/es.array.iterator.js';
-import 'core-js/modules/es.object.to-string.js';
-import 'core-js/modules/es.promise.js';
-import 'core-js/modules/es.regexp.exec.js';
-import 'core-js/modules/es.regexp.to-string.js';
-import 'core-js/modules/es.set.js';
-import 'core-js/modules/es.string.includes.js';
-import 'core-js/modules/es.string.replace.js';
-import 'core-js/modules/es.string.search.js';
-import 'core-js/modules/web.dom-collections.iterator.js';
-import 'core-js/modules/web.url.js';
-import 'core-js/modules/web.url.to-json.js';
-import 'core-js/modules/web.url-search-params.js';
 import { getAbsoluteBaseURL, fixUrl } from '../global/url.js';
 import Listeners from '../global/listeners.js';
 import HTTP from '../http/http.js';
 import promiseWithTimeout from '../global/promise-with-timeout.js';
-import { translate, getTranslationsWithFallback, getTranslations } from '../i18n/i18n.js';
+import { getTranslationsWithFallback, translate, getTranslations } from '../i18n/i18n.js';
 import AuthStorage from './storage.js';
 import AuthResponseParser from './response-parser.js';
 import AuthRequestBuilder from './request-builder.js';
 import BackgroundFlow from './background-flow.js';
 import TokenValidator from './token-validator.js';
-import 'core-js/modules/es.array.index-of.js';
-import 'core-js/modules/es.string.match.js';
-import 'core-js/modules/es.array.map.js';
-import 'core-js/modules/es.map.js';
-import 'core-js/modules/es.object.entries.js';
-import 'core-js/modules/es.reflect.delete-property.js';
-import 'core-js/modules/es.weak-map.js';
-import 'core-js/modules/web.dom-collections.for-each.js';
 import 'es6-error';
-import 'core-js/modules/es.array.reduce.js';
-import 'core-js/modules/es.array.sort.js';
 import '../storage/storage.js';
 import '../storage/storage__local.js';
 import '../alert-service/alert-service.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
 import 'react';
 import 'react-dom/client';
 import '../global/get-uid.js';
 import '../alert/alert.js';
-import 'core-js/modules/es.object.values.js';
 import 'classnames';
 import 'prop-types';
 import '@jetbrains/icons/exception';
@@ -54,13 +27,10 @@ import '../icon/icon.js';
 import 'util-deprecate';
 import '../icon/icon__constants.js';
 import '../_helpers/icon__svg.js';
-import 'core-js/modules/es.string.starts-with.js';
 import '../global/memoize.js';
 import '../loader-inline/loader-inline.js';
 import '../global/data-tests.js';
 import '../global/dom.js';
-import 'core-js/modules/es.object.assign.js';
-import 'core-js/modules/es.string.split.js';
 import '../button/button.js';
 import '@jetbrains/icons/chevron-10px';
 import '../link/clickableLink.js';
@@ -73,9 +43,6 @@ import '../popup/popup.js';
 import '../global/schedule-raf.js';
 import '../shortcuts/shortcuts.js';
 import '../shortcuts/core.js';
-import 'core-js/modules/es.array.find-index.js';
-import 'core-js/modules/es.array.slice.js';
-import 'core-js/modules/es.array.splice.js';
 import 'combokeys';
 import '../global/sniffer.js';
 import 'sniffr';
@@ -88,19 +55,19 @@ import 'deep-equal';
 import 'simply-uuid';
 
 /* eslint-disable @typescript-eslint/no-magic-numbers */
-var DEFAULT_EXPIRES_TIMEOUT = 40 * 60;
-var DEFAULT_BACKGROUND_TIMEOUT = 10 * 1000;
-var DEFAULT_BACKEND_CHECK_TIMEOUT = 10 * 1000;
-var BACKGROUND_REDIRECT_TIMEOUT = 20 * 1000;
-var DEFAULT_WAIT_FOR_REDIRECT_TIMEOUT = 5 * 1000;
+const DEFAULT_EXPIRES_TIMEOUT = 40 * 60;
+const DEFAULT_BACKGROUND_TIMEOUT = 10 * 1000;
+const DEFAULT_BACKEND_CHECK_TIMEOUT = 10 * 1000;
+const BACKGROUND_REDIRECT_TIMEOUT = 20 * 1000;
+const DEFAULT_WAIT_FOR_REDIRECT_TIMEOUT = 5 * 1000;
 /* eslint-enable @typescript-eslint/no-magic-numbers */
-var USER_CHANGED_EVENT = 'userChange';
-var DOMAIN_USER_CHANGED_EVENT = 'domainUser';
-var LOGOUT_EVENT = 'logout';
-var LOGOUT_POSTPONED_EVENT = 'logoutPostponed';
-var USER_CHANGE_POSTPONED_EVENT = 'changePostponed';
+const USER_CHANGED_EVENT = 'userChange';
+const DOMAIN_USER_CHANGED_EVENT = 'domainUser';
+const LOGOUT_EVENT = 'logout';
+const LOGOUT_POSTPONED_EVENT = 'logoutPostponed';
+const USER_CHANGE_POSTPONED_EVENT = 'changePostponed';
 function noop() {}
-var DEFAULT_CONFIG = {
+const DEFAULT_CONFIG = {
   cacheCurrentUser: false,
   reloadOnUserChange: true,
   embeddedLogin: false,
@@ -114,78 +81,82 @@ var DEFAULT_CONFIG = {
   userFields: ['guest', 'id', 'name', 'login', 'profile/avatar/url'],
   cleanHash: true,
   onLogout: noop,
-  onPostponeChangedUser: function onPostponeChangedUser() {},
-  onPostponeLogout: function onPostponeLogout() {},
+  onPostponeChangedUser: () => {},
+  onPostponeLogout: () => {},
   enableBackendStatusCheck: true,
   backendCheckTimeout: DEFAULT_BACKEND_CHECK_TIMEOUT,
-  checkBackendIsUp: function checkBackendIsUp() {
-    return Promise.resolve(null);
-  },
-  onBackendDown: function onBackendDown() {
-    return function () {};
-  },
+  checkBackendIsUp: () => Promise.resolve(null),
+  onBackendDown: () => () => {},
   defaultExpiresIn: DEFAULT_EXPIRES_TIMEOUT,
   waitForRedirectTimeout: DEFAULT_WAIT_FOR_REDIRECT_TIMEOUT,
   translations: null
 };
-var Auth = /*#__PURE__*/function () {
-  function Auth(config) {
-    var _this = this;
-    _classCallCheck(this, Auth);
-    _defineProperty(this, "config", void 0);
-    _defineProperty(this, "listeners", new Listeners());
-    _defineProperty(this, "http", void 0);
-    _defineProperty(this, "_service", {});
-    _defineProperty(this, "_storage", null);
-    _defineProperty(this, "_responseParser", new AuthResponseParser());
-    _defineProperty(this, "_requestBuilder", null);
-    _defineProperty(this, "_backgroundFlow", void 0);
-    _defineProperty(this, "_embeddedFlow", null);
-    _defineProperty(this, "_tokenValidator", null);
-    _defineProperty(this, "_postponed", false);
-    _defineProperty(this, "_backendCheckPromise", null);
-    _defineProperty(this, "_authDialogService", undefined);
-    _defineProperty(this, "_domainStorage", void 0);
-    _defineProperty(this, "user", null);
-    _defineProperty(this, "_initDeferred", void 0);
-    _defineProperty(this, "_isLoginWindowOpen", void 0);
+class Auth {
+  static DEFAULT_CONFIG = DEFAULT_CONFIG;
+  static API_PATH = 'api/rest/';
+  static API_AUTH_PATH = 'oauth2/auth';
+  static API_PROFILE_PATH = 'users/me';
+  static CLOSE_BACKEND_DOWN_MESSAGE = 'backend-check-succeeded';
+  static CLOSE_WINDOW_MESSAGE = 'close-login-window';
+  static shouldRefreshToken = TokenValidator.shouldRefreshToken;
+  static storageIsUnavailable = !navigator.cookieEnabled;
+  config;
+  listeners = new Listeners();
+  http;
+  _service = {};
+  _storage = null;
+  _responseParser = new AuthResponseParser();
+  _requestBuilder = null;
+  _backgroundFlow;
+  _embeddedFlow = null;
+  _tokenValidator = null;
+  _postponed = false;
+  _backendCheckPromise = null;
+  _authDialogService = undefined;
+  _domainStorage;
+  user = null;
+  _initDeferred;
+  _isLoginWindowOpen;
+  constructor(config) {
     if (!config) {
       throw new Error('Config is required');
     }
     if (config.serverUri == null) {
       throw new Error('\"serverUri\" property is required');
     }
-    var unsupportedParams = ['redirect_uri', 'request_credentials', 'client_id'].filter(function (param) {
-      return config.hasOwnProperty(param);
-    });
+    const unsupportedParams = ['redirect_uri', 'request_credentials', 'client_id'].filter(param => config.hasOwnProperty(param));
     if (unsupportedParams.length !== 0) {
-      throw new Error("The following parameters are no longer supported: ".concat(unsupportedParams.join(', '), ". Please change them from snake_case to camelCase."));
+      throw new Error(`The following parameters are no longer supported: ${unsupportedParams.join(', ')}. Please change them from snake_case to camelCase.`);
     }
     config.userFields = config.userFields || [];
-    this.config = _objectSpread2(_objectSpread2({}, Auth.DEFAULT_CONFIG), config);
-    var _this$config = this.config,
-      clientId = _this$config.clientId,
-      redirect = _this$config.redirect,
-      redirectUri = _this$config.redirectUri,
-      requestCredentials = _this$config.requestCredentials,
-      scope = _this$config.scope;
-    var serverUriLength = this.config.serverUri.length;
+    this.config = {
+      ...Auth.DEFAULT_CONFIG,
+      ...config
+    };
+    const {
+      clientId,
+      redirect,
+      redirectUri,
+      requestCredentials,
+      scope
+    } = this.config;
+    const serverUriLength = this.config.serverUri.length;
     if (serverUriLength > 0 && this.config.serverUri.charAt(serverUriLength - 1) !== '/') {
       this.config.serverUri += '/';
     }
     this.config.userParams = {
       query: {
-        fields: _toConsumableArray(new Set(Auth.DEFAULT_CONFIG.userFields.concat(config.userFields))).join()
+        fields: [...new Set(Auth.DEFAULT_CONFIG.userFields.concat(config.userFields))].join()
       }
     };
     if (!scope.includes(Auth.DEFAULT_CONFIG.clientId)) {
       scope.push(Auth.DEFAULT_CONFIG.clientId);
     }
     this._storage = new AuthStorage({
-      messagePrefix: "".concat(clientId, "-message-"),
-      stateKeyPrefix: "".concat(clientId, "-states-"),
-      tokenKey: "".concat(clientId, "-token"),
-      userKey: "".concat(clientId, "-user-")
+      messagePrefix: `${clientId}-message-`,
+      stateKeyPrefix: `${clientId}-states-`,
+      tokenKey: `${clientId}-token`,
+      userKey: `${clientId}-user-`
     });
     this._domainStorage = new AuthStorage({
       messagePrefix: 'domain-message-'
@@ -198,7 +169,9 @@ var Auth = /*#__PURE__*/function () {
       requestCredentials,
       scopes: scope
     }, this._storage);
-    var backgroundRefreshTimeout = this.config.backgroundRefreshTimeout;
+    let {
+      backgroundRefreshTimeout
+    } = this.config;
     if (!backgroundRefreshTimeout) {
       backgroundRefreshTimeout = this.config.embeddedLogin ? DEFAULT_BACKGROUND_TIMEOUT : BACKGROUND_REDIRECT_TIMEOUT;
     }
@@ -207,1447 +180,749 @@ var Auth = /*#__PURE__*/function () {
       var _this$config$translat;
       this._embeddedFlow = new this.config.EmbeddedLoginFlow(this._requestBuilder, this._storage, (_this$config$translat = this.config.translations) !== null && _this$config$translat !== void 0 ? _this$config$translat : getTranslationsWithFallback());
     }
-    var API_BASE = this.config.serverUri + Auth.API_PATH;
-    var fetchConfig = config.fetchCredentials ? {
+    const API_BASE = this.config.serverUri + Auth.API_PATH;
+    const fetchConfig = config.fetchCredentials ? {
       credentials: config.fetchCredentials
     } : undefined;
     this.http = new HTTP(this, API_BASE, fetchConfig);
-    var getUser = /*#__PURE__*/function () {
-      var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(token) {
-        var user;
-        return _regeneratorRuntime().wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              _context.next = 2;
-              return _this.getUser(token);
-            case 2:
-              user = _context.sent;
-              _this.user = user;
-              return _context.abrupt("return", user);
-            case 5:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee);
-      }));
-      return function getUser(_x) {
-        return _ref.apply(this, arguments);
-      };
-    }();
+    const getUser = async token => {
+      const user = await this.getUser(token);
+      this.user = user;
+      return user;
+    };
     this._tokenValidator = new TokenValidator(this.config, getUser, this._storage);
     if (this.config.onLogout) {
       this.addListener(LOGOUT_EVENT, this.config.onLogout);
     }
     if (this.config.reloadOnUserChange) {
-      this.addListener(USER_CHANGED_EVENT, function () {
-        return _this._reloadCurrentPage();
-      });
+      this.addListener(USER_CHANGED_EVENT, () => this._reloadCurrentPage());
     }
-    this.addListener(LOGOUT_POSTPONED_EVENT, function () {
-      return _this._setPostponed(true);
-    });
-    this.addListener(USER_CHANGE_POSTPONED_EVENT, function () {
-      return _this._setPostponed(true);
-    });
-    this.addListener(USER_CHANGED_EVENT, function () {
-      return _this._setPostponed(false);
-    });
-    this.addListener(USER_CHANGED_EVENT, function (user) {
+    this.addListener(LOGOUT_POSTPONED_EVENT, () => this._setPostponed(true));
+    this.addListener(USER_CHANGE_POSTPONED_EVENT, () => this._setPostponed(true));
+    this.addListener(USER_CHANGED_EVENT, () => this._setPostponed(false));
+    this.addListener(USER_CHANGED_EVENT, user => {
       if (user) {
-        _this._updateDomainUser(user.id);
+        this._updateDomainUser(user.id);
       }
     });
     if (this.config.cacheCurrentUser) {
-      this.addListener(LOGOUT_EVENT, function () {
-        var _this$_storage;
-        return (_this$_storage = _this._storage) === null || _this$_storage === void 0 ? void 0 : _this$_storage.wipeCachedCurrentUser();
-      });
-      this.addListener(USER_CHANGED_EVENT, function () {
-        var _this$_storage2;
-        return (_this$_storage2 = _this._storage) === null || _this$_storage2 === void 0 ? void 0 : _this$_storage2.onUserChanged();
-      });
+      this.addListener(LOGOUT_EVENT, () => this._storage?.wipeCachedCurrentUser());
+      this.addListener(USER_CHANGED_EVENT, () => this._storage?.onUserChanged());
     }
     this._createInitDeferred();
     this.setUpPreconnect(config.serverUri);
   }
-  return _createClass(Auth, [{
-    key: "_setPostponed",
-    value: function _setPostponed() {
-      var postponed = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-      this._postponed = postponed;
-    }
-  }, {
-    key: "_updateDomainUser",
-    value: function _updateDomainUser(userID) {
-      this._domainStorage.sendMessage(DOMAIN_USER_CHANGED_EVENT, {
+  _setPostponed() {
+    let postponed = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    this._postponed = postponed;
+  }
+  _updateDomainUser(userID) {
+    this._domainStorage.sendMessage(DOMAIN_USER_CHANGED_EVENT, {
+      userID,
+      serviceID: this.config.clientId
+    });
+  }
+  addListener(event, handler) {
+    this.listeners.add(event, handler);
+  }
+  removeListener(event, handler) {
+    this.listeners.remove(event, handler);
+  }
+  setAuthDialogService(authDialogService) {
+    this._authDialogService = authDialogService;
+  }
+  setCurrentService(service) {
+    this._service = service;
+  }
+  _createInitDeferred() {
+    const deferred = {};
+    deferred.promise = new Promise((resolve, reject) => {
+      deferred.resolve = resolve;
+      deferred.reject = reject;
+    });
+    this._initDeferred = deferred;
+  }
+  /**
+   * @return {Promise.<string>} absolute URL promise that is resolved to a URL
+   * that should be restored after returning back from auth server.
+   */
+  async init() {
+    this._storage?.onTokenChange(async token => {
+      const isGuest = this.user ? this.user.guest : false;
+      if (isGuest && !token) {
+        return;
+      }
+      if (!token) {
+        this.logout();
+      } else {
+        try {
+          await this._detectUserChange(token.accessToken);
+        } catch (error) {
+          if (!(error instanceof Error)) {
+            throw error;
+          }
+          if (this._canShowDialogs()) {
+            this._showAuthDialog({
+              nonInteractive: true,
+              error
+            });
+          }
+        }
+      }
+    });
+    this._domainStorage.onMessage(DOMAIN_USER_CHANGED_EVENT, message => {
+      const {
         userID,
-        serviceID: this.config.clientId
-      });
+        serviceID
+      } = message || {};
+      if (serviceID === this.config.clientId) {
+        return;
+      }
+      if (this.user && userID === this.user.id) {
+        return;
+      }
+      this.forceTokenUpdate();
+    });
+    let state;
+    try {
+      // Look for token or error in hash
+      state = await this._checkForAuthResponse();
+    } catch (error) {
+      return error instanceof Error ? this.handleInitError(error) : undefined;
     }
-  }, {
-    key: "addListener",
-    value: function addListener(event, handler) {
-      this.listeners.add(event, handler);
+    // Return endless promise in the background to avoid service start
+    if (state && state.nonRedirect) {
+      return new Promise(noop);
     }
-  }, {
-    key: "removeListener",
-    value: function removeListener(event, handler) {
-      this.listeners.remove(event, handler);
+    try {
+      // Check if there is a valid token
+      await this._tokenValidator?.validateToken();
+      // Checking if there is a message left by another app on this domain
+      const message = await this._domainStorage._messagesStorage.get(`domain-message-${DOMAIN_USER_CHANGED_EVENT}`);
+      if (message) {
+        const {
+          userID,
+          serviceID
+        } = message;
+        if (serviceID !== this.config.clientId && (!userID || this.user?.id !== userID)) {
+          this.forceTokenUpdate();
+        }
+      }
+      // Access token appears to be valid.
+      // We may resolve restoreLocation URL now
+      if (!state) {
+        // Check if we have requested to restore state anyway
+        state = await this._checkForStateRestoration();
+      }
+      this._initDeferred?.resolve?.(state && state.restoreLocation);
+      return state?.restoreLocation;
+    } catch (error) {
+      if (Auth.storageIsUnavailable) {
+        this._initDeferred?.resolve?.(); // No way to handle if cookies are disabled
+        await this.requestUser(); // Someone may expect user to be loaded as a part of token validation
+        return null;
+      }
+      return error instanceof Error ? this.handleInitValidationError(error) : undefined;
     }
-  }, {
-    key: "setAuthDialogService",
-    value: function setAuthDialogService(authDialogService) {
-      this._authDialogService = authDialogService;
+  }
+  async sendRedirect(error) {
+    const authRequest = await this._requestBuilder?.prepareAuthRequest();
+    if (authRequest != null) {
+      this._redirectCurrentPage(authRequest.url);
     }
-  }, {
-    key: "setCurrentService",
-    value: function setCurrentService(service) {
-      this._service = service;
+    // HUB-10867 Since we already redirecting the page, there is no actual need to throw an error
+    // and scare user with flashing error
+    // But let's keep it just in case redirect was not successful
+    await new Promise(resolve => setTimeout(resolve, this.config.waitForRedirectTimeout));
+    throw error;
+  }
+  async handleInitError(error) {
+    if ('stateId' in error && error.stateId) {
+      try {
+        const state = await this._storage?.getState(error.stateId);
+        if (state && state.nonRedirect) {
+          state.error = error;
+          this._storage?.saveState(error.stateId, state);
+          // Return endless promise in the background to avoid service start
+          return new Promise(noop);
+        }
+      } catch (e) {
+        // Throw the original error instead below
+      }
     }
-  }, {
-    key: "_createInitDeferred",
-    value: function _createInitDeferred() {
-      var deferred = {};
-      deferred.promise = new Promise(function (resolve, reject) {
-        deferred.resolve = resolve;
-        deferred.reject = reject;
-      });
-      this._initDeferred = deferred;
+    throw error;
+  }
+  async handleInitValidationError(error) {
+    if ('cause' in error && error.cause instanceof Error && error.cause?.message === 'invalid_client') {
+      // eslint-disable-next-line no-console
+      console.error('RingUI Auth: invalid client detected. Logging out', error);
+      await this.logout();
+      return undefined;
     }
-    /**
-     * @return {Promise.<string>} absolute URL promise that is resolved to a URL
-     * that should be restored after returning back from auth server.
-     */
-  }, {
-    key: "init",
-    value: (function () {
-      var _init = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
-        var _this$_storage3,
-          _this2 = this;
-        var state, _this$_tokenValidator, _this$_initDeferred, _this$_initDeferred$r, _state, message, _this$user, userID, serviceID, _this$_initDeferred2, _this$_initDeferred2$;
-        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
-            case 0:
-              (_this$_storage3 = this._storage) === null || _this$_storage3 === void 0 || _this$_storage3.onTokenChange( /*#__PURE__*/function () {
-                var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(token) {
-                  var isGuest;
-                  return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-                    while (1) switch (_context2.prev = _context2.next) {
-                      case 0:
-                        isGuest = _this2.user ? _this2.user.guest : false;
-                        if (!(isGuest && !token)) {
-                          _context2.next = 3;
-                          break;
-                        }
-                        return _context2.abrupt("return");
-                      case 3:
-                        if (token) {
-                          _context2.next = 7;
-                          break;
-                        }
-                        _this2.logout();
-                        _context2.next = 17;
-                        break;
-                      case 7:
-                        _context2.prev = 7;
-                        _context2.next = 10;
-                        return _this2._detectUserChange(token.accessToken);
-                      case 10:
-                        _context2.next = 17;
-                        break;
-                      case 12:
-                        _context2.prev = 12;
-                        _context2.t0 = _context2["catch"](7);
-                        if (_context2.t0 instanceof Error) {
-                          _context2.next = 16;
-                          break;
-                        }
-                        throw _context2.t0;
-                      case 16:
-                        if (_this2._canShowDialogs()) {
-                          _this2._showAuthDialog({
-                            nonInteractive: true,
-                            error: _context2.t0
-                          });
-                        }
-                      case 17:
-                      case "end":
-                        return _context2.stop();
-                    }
-                  }, _callee2, null, [[7, 12]]);
-                }));
-                return function (_x2) {
-                  return _ref2.apply(this, arguments);
-                };
-              }());
-              this._domainStorage.onMessage(DOMAIN_USER_CHANGED_EVENT, function (message) {
-                var _ref3 = message || {},
-                  userID = _ref3.userID,
-                  serviceID = _ref3.serviceID;
-                if (serviceID === _this2.config.clientId) {
-                  return;
-                }
-                if (_this2.user && userID === _this2.user.id) {
-                  return;
-                }
-                _this2.forceTokenUpdate();
-              });
-              _context3.prev = 2;
-              _context3.next = 5;
-              return this._checkForAuthResponse();
-            case 5:
-              state = _context3.sent;
-              _context3.next = 11;
-              break;
-            case 8:
-              _context3.prev = 8;
-              _context3.t0 = _context3["catch"](2);
-              return _context3.abrupt("return", _context3.t0 instanceof Error ? this.handleInitError(_context3.t0) : undefined);
-            case 11:
-              if (!(state && state.nonRedirect)) {
-                _context3.next = 13;
-                break;
-              }
-              return _context3.abrupt("return", new Promise(noop));
-            case 13:
-              _context3.prev = 13;
-              _context3.next = 16;
-              return (_this$_tokenValidator = this._tokenValidator) === null || _this$_tokenValidator === void 0 ? void 0 : _this$_tokenValidator.validateToken();
-            case 16:
-              _context3.next = 18;
-              return this._domainStorage._messagesStorage.get("domain-message-".concat(DOMAIN_USER_CHANGED_EVENT));
-            case 18:
-              message = _context3.sent;
-              if (message) {
-                userID = message.userID, serviceID = message.serviceID;
-                if (serviceID !== this.config.clientId && (!userID || ((_this$user = this.user) === null || _this$user === void 0 ? void 0 : _this$user.id) !== userID)) {
-                  this.forceTokenUpdate();
-                }
-              }
-              // Access token appears to be valid.
-              // We may resolve restoreLocation URL now
-              if (state) {
-                _context3.next = 24;
-                break;
-              }
-              _context3.next = 23;
-              return this._checkForStateRestoration();
-            case 23:
-              state = _context3.sent;
-            case 24:
-              (_this$_initDeferred = this._initDeferred) === null || _this$_initDeferred === void 0 || (_this$_initDeferred$r = _this$_initDeferred.resolve) === null || _this$_initDeferred$r === void 0 || _this$_initDeferred$r.call(_this$_initDeferred, state && state.restoreLocation);
-              return _context3.abrupt("return", (_state = state) === null || _state === void 0 ? void 0 : _state.restoreLocation);
-            case 28:
-              _context3.prev = 28;
-              _context3.t1 = _context3["catch"](13);
-              if (!Auth.storageIsUnavailable) {
-                _context3.next = 35;
-                break;
-              }
-              (_this$_initDeferred2 = this._initDeferred) === null || _this$_initDeferred2 === void 0 || (_this$_initDeferred2$ = _this$_initDeferred2.resolve) === null || _this$_initDeferred2$ === void 0 || _this$_initDeferred2$.call(_this$_initDeferred2); // No way to handle if cookies are disabled
-              _context3.next = 34;
-              return this.requestUser();
-            case 34:
-              return _context3.abrupt("return", null);
-            case 35:
-              return _context3.abrupt("return", _context3.t1 instanceof Error ? this.handleInitValidationError(_context3.t1) : undefined);
-            case 36:
-            case "end":
-              return _context3.stop();
-          }
-        }, _callee3, this, [[2, 8], [13, 28]]);
-      }));
-      function init() {
-        return _init.apply(this, arguments);
-      }
-      return init;
-    }())
-  }, {
-    key: "sendRedirect",
-    value: function () {
-      var _sendRedirect = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(error) {
-        var _this$_requestBuilder,
-          _this3 = this;
-        var authRequest;
-        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
-          while (1) switch (_context4.prev = _context4.next) {
-            case 0:
-              _context4.next = 2;
-              return (_this$_requestBuilder = this._requestBuilder) === null || _this$_requestBuilder === void 0 ? void 0 : _this$_requestBuilder.prepareAuthRequest();
-            case 2:
-              authRequest = _context4.sent;
-              if (authRequest != null) {
-                this._redirectCurrentPage(authRequest.url);
-              }
-              // HUB-10867 Since we already redirecting the page, there is no actual need to throw an error
-              // and scare user with flashing error
-              // But let's keep it just in case redirect was not successful
-              _context4.next = 6;
-              return new Promise(function (resolve) {
-                return setTimeout(resolve, _this3.config.waitForRedirectTimeout);
-              });
-            case 6:
-              throw error;
-            case 7:
-            case "end":
-              return _context4.stop();
-          }
-        }, _callee4, this);
-      }));
-      function sendRedirect(_x3) {
-        return _sendRedirect.apply(this, arguments);
+    // Redirect flow
+    if ('authRedirect' in error && error.authRedirect && this.config.redirect) {
+      return this.sendRedirect(error);
+    }
+    // Background flow
+    if ('authRedirect' in error && error.authRedirect && !this.config.redirect) {
+      try {
+        await this._backgroundFlow?.authorize();
+        await this._tokenValidator?.validateToken();
+        this._initDeferred?.resolve?.();
+        return undefined;
+      } catch (validationError) {
+        // Fallback to redirect flow
+        return validationError instanceof Error ? this.sendRedirect(validationError) : undefined;
       }
-      return sendRedirect;
-    }()
-  }, {
-    key: "handleInitError",
-    value: function () {
-      var _handleInitError = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(error) {
-        var _this$_storage4, state, _this$_storage5;
-        return _regeneratorRuntime().wrap(function _callee5$(_context5) {
-          while (1) switch (_context5.prev = _context5.next) {
-            case 0:
-              if (!('stateId' in error && error.stateId)) {
-                _context5.next = 13;
-                break;
-              }
-              _context5.prev = 1;
-              _context5.next = 4;
-              return (_this$_storage4 = this._storage) === null || _this$_storage4 === void 0 ? void 0 : _this$_storage4.getState(error.stateId);
-            case 4:
-              state = _context5.sent;
-              if (!(state && state.nonRedirect)) {
-                _context5.next = 9;
-                break;
-              }
-              state.error = error;
-              (_this$_storage5 = this._storage) === null || _this$_storage5 === void 0 || _this$_storage5.saveState(error.stateId, state);
-              // Return endless promise in the background to avoid service start
-              return _context5.abrupt("return", new Promise(noop));
-            case 9:
-              _context5.next = 13;
-              break;
-            case 11:
-              _context5.prev = 11;
-              _context5.t0 = _context5["catch"](1);
-            case 13:
-              throw error;
-            case 14:
-            case "end":
-              return _context5.stop();
-          }
-        }, _callee5, this, [[1, 11]]);
-      }));
-      function handleInitError(_x4) {
-        return _handleInitError.apply(this, arguments);
+    }
+    this._initDeferred?.reject?.(error);
+    throw error;
+  }
+  /**
+   * Get token from local storage or request it if necessary.
+   * Can redirect to login page.
+   * @return {Promise.<string>}
+   */
+  async requestToken() {
+    if (this._postponed) {
+      throw new Error('You should log in to be able to make requests');
+    }
+    try {
+      var _await$this$_tokenVal;
+      await this._initDeferred?.promise;
+      if (Auth.storageIsUnavailable) {
+        return null; // Forever guest if storage is unavailable
       }
-      return handleInitError;
-    }()
-  }, {
-    key: "handleInitValidationError",
-    value: function () {
-      var _handleInitValidationError = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(error) {
-        var _error$cause, _this$_initDeferred4, _this$_initDeferred4$;
-        var _this$_backgroundFlow, _this$_tokenValidator2, _this$_initDeferred3, _this$_initDeferred3$;
-        return _regeneratorRuntime().wrap(function _callee6$(_context6) {
-          while (1) switch (_context6.prev = _context6.next) {
-            case 0:
-              if (!('cause' in error && error.cause instanceof Error && ((_error$cause = error.cause) === null || _error$cause === void 0 ? void 0 : _error$cause.message) === 'invalid_client')) {
-                _context6.next = 5;
-                break;
-              }
-              // eslint-disable-next-line no-console
-              console.error('RingUI Auth: invalid client detected. Logging out', error);
-              _context6.next = 4;
-              return this.logout();
-            case 4:
-              return _context6.abrupt("return", undefined);
-            case 5:
-              if (!('authRedirect' in error && error.authRedirect && this.config.redirect)) {
-                _context6.next = 7;
-                break;
-              }
-              return _context6.abrupt("return", this.sendRedirect(error));
-            case 7:
-              if (!('authRedirect' in error && error.authRedirect && !this.config.redirect)) {
-                _context6.next = 20;
-                break;
-              }
-              _context6.prev = 8;
-              _context6.next = 11;
-              return (_this$_backgroundFlow = this._backgroundFlow) === null || _this$_backgroundFlow === void 0 ? void 0 : _this$_backgroundFlow.authorize();
-            case 11:
-              _context6.next = 13;
-              return (_this$_tokenValidator2 = this._tokenValidator) === null || _this$_tokenValidator2 === void 0 ? void 0 : _this$_tokenValidator2.validateToken();
-            case 13:
-              (_this$_initDeferred3 = this._initDeferred) === null || _this$_initDeferred3 === void 0 || (_this$_initDeferred3$ = _this$_initDeferred3.resolve) === null || _this$_initDeferred3$ === void 0 || _this$_initDeferred3$.call(_this$_initDeferred3);
-              return _context6.abrupt("return", undefined);
-            case 17:
-              _context6.prev = 17;
-              _context6.t0 = _context6["catch"](8);
-              return _context6.abrupt("return", _context6.t0 instanceof Error ? this.sendRedirect(_context6.t0) : undefined);
-            case 20:
-              (_this$_initDeferred4 = this._initDeferred) === null || _this$_initDeferred4 === void 0 || (_this$_initDeferred4$ = _this$_initDeferred4.reject) === null || _this$_initDeferred4$ === void 0 || _this$_initDeferred4$.call(_this$_initDeferred4, error);
-              throw error;
-            case 22:
-            case "end":
-              return _context6.stop();
-          }
-        }, _callee6, this, [[8, 17]]);
-      }));
-      function handleInitValidationError(_x5) {
-        return _handleInitValidationError.apply(this, arguments);
+      return (_await$this$_tokenVal = await this._tokenValidator?.validateTokenLocally()) !== null && _await$this$_tokenVal !== void 0 ? _await$this$_tokenVal : null;
+    } catch (e) {
+      return this.forceTokenUpdate();
+    }
+  }
+  /**
+   * Get new token in the background or redirect to the login page.
+   * @return {Promise.<string>}
+   */
+  async forceTokenUpdate() {
+    try {
+      if (!this._backendCheckPromise) {
+        this._backendCheckPromise = this._checkBackendsStatusesIfEnabled();
       }
-      return handleInitValidationError;
-    }()
-    /**
-     * Get token from local storage or request it if necessary.
-     * Can redirect to login page.
-     * @return {Promise.<string>}
-     */
-  }, {
-    key: "requestToken",
-    value: (function () {
-      var _requestToken = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7() {
-        var _this$_initDeferred5, _yield$this$_tokenVal, _this$_tokenValidator3;
-        return _regeneratorRuntime().wrap(function _callee7$(_context7) {
-          while (1) switch (_context7.prev = _context7.next) {
-            case 0:
-              if (!this._postponed) {
-                _context7.next = 2;
-                break;
-              }
-              throw new Error('You should log in to be able to make requests');
-            case 2:
-              _context7.prev = 2;
-              _context7.next = 5;
-              return (_this$_initDeferred5 = this._initDeferred) === null || _this$_initDeferred5 === void 0 ? void 0 : _this$_initDeferred5.promise;
-            case 5:
-              if (!Auth.storageIsUnavailable) {
-                _context7.next = 7;
-                break;
-              }
-              return _context7.abrupt("return", null);
-            case 7:
-              _context7.next = 9;
-              return (_this$_tokenValidator3 = this._tokenValidator) === null || _this$_tokenValidator3 === void 0 ? void 0 : _this$_tokenValidator3.validateTokenLocally();
-            case 9:
-              _context7.t1 = _yield$this$_tokenVal = _context7.sent;
-              _context7.t0 = _context7.t1 !== null;
-              if (!_context7.t0) {
-                _context7.next = 13;
-                break;
-              }
-              _context7.t0 = _yield$this$_tokenVal !== void 0;
-            case 13:
-              if (!_context7.t0) {
-                _context7.next = 17;
-                break;
-              }
-              _context7.t2 = _yield$this$_tokenVal;
-              _context7.next = 18;
-              break;
-            case 17:
-              _context7.t2 = null;
-            case 18:
-              return _context7.abrupt("return", _context7.t2);
-            case 21:
-              _context7.prev = 21;
-              _context7.t3 = _context7["catch"](2);
-              return _context7.abrupt("return", this.forceTokenUpdate());
-            case 24:
-            case "end":
-              return _context7.stop();
-          }
-        }, _callee7, this, [[2, 21]]);
-      }));
-      function requestToken() {
-        return _requestToken.apply(this, arguments);
+      await this._backendCheckPromise;
+    } catch (e) {
+      throw new Error('Cannot refresh token: backend is not available. Postponed by user.');
+    } finally {
+      this._backendCheckPromise = null;
+    }
+    try {
+      var _await$this$_backgrou;
+      return (_await$this$_backgrou = await this._backgroundFlow?.authorize()) !== null && _await$this$_backgrou !== void 0 ? _await$this$_backgrou : null;
+    } catch (error) {
+      if (!(error instanceof Error)) {
+        return null;
       }
-      return requestToken;
-    }()
-    /**
-     * Get new token in the background or redirect to the login page.
-     * @return {Promise.<string>}
-     */
-    )
-  }, {
-    key: "forceTokenUpdate",
-    value: (function () {
-      var _forceTokenUpdate = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9() {
-        var _this4 = this;
-        var _yield$this$_backgrou, _this$_backgroundFlow2, _this$_requestBuilder2, authRequest;
-        return _regeneratorRuntime().wrap(function _callee9$(_context9) {
-          while (1) switch (_context9.prev = _context9.next) {
-            case 0:
-              _context9.prev = 0;
-              if (!this._backendCheckPromise) {
-                this._backendCheckPromise = this._checkBackendsStatusesIfEnabled();
-              }
-              _context9.next = 4;
-              return this._backendCheckPromise;
-            case 4:
-              _context9.next = 9;
-              break;
-            case 6:
-              _context9.prev = 6;
-              _context9.t0 = _context9["catch"](0);
-              throw new Error('Cannot refresh token: backend is not available. Postponed by user.');
-            case 9:
-              _context9.prev = 9;
-              this._backendCheckPromise = null;
-              return _context9.finish(9);
-            case 12:
-              _context9.prev = 12;
-              _context9.next = 15;
-              return (_this$_backgroundFlow2 = this._backgroundFlow) === null || _this$_backgroundFlow2 === void 0 ? void 0 : _this$_backgroundFlow2.authorize();
-            case 15:
-              _context9.t2 = _yield$this$_backgrou = _context9.sent;
-              _context9.t1 = _context9.t2 !== null;
-              if (!_context9.t1) {
-                _context9.next = 19;
-                break;
-              }
-              _context9.t1 = _yield$this$_backgrou !== void 0;
-            case 19:
-              if (!_context9.t1) {
-                _context9.next = 23;
-                break;
-              }
-              _context9.t3 = _yield$this$_backgrou;
-              _context9.next = 24;
-              break;
-            case 23:
-              _context9.t3 = null;
-            case 24:
-              return _context9.abrupt("return", _context9.t3);
-            case 27:
-              _context9.prev = 27;
-              _context9.t4 = _context9["catch"](12);
-              if (_context9.t4 instanceof Error) {
-                _context9.next = 31;
-                break;
-              }
-              return _context9.abrupt("return", null);
-            case 31:
-              if (!this._canShowDialogs()) {
-                _context9.next = 35;
-                break;
-              }
-              return _context9.abrupt("return", new Promise(function (resolve) {
-                var onTryAgain = /*#__PURE__*/function () {
-                  var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8() {
-                    var _this4$_backgroundFlo, result;
-                    return _regeneratorRuntime().wrap(function _callee8$(_context8) {
-                      while (1) switch (_context8.prev = _context8.next) {
-                        case 0:
-                          _context8.prev = 0;
-                          _context8.next = 3;
-                          return (_this4$_backgroundFlo = _this4._backgroundFlow) === null || _this4$_backgroundFlo === void 0 ? void 0 : _this4$_backgroundFlo.authorize();
-                        case 3:
-                          result = _context8.sent;
-                          resolve(result !== null && result !== void 0 ? result : null);
-                          _context8.next = 11;
-                          break;
-                        case 7:
-                          _context8.prev = 7;
-                          _context8.t0 = _context8["catch"](0);
-                          if (_context8.t0 instanceof Error) {
-                            _this4._showAuthDialog({
-                              nonInteractive: true,
-                              error: _context8.t0,
-                              onTryAgain
-                            });
-                          }
-                          throw _context8.t0;
-                        case 11:
-                        case "end":
-                          return _context8.stop();
-                      }
-                    }, _callee8, null, [[0, 7]]);
-                  }));
-                  return function onTryAgain() {
-                    return _ref4.apply(this, arguments);
-                  };
-                }();
-                _this4._showAuthDialog({
+      if (this._canShowDialogs()) {
+        return new Promise(resolve => {
+          const onTryAgain = async () => {
+            try {
+              const result = await this._backgroundFlow?.authorize();
+              resolve(result !== null && result !== void 0 ? result : null);
+            } catch (retryError) {
+              if (retryError instanceof Error) {
+                this._showAuthDialog({
                   nonInteractive: true,
-                  error: _context9.t4,
+                  error: retryError,
                   onTryAgain
                 });
-              }));
-            case 35:
-              _context9.next = 37;
-              return (_this$_requestBuilder2 = this._requestBuilder) === null || _this$_requestBuilder2 === void 0 ? void 0 : _this$_requestBuilder2.prepareAuthRequest();
-            case 37:
-              authRequest = _context9.sent;
-              if (authRequest != null) {
-                this._redirectCurrentPage(authRequest.url);
-              }
-            case 39:
-              throw new TokenValidator.TokenValidationError(_context9.t4.message);
-            case 40:
-            case "end":
-              return _context9.stop();
-          }
-        }, _callee9, this, [[0, 6, 9, 12], [12, 27]]);
-      }));
-      function forceTokenUpdate() {
-        return _forceTokenUpdate.apply(this, arguments);
-      }
-      return forceTokenUpdate;
-    }())
-  }, {
-    key: "loadCurrentService",
-    value: function () {
-      var _loadCurrentService = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10() {
-        var _ref5, serviceName, serviceImage;
-        return _regeneratorRuntime().wrap(function _callee10$(_context10) {
-          while (1) switch (_context10.prev = _context10.next) {
-            case 0:
-              if (!this._service.serviceName) {
-                _context10.next = 2;
-                break;
-              }
-              return _context10.abrupt("return");
-            case 2:
-              _context10.prev = 2;
-              _context10.next = 5;
-              return this.http.get("oauth2/interactive/login/settings?client_id=".concat(this.config.clientId));
-            case 5:
-              _context10.t0 = _context10.sent;
-              if (_context10.t0) {
-                _context10.next = 8;
-                break;
               }
-              _context10.t0 = {};
-            case 8:
-              _ref5 = _context10.t0;
-              serviceName = _ref5.serviceName;
-              serviceImage = _ref5.iconUrl;
-              this.setCurrentService({
-                serviceImage,
-                serviceName
-              });
-              _context10.next = 16;
-              break;
-            case 14:
-              _context10.prev = 14;
-              _context10.t1 = _context10["catch"](2);
-            case 16:
-            case "end":
-              return _context10.stop();
-          }
-        }, _callee10, this, [[2, 14]]);
-      }));
-      function loadCurrentService() {
-        return _loadCurrentService.apply(this, arguments);
-      }
-      return loadCurrentService;
-    }()
-  }, {
-    key: "getAPIPath",
-    value: function getAPIPath() {
-      return this.config.serverUri + Auth.API_PATH;
-    }
-    /**
-     * @return {Promise.<object>}
-     */
-  }, {
-    key: "getUser",
-    value: function getUser(accessToken) {
-      var _this5 = this;
-      if (this.config.cacheCurrentUser) {
-        var _this$_storage6;
-        return (_this$_storage6 = this._storage) === null || _this$_storage6 === void 0 ? void 0 : _this$_storage6.getCachedUser(function () {
-          return _this5.http.authorizedFetch(Auth.API_PROFILE_PATH, accessToken, _this5.config.userParams);
+              throw retryError;
+            }
+          };
+          this._showAuthDialog({
+            nonInteractive: true,
+            error: error,
+            onTryAgain
+          });
         });
       } else {
-        return this.http.authorizedFetch(Auth.API_PROFILE_PATH, accessToken, this.config.userParams);
+        const authRequest = await this._requestBuilder?.prepareAuthRequest();
+        if (authRequest != null) {
+          this._redirectCurrentPage(authRequest.url);
+        }
       }
+      throw new TokenValidator.TokenValidationError(error.message);
     }
-    /**
-     * @return {Promise.<object>}
-     */
-  }, {
-    key: "requestUser",
-    value: (function () {
-      var _requestUser = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11() {
-        var accessToken, user;
-        return _regeneratorRuntime().wrap(function _callee11$(_context11) {
-          while (1) switch (_context11.prev = _context11.next) {
-            case 0:
-              if (!this.user) {
-                _context11.next = 2;
-                break;
-              }
-              return _context11.abrupt("return", this.user);
-            case 2:
-              _context11.next = 4;
-              return this.requestToken();
-            case 4:
-              accessToken = _context11.sent;
-              if (!this.user) {
-                _context11.next = 7;
-                break;
-              }
-              return _context11.abrupt("return", this.user);
-            case 7:
-              _context11.next = 9;
-              return this.getUser(accessToken);
-            case 9:
-              user = _context11.sent;
-              this.user = user;
-              return _context11.abrupt("return", user);
-            case 12:
-            case "end":
-              return _context11.stop();
-          }
-        }, _callee11, this);
-      }));
-      function requestUser() {
-        return _requestUser.apply(this, arguments);
+  }
+  async loadCurrentService() {
+    if (this._service.serviceName) {
+      return;
+    }
+    try {
+      const {
+        serviceName,
+        iconUrl: serviceImage
+      } = (await this.http.get(`oauth2/interactive/login/settings?client_id=${this.config.clientId}`)) || {};
+      this.setCurrentService({
+        serviceImage,
+        serviceName
+      });
+    } catch (e) {
+      // noop
+    }
+  }
+  getAPIPath() {
+    return this.config.serverUri + Auth.API_PATH;
+  }
+  /**
+   * @return {Promise.<object>}
+   */
+  getUser(accessToken) {
+    if (this.config.cacheCurrentUser) {
+      return this._storage?.getCachedUser(() => this.http.authorizedFetch(Auth.API_PROFILE_PATH, accessToken, this.config.userParams));
+    } else {
+      return this.http.authorizedFetch(Auth.API_PROFILE_PATH, accessToken, this.config.userParams);
+    }
+  }
+  /**
+   * @return {Promise.<object>}
+   */
+  async requestUser() {
+    if (this.user) {
+      return this.user;
+    }
+    const accessToken = await this.requestToken();
+    // If user was fetched during token request
+    if (this.user) {
+      return this.user;
+    }
+    const user = await this.getUser(accessToken);
+    this.user = user;
+    return user;
+  }
+  async updateUser() {
+    this._setPostponed(false);
+    const accessToken = await this.requestToken();
+    this._storage?.wipeCachedCurrentUser();
+    const user = await this.getUser(accessToken);
+    this.user = user;
+    this.listeners.trigger(USER_CHANGED_EVENT, user);
+  }
+  async _detectUserChange(accessToken) {
+    const windowWasOpen = this._isLoginWindowOpen;
+    const user = await this.getUser(accessToken);
+    const onApply = () => {
+      this.user = user;
+      this.listeners.trigger(USER_CHANGED_EVENT, user);
+    };
+    if (user && this.user && this.user.id !== user.id) {
+      if (!this._canShowDialogs() || this.user.guest || windowWasOpen) {
+        onApply();
+        return;
       }
-      return requestUser;
-    }())
-  }, {
-    key: "updateUser",
-    value: function () {
-      var _updateUser = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12() {
-        var _this$_storage7;
-        var accessToken, user;
-        return _regeneratorRuntime().wrap(function _callee12$(_context12) {
-          while (1) switch (_context12.prev = _context12.next) {
-            case 0:
-              this._setPostponed(false);
-              _context12.next = 3;
-              return this.requestToken();
-            case 3:
-              accessToken = _context12.sent;
-              (_this$_storage7 = this._storage) === null || _this$_storage7 === void 0 || _this$_storage7.wipeCachedCurrentUser();
-              _context12.next = 7;
-              return this.getUser(accessToken);
-            case 7:
-              user = _context12.sent;
-              this.user = user;
-              this.listeners.trigger(USER_CHANGED_EVENT, user);
-            case 10:
-            case "end":
-              return _context12.stop();
-          }
-        }, _callee12, this);
-      }));
-      function updateUser() {
-        return _updateUser.apply(this, arguments);
+      if (user.guest) {
+        this._showAuthDialog({
+          nonInteractive: true
+        });
+        return;
       }
-      return updateUser;
-    }()
-  }, {
-    key: "_detectUserChange",
-    value: function () {
-      var _detectUserChange2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee13(accessToken) {
-        var _this6 = this;
-        var windowWasOpen, user, onApply;
-        return _regeneratorRuntime().wrap(function _callee13$(_context13) {
-          while (1) switch (_context13.prev = _context13.next) {
-            case 0:
-              windowWasOpen = this._isLoginWindowOpen;
-              _context13.next = 3;
-              return this.getUser(accessToken);
-            case 3:
-              user = _context13.sent;
-              onApply = function onApply() {
-                _this6.user = user;
-                _this6.listeners.trigger(USER_CHANGED_EVENT, user);
-              };
-              if (!(user && this.user && this.user.id !== user.id)) {
-                _context13.next = 14;
-                break;
-              }
-              if (!(!this._canShowDialogs() || this.user.guest || windowWasOpen)) {
-                _context13.next = 9;
-                break;
-              }
-              onApply();
-              return _context13.abrupt("return");
-            case 9:
-              if (!user.guest) {
-                _context13.next = 12;
-                break;
-              }
-              this._showAuthDialog({
-                nonInteractive: true
-              });
-              return _context13.abrupt("return");
-            case 12:
-              _context13.next = 14;
-              return this._showUserChangedDialog({
-                newUser: user,
-                onApply,
-                onPostpone: function onPostpone() {
-                  _this6.listeners.trigger(USER_CHANGE_POSTPONED_EVENT);
-                  _this6.config.onPostponeChangedUser(_this6.user, user);
-                }
-              });
-            case 14:
-            case "end":
-              return _context13.stop();
-          }
-        }, _callee13, this);
-      }));
-      function _detectUserChange(_x6) {
-        return _detectUserChange2.apply(this, arguments);
+      await this._showUserChangedDialog({
+        newUser: user,
+        onApply,
+        onPostpone: () => {
+          this.listeners.trigger(USER_CHANGE_POSTPONED_EVENT);
+          this.config.onPostponeChangedUser(this.user, user);
+        }
+      });
+    }
+  }
+  _beforeLogout(params) {
+    if (this._canShowDialogs()) {
+      this._showAuthDialog(params);
+      return;
+    }
+    this.logout();
+  }
+  _showAuthDialog() {
+    let {
+      nonInteractive,
+      error,
+      canCancel,
+      onTryAgain
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const {
+      embeddedLogin,
+      onPostponeLogout,
+      translations
+    } = this.config;
+    const cancelable = this.user?.guest || canCancel;
+    const actualTranslations = translations !== null && translations !== void 0 ? translations : getTranslations();
+    this._createInitDeferred();
+    const closeDialog = () => {
+      /* eslint-disable @typescript-eslint/no-use-before-define */
+      stopTokenListening?.();
+      stopMessageListening?.();
+      hide?.();
+      /* eslint-enable @typescript-eslint/no-use-before-define */
+    };
+    const onConfirm = () => {
+      if (!embeddedLogin) {
+        closeDialog();
+        this.logout();
+        return;
       }
-      return _detectUserChange;
-    }()
-  }, {
-    key: "_beforeLogout",
-    value: function _beforeLogout(params) {
-      if (this._canShowDialogs()) {
-        this._showAuthDialog(params);
+      this._runEmbeddedLogin();
+    };
+    const onCancel = () => {
+      this._embeddedFlow?.stop();
+      this._storage?.sendMessage(Auth.CLOSE_WINDOW_MESSAGE, Date.now());
+      closeDialog();
+      if (!cancelable) {
+        this._initDeferred?.resolve?.();
+        this.listeners.trigger(LOGOUT_POSTPONED_EVENT);
+        onPostponeLogout();
         return;
       }
-      this.logout();
+      if (this.user?.guest && nonInteractive) {
+        this.forceTokenUpdate();
+      } else {
+        this._initDeferred?.resolve?.();
+      }
+    };
+    const onTryAgainClick = async () => {
+      await onTryAgain?.();
+      closeDialog();
+    };
+    const hide = this._authDialogService?.({
+      ...this._service,
+      loginCaption: actualTranslations.login,
+      loginToCaption: actualTranslations.loginTo,
+      confirmLabel: actualTranslations.login,
+      tryAgainLabel: actualTranslations.tryAgainLabel,
+      cancelLabel: cancelable ? actualTranslations.cancel : actualTranslations.postpone,
+      errorMessage: this._extractErrorMessage(error, true),
+      onConfirm,
+      onCancel,
+      onTryAgain: onTryAgain ? onTryAgainClick : undefined
+    });
+    const stopTokenListening = this._storage?.onTokenChange(token => {
+      if (token) {
+        closeDialog();
+        this._initDeferred?.resolve?.();
+      }
+    });
+    const stopMessageListening = this._storage?.onMessage(Auth.CLOSE_WINDOW_MESSAGE, () => this._embeddedFlow?.stop());
+  }
+  _showUserChangedDialog(_ref) {
+    var _translations$youHave, _newUser$name, _newUser$name2, _translations$login, _translations$loginTo, _translations$applyCh, _translations$tryAgai, _translations$postpon;
+    let {
+      newUser,
+      onApply,
+      onPostpone
+    } = _ref;
+    const {
+      translations
+    } = this.config;
+    this._createInitDeferred();
+    const done = () => {
+      this._initDeferred?.resolve?.();
+      // eslint-disable-next-line @typescript-eslint/no-use-before-define
+      hide?.();
+    };
+    const hide = this._authDialogService?.({
+      ...this._service,
+      title: (_translations$youHave = translations?.youHaveLoggedInAs) !== null && _translations$youHave !== void 0 ? _translations$youHave : translate('youHaveLoggedInAs').replace('%userName%', (_newUser$name = newUser.name) !== null && _newUser$name !== void 0 ? _newUser$name : '').replace('{{userName}}', (_newUser$name2 = newUser.name) !== null && _newUser$name2 !== void 0 ? _newUser$name2 : ''),
+      loginCaption: (_translations$login = translations?.login) !== null && _translations$login !== void 0 ? _translations$login : translate('login'),
+      loginToCaption: (_translations$loginTo = translations?.loginTo) !== null && _translations$loginTo !== void 0 ? _translations$loginTo : translate('loginTo'),
+      confirmLabel: (_translations$applyCh = translations?.applyChange) !== null && _translations$applyCh !== void 0 ? _translations$applyCh : translate('applyChange'),
+      tryAgainLabel: (_translations$tryAgai = translations?.tryAgainLabel) !== null && _translations$tryAgai !== void 0 ? _translations$tryAgai : translate('tryAgainLabel'),
+      cancelLabel: (_translations$postpon = translations?.postpone) !== null && _translations$postpon !== void 0 ? _translations$postpon : translate('postpone'),
+      onConfirm: () => {
+        done();
+        onApply();
+      },
+      onCancel: () => {
+        done();
+        onPostpone();
+      }
+    });
+  }
+  _extractErrorMessage(error) {
+    let logError = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    if (!error) {
+      return null;
+    }
+    if (logError) {
+      // eslint-disable-next-line no-console
+      console.error('RingUI Auth error', error);
+    }
+    try {
+      // We've got some error from this list
+      // https://www.jetbrains.com/help/youtrack/devportal/OAuth-2.0-Errors.html
+      if ('code' in error && error.code && typeof error.code === 'object' && 'code' in error.code && typeof error.code.code === 'string') {
+        const readableCode = error.code.code.split('_').join(' ');
+        return `Authorization error: ${readableCode}`;
+      }
+    } catch {
+      // noop
     }
-  }, {
-    key: "_showAuthDialog",
-    value: function _showAuthDialog() {
-      var _this$user2,
-        _this7 = this,
-        _this$_authDialogServ,
-        _this$_storage8,
-        _this$_storage9;
-      var _ref6 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-        nonInteractive = _ref6.nonInteractive,
-        error = _ref6.error,
-        canCancel = _ref6.canCancel,
-        onTryAgain = _ref6.onTryAgain;
-      var _this$config2 = this.config,
-        embeddedLogin = _this$config2.embeddedLogin,
-        onPostponeLogout = _this$config2.onPostponeLogout,
-        translations = _this$config2.translations;
-      var cancelable = ((_this$user2 = this.user) === null || _this$user2 === void 0 ? void 0 : _this$user2.guest) || canCancel;
-      var actualTranslations = translations !== null && translations !== void 0 ? translations : getTranslations();
-      this._createInitDeferred();
-      var closeDialog = function closeDialog() {
+    return error.toString ? error.toString() : null;
+  }
+  _showBackendDownDialog(backendError) {
+    const {
+      onBackendDown,
+      translations
+    } = this.config;
+    const REPEAT_TIMEOUT = 5000;
+    let timerId;
+    return new Promise((resolve, reject) => {
+      const done = () => {
         /* eslint-disable @typescript-eslint/no-use-before-define */
-        stopTokenListening === null || stopTokenListening === void 0 || stopTokenListening();
-        stopMessageListening === null || stopMessageListening === void 0 || stopMessageListening();
-        hide === null || hide === void 0 || hide();
+        hide();
+        window.removeEventListener('online', onCheckAgain);
+        stopListeningCloseMessage?.();
         /* eslint-enable @typescript-eslint/no-use-before-define */
+        this._storage?.sendMessage(Auth.CLOSE_BACKEND_DOWN_MESSAGE, Date.now());
+        clearTimeout(timerId);
       };
-      var onConfirm = function onConfirm() {
-        if (!embeddedLogin) {
-          closeDialog();
-          _this7.logout();
-          return;
-        }
-        _this7._runEmbeddedLogin();
+      const stopListeningCloseMessage = this._storage?.onMessage(Auth.CLOSE_BACKEND_DOWN_MESSAGE, () => {
+        stopListeningCloseMessage?.();
+        done();
+        resolve();
+      });
+      const onCheckAgain = async () => {
+        await this._checkBackendsAreUp();
+        done();
+        resolve();
       };
-      var onCancel = function onCancel() {
-        var _this7$_embeddedFlow, _this7$_storage, _this7$user;
-        (_this7$_embeddedFlow = _this7._embeddedFlow) === null || _this7$_embeddedFlow === void 0 || _this7$_embeddedFlow.stop();
-        (_this7$_storage = _this7._storage) === null || _this7$_storage === void 0 || _this7$_storage.sendMessage(Auth.CLOSE_WINDOW_MESSAGE, Date.now());
-        closeDialog();
-        if (!cancelable) {
-          var _this7$_initDeferred, _this7$_initDeferred$;
-          (_this7$_initDeferred = _this7._initDeferred) === null || _this7$_initDeferred === void 0 || (_this7$_initDeferred$ = _this7$_initDeferred.resolve) === null || _this7$_initDeferred$ === void 0 || _this7$_initDeferred$.call(_this7$_initDeferred);
-          _this7.listeners.trigger(LOGOUT_POSTPONED_EVENT);
-          onPostponeLogout();
-          return;
-        }
-        if ((_this7$user = _this7.user) !== null && _this7$user !== void 0 && _this7$user.guest && nonInteractive) {
-          _this7.forceTokenUpdate();
-        } else {
-          var _this7$_initDeferred2, _this7$_initDeferred3;
-          (_this7$_initDeferred2 = _this7._initDeferred) === null || _this7$_initDeferred2 === void 0 || (_this7$_initDeferred3 = _this7$_initDeferred2.resolve) === null || _this7$_initDeferred3 === void 0 || _this7$_initDeferred3.call(_this7$_initDeferred2);
-        }
+      const onPostpone = () => {
+        done();
+        reject(new Error('Auth(@jetbrains/ring-ui): postponed by user'));
       };
-      var onTryAgainClick = /*#__PURE__*/function () {
-        var _ref7 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee14() {
-          return _regeneratorRuntime().wrap(function _callee14$(_context14) {
-            while (1) switch (_context14.prev = _context14.next) {
-              case 0:
-                _context14.next = 2;
-                return onTryAgain === null || onTryAgain === void 0 ? void 0 : onTryAgain();
-              case 2:
-                closeDialog();
-              case 3:
-              case "end":
-                return _context14.stop();
-            }
-          }, _callee14);
-        }));
-        return function onTryAgainClick() {
-          return _ref7.apply(this, arguments);
-        };
-      }();
-      var hide = (_this$_authDialogServ = this._authDialogService) === null || _this$_authDialogServ === void 0 ? void 0 : _this$_authDialogServ.call(this, _objectSpread2(_objectSpread2({}, this._service), {}, {
-        loginCaption: actualTranslations.login,
-        loginToCaption: actualTranslations.loginTo,
-        confirmLabel: actualTranslations.login,
-        tryAgainLabel: actualTranslations.tryAgainLabel,
-        cancelLabel: cancelable ? actualTranslations.cancel : actualTranslations.postpone,
-        errorMessage: this._extractErrorMessage(error, true),
-        onConfirm,
-        onCancel,
-        onTryAgain: onTryAgain ? onTryAgainClick : undefined
-      }));
-      var stopTokenListening = (_this$_storage8 = this._storage) === null || _this$_storage8 === void 0 ? void 0 : _this$_storage8.onTokenChange(function (token) {
-        if (token) {
-          var _this7$_initDeferred4, _this7$_initDeferred5;
-          closeDialog();
-          (_this7$_initDeferred4 = _this7._initDeferred) === null || _this7$_initDeferred4 === void 0 || (_this7$_initDeferred5 = _this7$_initDeferred4.resolve) === null || _this7$_initDeferred5 === void 0 || _this7$_initDeferred5.call(_this7$_initDeferred4);
-        }
+      const hide = onBackendDown({
+        onCheckAgain,
+        onPostpone,
+        backendError,
+        translations: translations !== null && translations !== void 0 ? translations : getTranslationsWithFallback()
       });
-      var stopMessageListening = (_this$_storage9 = this._storage) === null || _this$_storage9 === void 0 ? void 0 : _this$_storage9.onMessage(Auth.CLOSE_WINDOW_MESSAGE, function () {
-        var _this7$_embeddedFlow2;
-        return (_this7$_embeddedFlow2 = _this7._embeddedFlow) === null || _this7$_embeddedFlow2 === void 0 ? void 0 : _this7$_embeddedFlow2.stop();
-      });
-    }
-  }, {
-    key: "_showUserChangedDialog",
-    value: function _showUserChangedDialog(_ref8) {
-      var _this8 = this,
-        _this$_authDialogServ2,
-        _translations$youHave,
-        _newUser$name,
-        _newUser$name2,
-        _translations$login,
-        _translations$loginTo,
-        _translations$applyCh,
-        _translations$tryAgai,
-        _translations$postpon;
-      var newUser = _ref8.newUser,
-        onApply = _ref8.onApply,
-        onPostpone = _ref8.onPostpone;
-      var translations = this.config.translations;
-      this._createInitDeferred();
-      var done = function done() {
-        var _this8$_initDeferred, _this8$_initDeferred$;
-        (_this8$_initDeferred = _this8._initDeferred) === null || _this8$_initDeferred === void 0 || (_this8$_initDeferred$ = _this8$_initDeferred.resolve) === null || _this8$_initDeferred$ === void 0 || _this8$_initDeferred$.call(_this8$_initDeferred);
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        hide === null || hide === void 0 || hide();
-      };
-      var hide = (_this$_authDialogServ2 = this._authDialogService) === null || _this$_authDialogServ2 === void 0 ? void 0 : _this$_authDialogServ2.call(this, _objectSpread2(_objectSpread2({}, this._service), {}, {
-        title: (_translations$youHave = translations === null || translations === void 0 ? void 0 : translations.youHaveLoggedInAs) !== null && _translations$youHave !== void 0 ? _translations$youHave : translate('youHaveLoggedInAs').replace('%userName%', (_newUser$name = newUser.name) !== null && _newUser$name !== void 0 ? _newUser$name : '').replace('{{userName}}', (_newUser$name2 = newUser.name) !== null && _newUser$name2 !== void 0 ? _newUser$name2 : ''),
-        loginCaption: (_translations$login = translations === null || translations === void 0 ? void 0 : translations.login) !== null && _translations$login !== void 0 ? _translations$login : translate('login'),
-        loginToCaption: (_translations$loginTo = translations === null || translations === void 0 ? void 0 : translations.loginTo) !== null && _translations$loginTo !== void 0 ? _translations$loginTo : translate('loginTo'),
-        confirmLabel: (_translations$applyCh = translations === null || translations === void 0 ? void 0 : translations.applyChange) !== null && _translations$applyCh !== void 0 ? _translations$applyCh : translate('applyChange'),
-        tryAgainLabel: (_translations$tryAgai = translations === null || translations === void 0 ? void 0 : translations.tryAgainLabel) !== null && _translations$tryAgai !== void 0 ? _translations$tryAgai : translate('tryAgainLabel'),
-        cancelLabel: (_translations$postpon = translations === null || translations === void 0 ? void 0 : translations.postpone) !== null && _translations$postpon !== void 0 ? _translations$postpon : translate('postpone'),
-        onConfirm: function onConfirm() {
-          done();
-          onApply();
-        },
-        onCancel: function onCancel() {
-          done();
-          onPostpone();
-        }
-      }));
-    }
-  }, {
-    key: "_extractErrorMessage",
-    value: function _extractErrorMessage(error) {
-      var logError = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-      if (!error) {
-        return null;
-      }
-      if (logError) {
-        // eslint-disable-next-line no-console
-        console.error('RingUI Auth error', error);
-      }
-      try {
-        // We've got some error from this list
-        // https://www.jetbrains.com/help/youtrack/devportal/OAuth-2.0-Errors.html
-        if ('code' in error && error.code && typeof error.code === 'object' && 'code' in error.code && typeof error.code.code === 'string') {
-          var readableCode = error.code.code.split('_').join(' ');
-          return "Authorization error: ".concat(readableCode);
+      window.addEventListener('online', onCheckAgain);
+      function networkWatchdog() {
+        if (navigator && navigator.onLine) {
+          onCheckAgain();
         }
-      } catch (_unused) {
-        // noop
+        timerId = window.setTimeout(networkWatchdog, REPEAT_TIMEOUT);
       }
-      return error.toString ? error.toString() : null;
+      timerId = window.setTimeout(networkWatchdog, REPEAT_TIMEOUT);
+    });
+  }
+  /**
+   * Wipe accessToken and redirect to auth page with required authorization
+   */
+  async logout(extraParams) {
+    const requestParams = {
+      // eslint-disable-next-line camelcase
+      request_credentials: 'required',
+      ...extraParams
+    };
+    await this._checkBackendsStatusesIfEnabled();
+    await this.listeners.trigger('logout');
+    this._updateDomainUser(null);
+    await this._storage?.wipeToken();
+    const authRequest = await this._requestBuilder?.prepareAuthRequest(requestParams);
+    if (authRequest != null) {
+      this._redirectCurrentPage(authRequest.url);
     }
-  }, {
-    key: "_showBackendDownDialog",
-    value: function _showBackendDownDialog(backendError) {
-      var _this9 = this;
-      var _this$config3 = this.config,
-        onBackendDown = _this$config3.onBackendDown,
-        translations = _this$config3.translations;
-      var REPEAT_TIMEOUT = 5000;
-      var timerId;
-      return new Promise(function (resolve, reject) {
-        var _this9$_storage2;
-        var done = function done() {
-          var _this9$_storage;
-          /* eslint-disable @typescript-eslint/no-use-before-define */
-          hide();
-          window.removeEventListener('online', onCheckAgain);
-          stopListeningCloseMessage === null || stopListeningCloseMessage === void 0 || stopListeningCloseMessage();
-          /* eslint-enable @typescript-eslint/no-use-before-define */
-          (_this9$_storage = _this9._storage) === null || _this9$_storage === void 0 || _this9$_storage.sendMessage(Auth.CLOSE_BACKEND_DOWN_MESSAGE, Date.now());
-          clearTimeout(timerId);
-        };
-        var stopListeningCloseMessage = (_this9$_storage2 = _this9._storage) === null || _this9$_storage2 === void 0 ? void 0 : _this9$_storage2.onMessage(Auth.CLOSE_BACKEND_DOWN_MESSAGE, function () {
-          stopListeningCloseMessage === null || stopListeningCloseMessage === void 0 || stopListeningCloseMessage();
-          done();
-          resolve();
-        });
-        var onCheckAgain = /*#__PURE__*/function () {
-          var _ref9 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee15() {
-            return _regeneratorRuntime().wrap(function _callee15$(_context15) {
-              while (1) switch (_context15.prev = _context15.next) {
-                case 0:
-                  _context15.next = 2;
-                  return _this9._checkBackendsAreUp();
-                case 2:
-                  done();
-                  resolve();
-                case 4:
-                case "end":
-                  return _context15.stop();
-              }
-            }, _callee15);
-          }));
-          return function onCheckAgain() {
-            return _ref9.apply(this, arguments);
-          };
-        }();
-        var onPostpone = function onPostpone() {
-          done();
-          reject(new Error('Auth(@jetbrains/ring-ui): postponed by user'));
-        };
-        var hide = onBackendDown({
-          onCheckAgain,
-          onPostpone,
-          backendError,
-          translations: translations !== null && translations !== void 0 ? translations : getTranslationsWithFallback()
-        });
-        window.addEventListener('online', onCheckAgain);
-        function networkWatchdog() {
-          if (navigator && navigator.onLine) {
-            onCheckAgain();
-          }
-          timerId = window.setTimeout(networkWatchdog, REPEAT_TIMEOUT);
-        }
-        timerId = window.setTimeout(networkWatchdog, REPEAT_TIMEOUT);
-      });
+  }
+  async _runEmbeddedLogin() {
+    this._storage?.sendMessage(Auth.CLOSE_WINDOW_MESSAGE, Date.now());
+    try {
+      this._isLoginWindowOpen = true;
+      return await this._embeddedFlow?.authorize();
+    } catch (e) {
+      throw e;
+    } finally {
+      this._isLoginWindowOpen = false;
     }
-    /**
-     * Wipe accessToken and redirect to auth page with required authorization
-     */
-  }, {
-    key: "logout",
-    value: (function () {
-      var _logout = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee16(extraParams) {
-        var _this$_storage10, _this$_requestBuilder3;
-        var requestParams, authRequest;
-        return _regeneratorRuntime().wrap(function _callee16$(_context16) {
-          while (1) switch (_context16.prev = _context16.next) {
-            case 0:
-              requestParams = _objectSpread2({
-                // eslint-disable-next-line camelcase
-                request_credentials: 'required'
-              }, extraParams);
-              _context16.next = 3;
-              return this._checkBackendsStatusesIfEnabled();
-            case 3:
-              _context16.next = 5;
-              return this.listeners.trigger('logout');
-            case 5:
-              this._updateDomainUser(null);
-              _context16.next = 8;
-              return (_this$_storage10 = this._storage) === null || _this$_storage10 === void 0 ? void 0 : _this$_storage10.wipeToken();
-            case 8:
-              _context16.next = 10;
-              return (_this$_requestBuilder3 = this._requestBuilder) === null || _this$_requestBuilder3 === void 0 ? void 0 : _this$_requestBuilder3.prepareAuthRequest(requestParams);
-            case 10:
-              authRequest = _context16.sent;
-              if (authRequest != null) {
-                this._redirectCurrentPage(authRequest.url);
-              }
-            case 12:
-            case "end":
-              return _context16.stop();
-          }
-        }, _callee16, this);
-      }));
-      function logout(_x7) {
-        return _logout.apply(this, arguments);
-      }
-      return logout;
-    }())
-  }, {
-    key: "_runEmbeddedLogin",
-    value: function () {
-      var _runEmbeddedLogin2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee17() {
-        var _this$_storage11;
-        var _this$_embeddedFlow;
-        return _regeneratorRuntime().wrap(function _callee17$(_context17) {
-          while (1) switch (_context17.prev = _context17.next) {
-            case 0:
-              (_this$_storage11 = this._storage) === null || _this$_storage11 === void 0 || _this$_storage11.sendMessage(Auth.CLOSE_WINDOW_MESSAGE, Date.now());
-              _context17.prev = 1;
-              this._isLoginWindowOpen = true;
-              _context17.next = 5;
-              return (_this$_embeddedFlow = this._embeddedFlow) === null || _this$_embeddedFlow === void 0 ? void 0 : _this$_embeddedFlow.authorize();
-            case 5:
-              return _context17.abrupt("return", _context17.sent);
-            case 8:
-              _context17.prev = 8;
-              _context17.t0 = _context17["catch"](1);
-              throw _context17.t0;
-            case 11:
-              _context17.prev = 11;
-              this._isLoginWindowOpen = false;
-              return _context17.finish(11);
-            case 14:
-            case "end":
-              return _context17.stop();
-          }
-        }, _callee17, this, [[1, 8, 11, 14]]);
-      }));
-      function _runEmbeddedLogin() {
-        return _runEmbeddedLogin2.apply(this, arguments);
-      }
-      return _runEmbeddedLogin;
-    }()
-    /**
-     * Wipe accessToken and redirect to auth page to obtain authorization data
-     * if user is logged in or log her in otherwise
-     */
-  }, {
-    key: "login",
-    value: (function () {
-      var _login = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee18() {
-        var _this$_backgroundFlow3, accessToken, _user;
-        return _regeneratorRuntime().wrap(function _callee18$(_context18) {
-          while (1) switch (_context18.prev = _context18.next) {
-            case 0:
-              if (!this.config.embeddedLogin) {
-                _context18.next = 4;
-                break;
-              }
-              _context18.next = 3;
-              return this._runEmbeddedLogin();
-            case 3:
-              return _context18.abrupt("return");
-            case 4:
-              _context18.next = 6;
-              return this._checkBackendsStatusesIfEnabled();
-            case 6:
-              _context18.prev = 6;
-              _context18.next = 9;
-              return (_this$_backgroundFlow3 = this._backgroundFlow) === null || _this$_backgroundFlow3 === void 0 ? void 0 : _this$_backgroundFlow3.authorize();
-            case 9:
-              accessToken = _context18.sent;
-              _context18.next = 12;
-              return this.getUser(accessToken);
-            case 12:
-              _user = _context18.sent;
-              if (_user.guest) {
-                this._beforeLogout();
-              } else {
-                this.user = _user;
-                this.listeners.trigger(USER_CHANGED_EVENT, _user);
-              }
-              _context18.next = 19;
-              break;
-            case 16:
-              _context18.prev = 16;
-              _context18.t0 = _context18["catch"](6);
-              this._beforeLogout();
-            case 19:
-            case "end":
-              return _context18.stop();
-          }
-        }, _callee18, this, [[6, 16]]);
-      }));
-      function login() {
-        return _login.apply(this, arguments);
-      }
-      return login;
-    }())
-  }, {
-    key: "switchUser",
-    value: function () {
-      var _switchUser = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee19() {
-        return _regeneratorRuntime().wrap(function _callee19$(_context19) {
-          while (1) switch (_context19.prev = _context19.next) {
-            case 0:
-              if (this.config.embeddedLogin) {
-                _context19.next = 2;
-                break;
-              }
-              throw new Error('Auth: switchUser only supported for "embeddedLogin" mode');
-            case 2:
-              _context19.next = 4;
-              return this._runEmbeddedLogin();
-            case 4:
-            case "end":
-              return _context19.stop();
-          }
-        }, _callee19, this);
-      }));
-      function switchUser() {
-        return _switchUser.apply(this, arguments);
-      }
-      return switchUser;
-    }()
-  }, {
-    key: "_makeStateFromResponse",
-    value: function _makeStateFromResponse(authResponse) {
-      var state = authResponse.state;
-      if (!state) {
-        return {};
+  }
+  /**
+   * Wipe accessToken and redirect to auth page to obtain authorization data
+   * if user is logged in or log her in otherwise
+   */
+  async login() {
+    if (this.config.embeddedLogin) {
+      await this._runEmbeddedLogin();
+      return;
+    }
+    await this._checkBackendsStatusesIfEnabled();
+    try {
+      const accessToken = await this._backgroundFlow?.authorize();
+      const user = await this.getUser(accessToken);
+      if (user.guest) {
+        this._beforeLogout();
+      } else {
+        this.user = user;
+        this.listeners.trigger(USER_CHANGED_EVENT, user);
       }
-      var defaultScope = this.config.scope;
-      try {
-        var urlFromState = new URL(state); // checking if state contains valid URL on same origin, see HUB-11514
-        if (urlFromState.origin !== window.location.origin) {
-          return {};
-        }
-        return {
-          restoreLocation: state,
-          created: Date.now(),
-          scopes: defaultScope
-        };
-      } catch (e) {
+    } catch (e) {
+      this._beforeLogout();
+    }
+  }
+  async switchUser() {
+    if (!this.config.embeddedLogin) {
+      throw new Error('Auth: switchUser only supported for "embeddedLogin" mode');
+    }
+    await this._runEmbeddedLogin();
+  }
+  _makeStateFromResponse(authResponse) {
+    const {
+      state
+    } = authResponse;
+    if (!state) {
+      return {};
+    }
+    const {
+      scope: defaultScope
+    } = this.config;
+    try {
+      const urlFromState = new URL(state); // checking if state contains valid URL on same origin, see HUB-11514
+      if (urlFromState.origin !== window.location.origin) {
         return {};
       }
+      return {
+        restoreLocation: state,
+        created: Date.now(),
+        scopes: defaultScope
+      };
+    } catch (e) {
+      return {};
     }
-    /**
-     * Check if the hash contains an access token.
-     * If it does, extract the state, compare with
-     * config, and store the auth response for later use.
-     *
-     * @return {Promise} promise that is resolved to restoreLocation URL, or rejected
-     * @private
-     */
-  }, {
-    key: "_checkForAuthResponse",
-    value: (function () {
-      var _checkForAuthResponse2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee20() {
-        var _this$_storage12;
-        var authResponse, _this$config4, defaultScope, defaultExpiresIn, cleanHash, stateId, scope, expiresIn, accessToken, newState, scopes, effectiveExpiresIn, expires, _this$_storage13;
-        return _regeneratorRuntime().wrap(function _callee20$(_context20) {
-          while (1) switch (_context20.prev = _context20.next) {
-            case 0:
-              // getAuthResponseURL may throw an exception
-              authResponse = this._responseParser.getAuthResponseFromURL();
-              _this$config4 = this.config, defaultScope = _this$config4.scope, defaultExpiresIn = _this$config4.defaultExpiresIn, cleanHash = _this$config4.cleanHash;
-              if (authResponse && cleanHash) {
-                this.setHash('');
-              }
-              if (authResponse) {
-                _context20.next = 5;
-                break;
-              }
-              return _context20.abrupt("return", undefined);
-            case 5:
-              stateId = authResponse.state, scope = authResponse.scope, expiresIn = authResponse.expiresIn, accessToken = authResponse.accessToken;
-              _context20.next = 8;
-              return stateId && ((_this$_storage12 = this._storage) === null || _this$_storage12 === void 0 ? void 0 : _this$_storage12.getState(stateId));
-            case 8:
-              _context20.t0 = _context20.sent;
-              if (_context20.t0) {
-                _context20.next = 11;
-                break;
-              }
-              _context20.t0 = this._makeStateFromResponse(authResponse);
-            case 11:
-              newState = _context20.t0;
-              scopes = scope ? scope.split(' ') : newState.scopes || defaultScope || [];
-              effectiveExpiresIn = expiresIn ? parseInt(expiresIn, 10) : defaultExpiresIn;
-              expires = TokenValidator._epoch() + effectiveExpiresIn;
-              if (!(accessToken != null)) {
-                _context20.next = 18;
-                break;
-              }
-              _context20.next = 18;
-              return (_this$_storage13 = this._storage) === null || _this$_storage13 === void 0 ? void 0 : _this$_storage13.saveToken({
-                accessToken,
-                scopes,
-                expires,
-                lifeTime: effectiveExpiresIn
-              });
-            case 18:
-              return _context20.abrupt("return", newState);
-            case 19:
-            case "end":
-              return _context20.stop();
-          }
-        }, _callee20, this);
-      }));
-      function _checkForAuthResponse() {
-        return _checkForAuthResponse2.apply(this, arguments);
-      }
-      return _checkForAuthResponse;
-    }())
-  }, {
-    key: "_checkForStateRestoration",
-    value: function () {
-      var _checkForStateRestoration2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee21() {
-        var _this$_storage14;
-        var authResponse, stateId;
-        return _regeneratorRuntime().wrap(function _callee21$(_context21) {
-          while (1) switch (_context21.prev = _context21.next) {
-            case 0:
-              authResponse = this._responseParser._authResponse;
-              if (authResponse && this.config.cleanHash) {
-                this.setHash('');
-              }
-              stateId = authResponse === null || authResponse === void 0 ? void 0 : authResponse.restoreAuthState;
-              _context21.next = 5;
-              return stateId && ((_this$_storage14 = this._storage) === null || _this$_storage14 === void 0 ? void 0 : _this$_storage14.getState(stateId));
-            case 5:
-              _context21.t0 = _context21.sent;
-              if (_context21.t0) {
-                _context21.next = 8;
-                break;
-              }
-              _context21.t0 = {};
-            case 8:
-              return _context21.abrupt("return", _context21.t0);
-            case 9:
-            case "end":
-              return _context21.stop();
-          }
-        }, _callee21, this);
-      }));
-      function _checkForStateRestoration() {
-        return _checkForStateRestoration2.apply(this, arguments);
-      }
-      return _checkForStateRestoration;
-    }()
-  }, {
-    key: "_checkBackendsAreUp",
-    value: function _checkBackendsAreUp() {
-      var abortCtrl = new AbortController();
-      var backendCheckTimeout = this.config.backendCheckTimeout;
-      return Promise.all([promiseWithTimeout(this.http.fetch('settings/public?fields=id', {
-        signal: abortCtrl.signal
-      }), backendCheckTimeout, {
-        error: new Error('The authorization server is taking too long to respond. Please try again later.'),
-        onTimeout: function onTimeout() {
-          return abortCtrl.abort();
-        }
-      }), this.config.checkBackendIsUp()]).catch(function (err) {
-        if (err instanceof TypeError) {
-          throw new TypeError('Could not connect to the server due to network error. Please check your connection and try again.');
-        }
-        throw err;
+  }
+  /**
+   * Check if the hash contains an access token.
+   * If it does, extract the state, compare with
+   * config, and store the auth response for later use.
+   *
+   * @return {Promise} promise that is resolved to restoreLocation URL, or rejected
+   * @private
+   */
+  async _checkForAuthResponse() {
+    // getAuthResponseURL may throw an exception
+    const authResponse = this._responseParser.getAuthResponseFromURL();
+    const {
+      scope: defaultScope,
+      defaultExpiresIn,
+      cleanHash
+    } = this.config;
+    if (authResponse && cleanHash) {
+      this.setHash('');
+    }
+    if (!authResponse) {
+      return undefined;
+    }
+    const {
+      state: stateId,
+      scope,
+      expiresIn,
+      accessToken
+    } = authResponse;
+    const newState = (await (stateId && this._storage?.getState(stateId))) || this._makeStateFromResponse(authResponse);
+    const scopes = scope ? scope.split(' ') : newState.scopes || defaultScope || [];
+    const effectiveExpiresIn = expiresIn ? parseInt(expiresIn, 10) : defaultExpiresIn;
+    const expires = TokenValidator._epoch() + effectiveExpiresIn;
+    if (accessToken != null) {
+      await this._storage?.saveToken({
+        accessToken,
+        scopes,
+        expires,
+        lifeTime: effectiveExpiresIn
       });
     }
-  }, {
-    key: "_checkBackendsStatusesIfEnabled",
-    value: function () {
-      var _checkBackendsStatusesIfEnabled2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee22() {
-        return _regeneratorRuntime().wrap(function _callee22$(_context22) {
-          while (1) switch (_context22.prev = _context22.next) {
-            case 0:
-              if (this.config.enableBackendStatusCheck) {
-                _context22.next = 2;
-                break;
-              }
-              return _context22.abrupt("return");
-            case 2:
-              _context22.prev = 2;
-              _context22.next = 5;
-              return this._checkBackendsAreUp();
-            case 5:
-              _context22.next = 12;
-              break;
-            case 7:
-              _context22.prev = 7;
-              _context22.t0 = _context22["catch"](2);
-              if (!(_context22.t0 instanceof Error)) {
-                _context22.next = 12;
-                break;
-              }
-              _context22.next = 12;
-              return this._showBackendDownDialog(_context22.t0);
-            case 12:
-            case "end":
-              return _context22.stop();
-          }
-        }, _callee22, this, [[2, 7]]);
-      }));
-      function _checkBackendsStatusesIfEnabled() {
-        return _checkBackendsStatusesIfEnabled2.apply(this, arguments);
-      }
-      return _checkBackendsStatusesIfEnabled;
-    }()
-    /**
-     * Adds preconnect tag to help browser to establish connection to URL.
-     * See https://w3c.github.io/resource-hints/
-     * @param url Url to preconnect to.
-     */
-  }, {
-    key: "setUpPreconnect",
-    value: function setUpPreconnect(url) {
-      var linkNode = document.createElement('link');
-      linkNode.rel = 'preconnect';
-      linkNode.href = url;
-      linkNode.pr = '1.0';
-      linkNode.crossOrigin = 'use-credentials';
-      document.head.appendChild(linkNode);
+    return newState;
+  }
+  async _checkForStateRestoration() {
+    const authResponse = this._responseParser._authResponse;
+    if (authResponse && this.config.cleanHash) {
+      this.setHash('');
     }
-    /**
-     * Redirects current page to the given URL
-     * @param {string} url
-     * @private
-     */
-  }, {
-    key: "_redirectCurrentPage",
-    value: function _redirectCurrentPage(url) {
-      {
-        window.location.href = fixUrl(url);
+    const stateId = authResponse?.restoreAuthState;
+    return (await (stateId && this._storage?.getState(stateId))) || {};
+  }
+  _checkBackendsAreUp() {
+    const abortCtrl = new AbortController();
+    const {
+      backendCheckTimeout
+    } = this.config;
+    return Promise.all([promiseWithTimeout(this.http.fetch('settings/public?fields=id', {
+      signal: abortCtrl.signal
+    }), backendCheckTimeout, {
+      error: new Error('The authorization server is taking too long to respond. Please try again later.'),
+      onTimeout: () => abortCtrl.abort()
+    }), this.config.checkBackendIsUp()]).catch(err => {
+      if (err instanceof TypeError) {
+        throw new TypeError('Could not connect to the server due to network error. Please check your connection and try again.');
       }
+      throw err;
+    });
+  }
+  async _checkBackendsStatusesIfEnabled() {
+    if (!this.config.enableBackendStatusCheck) {
+      return;
     }
-    /**
-     * Reloads current page
-     */
-  }, {
-    key: "_reloadCurrentPage",
-    value: function _reloadCurrentPage() {
-      this._redirectCurrentPage(window.location.href);
+    try {
+      await this._checkBackendsAreUp();
+    } catch (backendDownErr) {
+      if (backendDownErr instanceof Error) {
+        await this._showBackendDownDialog(backendDownErr);
+      }
     }
-  }, {
-    key: "_canShowDialogs",
-    value: function _canShowDialogs() {
-      return this.config.embeddedLogin && this._authDialogService;
+  }
+  /**
+   * Adds preconnect tag to help browser to establish connection to URL.
+   * See https://w3c.github.io/resource-hints/
+   * @param url Url to preconnect to.
+   */
+  setUpPreconnect(url) {
+    const linkNode = document.createElement('link');
+    linkNode.rel = 'preconnect';
+    linkNode.href = url;
+    linkNode.pr = '1.0';
+    linkNode.crossOrigin = 'use-credentials';
+    document.head.appendChild(linkNode);
+  }
+  /**
+   * Redirects current page to the given URL
+   * @param {string} url
+   * @private
+   */
+  _redirectCurrentPage(url) {
+    {
+      window.location.href = fixUrl(url);
     }
-    /**
-     * Sets the location hash
-     * @param {string} hash
-     */
-  }, {
-    key: "setHash",
-    value: function setHash(hash) {
-      if (history.replaceState) {
-        // NB! History.replaceState is used here, because Firefox saves
-        // a record in history.
-        // NB! URL to redirect is formed manually because baseURI could be messed up,
-        // in which case it's not obvious where redirect will lead.
-        var cleanedUrl = [window.location.pathname, window.location.search].join('');
-        var hashIfExist = hash ? "#".concat(hash) : '';
-        history.replaceState(undefined, '', "".concat(cleanedUrl).concat(hashIfExist));
-      } else {
-        window.location.hash = hash;
-      }
+  }
+  /**
+   * Reloads current page
+   */
+  _reloadCurrentPage() {
+    this._redirectCurrentPage(window.location.href);
+  }
+  _canShowDialogs() {
+    return this.config.embeddedLogin && this._authDialogService;
+  }
+  /**
+   * Sets the location hash
+   * @param {string} hash
+   */
+  setHash(hash) {
+    if (history.replaceState) {
+      // NB! History.replaceState is used here, because Firefox saves
+      // a record in history.
+      // NB! URL to redirect is formed manually because baseURI could be messed up,
+      // in which case it's not obvious where redirect will lead.
+      const cleanedUrl = [window.location.pathname, window.location.search].join('');
+      const hashIfExist = hash ? `#${hash}` : '';
+      history.replaceState(undefined, '', `${cleanedUrl}${hashIfExist}`);
+    } else {
+      window.location.hash = hash;
     }
-  }]);
-}();
-_defineProperty(Auth, "DEFAULT_CONFIG", DEFAULT_CONFIG);
-_defineProperty(Auth, "API_PATH", 'api/rest/');
-_defineProperty(Auth, "API_AUTH_PATH", 'oauth2/auth');
-_defineProperty(Auth, "API_PROFILE_PATH", 'users/me');
-_defineProperty(Auth, "CLOSE_BACKEND_DOWN_MESSAGE", 'backend-check-succeeded');
-_defineProperty(Auth, "CLOSE_WINDOW_MESSAGE", 'close-login-window');
-_defineProperty(Auth, "shouldRefreshToken", TokenValidator.shouldRefreshToken);
-_defineProperty(Auth, "storageIsUnavailable", !navigator.cookieEnabled);
+  }
+}
 
 export { DEFAULT_BACKGROUND_TIMEOUT, DEFAULT_EXPIRES_TIMEOUT, DOMAIN_USER_CHANGED_EVENT, LOGOUT_EVENT, LOGOUT_POSTPONED_EVENT, USER_CHANGED_EVENT, USER_CHANGE_POSTPONED_EVENT, Auth as default };