@jetbrains/ring-ui 4.1.0-beta.3 → 4.1.1

package/dist/auth.js

@@ -1,1744 +0,0 @@
-import { b as _defineProperty, c as _objectSpread2 } from './_helpers/_rollupPluginBabelHelpers.js';
-import { A as AuthResponseParser, B as BackgroundFlow } from './_helpers/background-flow.js';
-import React from 'react';
-import PropTypes from 'prop-types';
-import alertService from './alert-service.js';
-import Alert from './alert.js';
-import Link from './link.js';
-import Group from './group.js';
-import { e as encodeURL, f as fixUrl, g as getAbsoluteBaseURL } from './_helpers/url.js';
-import HTTP, { CODE } from './http.js';
-import ActualStorage from './storage.js';
-import uuid from 'simply-uuid';
-import ExtendableError from 'es6-error';
-import 'react-dom';
-import './_helpers/get-uid.js';
-import 'classnames';
-import '@jetbrains/icons/exception';
-import '@jetbrains/icons/checkmark';
-import '@jetbrains/icons/warning';
-import '@jetbrains/icons/close';
-import './icon.js';
-import 'util-deprecate';
-import './_helpers/memoize.js';
-import './loader-inline.js';
-import './_helpers/theme.js';
-import './_helpers/data-tests.js';
-import 'conic-gradient';
-import './_helpers/dom.js';
-import 'focus-visible';
-import './_helpers/clickableLink.js';
-import 'deep-equal';
-
-const NAVBAR_HEIGHT = 50;
-const CLOSED_CHECK_INTERVAL = 200;
-class WindowFlow {
-  constructor(requestBuilder, storage) {
-    _defineProperty(this, "_timeoutId", null);
-
-    _defineProperty(this, "checkIsClosed", () => {
-      if (this._loginWindow.closed) {
-        this.stop();
-        return;
-      }
-
-      this._timeoutId = setTimeout(this.checkIsClosed, CLOSED_CHECK_INTERVAL);
-    });
-
-    _defineProperty(this, "_reset", () => {
-      this._promise = null;
-      this._loginWindow = null;
-      clearTimeout(this._timeoutId);
-    });
-
-    this._requestBuilder = requestBuilder;
-    this._storage = storage;
-
-    this._reset();
-  }
-  /**
-   * Opens window with the given URL
-   * @param {string} url
-   * @private
-   */
-
-
-  _openWindow(url) {
-    const height = 700;
-    const width = 750;
-    const screenHalves = 2;
-    const top = (window.screen.height - height - NAVBAR_HEIGHT) / screenHalves;
-    const left = (window.screen.width - width) / screenHalves;
-    return window.open(url, 'HubLoginWindow', `height=${height}, width=${width}, left=${left}, top=${top}`);
-  }
-  /**
-   * Initiates authorization in window
-   */
-
-
-  async _load() {
-    const authRequest = await this._requestBuilder.prepareAuthRequest( // eslint-disable-next-line camelcase
-    {
-      request_credentials: 'required',
-      auth_mode: 'bypass_to_login'
-    }, {
-      nonRedirect: true
-    });
-    return new Promise((resolve, reject) => {
-      this.reject = reject;
-      let cleanRun;
-
-      const cleanUp = () => {
-        if (cleanRun) {
-          return;
-        }
-
-        cleanRun = true;
-        /* eslint-disable no-use-before-define */
-
-        removeStateListener();
-        removeTokenListener();
-        /* eslint-enable no-use-before-define */
-
-        this._loginWindow.close();
-
-        clearTimeout(this._timeoutId);
-      };
-
-      const removeTokenListener = this._storage.onTokenChange(token => {
-        if (token) {
-          cleanUp();
-          resolve(token.accessToken);
-        }
-      });
-
-      const removeStateListener = this._storage.onStateChange(authRequest.stateId, state => {
-        if (state && state.error) {
-          cleanUp();
-          reject(new AuthResponseParser.AuthError(state));
-        }
-      });
-
-      if (this._loginWindow === null || this._loginWindow.closed === true) {
-        this._loginWindow = this._openWindow(authRequest.url);
-      } else {
-        this._loginWindow.location = authRequest.url;
-      }
-
-      this.checkIsClosed();
-    });
-  }
-
-  stop() {
-    if (this._loginWindow !== null) {
-      this._loginWindow.close();
-    }
-
-    if (this.reject) {
-      this.reject('Authorization window closed');
-    }
-
-    this._reset();
-  }
-
-  authorize() {
-    if (this._promise !== null && this._loginWindow !== null && this._loginWindow.closed !== true) {
-      this._loginWindow.focus();
-
-      return this._promise;
-    }
-
-    this._promise = this._load();
-
-    this._promise.then(this._reset, this._reset);
-
-    return this._promise;
-  }
-
-}
-
-var modules_c87dd562 = {"unit":"8px","title":"downNotification_title__dc35b944","error":"downNotification_error__dc35b944"};
-
-let key = null;
-
-function renderAlert(message, type = Alert.Type.WARNING) {
-  const existingAlert = alertService.showingAlerts.filter(alert => alert.key === key)[0];
-
-  if (!existingAlert) {
-    key = alertService.addAlert(message, type, 0, {
-      closeable: false
-    });
-  } else {
-    existingAlert.message = message;
-    existingAlert.type = type;
-    alertService.renderAlerts();
-  }
-}
-
-function Message({
-  translations,
-  onCheckAgain
-}) {
-  const {
-    backendIsNotAvailable,
-    checkAgain,
-    errorMessage
-  } = translations;
-  return /*#__PURE__*/React.createElement("div", {
-    "data-test": "ring-backend-down-notification"
-  }, /*#__PURE__*/React.createElement(Group, null, /*#__PURE__*/React.createElement("div", {
-    className: modules_c87dd562.title
-  }, backendIsNotAvailable)), /*#__PURE__*/React.createElement("span", {
-    className: modules_c87dd562.error
-  }, errorMessage, " "), /*#__PURE__*/React.createElement(Link, {
-    onClick: onCheckAgain,
-    "data-test": "check-again"
-  }, checkAgain));
-}
-
-Message.propTypes = {
-  translations: PropTypes.shape({
-    backendIsNotAvailable: PropTypes.string,
-    checkAgain: PropTypes.string,
-    errorMessage: PropTypes.string
-  }),
-  onCheckAgain: PropTypes.func
-};
-function onBackendDown({
-  onCheckAgain,
-  translations
-}) {
-  async function checkAgainWithoutClosing(e) {
-    // Alert has weird behaviour of handling clicks by "a" tags
-    e.stopPropagation();
-
-    try {
-      renderAlert('Connecting...', Alert.Type.LOADING);
-      await onCheckAgain();
-    } catch (err) {
-      renderAlert( /*#__PURE__*/React.createElement(Message, {
-        translations: translations,
-        onCheckAgain: checkAgainWithoutClosing
-      }));
-    }
-  }
-
-  renderAlert( /*#__PURE__*/React.createElement(Message, {
-    translations: translations,
-    onCheckAgain: checkAgainWithoutClosing
-  }));
-  return () => alertService.remove(key);
-}
-
-class Listeners {
-  constructor() {
-    this.removeAll();
-  }
-
-  trigger(event, data) {
-    const handlers = this._all.get(event);
-
-    if (handlers) {
-      return Promise.all([...handlers].map(fn => fn(data)));
-    }
-
-    return Promise.resolve([]);
-  }
-
-  add(event, handler) {
-    let handlers = this._all.get(event);
-
-    if (!handlers) {
-      handlers = new Set();
-
-      this._all.set(event, handlers);
-    }
-
-    handlers.add(handler);
-  }
-
-  remove(event, handler) {
-    const handlers = this._all.get(event);
-
-    if (handlers) {
-      handlers.delete(handler);
-    }
-  }
-
-  removeAll() {
-    this._all = new Map();
-  }
-
-}
-
-// Useful for using fetch with timeout
-// https://github.com/github/fetch/issues/175#issuecomment-284787564
-function promiseWithTimeout(promise, timeout, {
-  error
-}) {
-  return new Promise((resolve, reject) => {
-    setTimeout(() => reject(error || new Error('Timeout')), timeout);
-    promise.then(resolve, reject);
-  });
-}
-
-/**
- * @typedef {Object} StoredToken
- * @property {string} accessToken
- * @property {string[]} scopes
- * @property {number} expires
- */
-
-/**
- * @typedef {Object} StoredState
- * @property {Date} created
- * @property {string} restoreLocation
- * @property {string[]} scopes
- */
-
-const DEFAULT_STATE_QUOTA = 102400; // 100 kb ~~ 200 tabs with a large list of scopes
-// eslint-disable-next-line no-magic-numbers
-
-const DEFAULT_STATE_TTL = 1000 * 60 * 60 * 24; // nobody will need auth state after a day
-
-const UPDATE_USER_TIMEOUT = 1000;
-class AuthStorage {
-  /**
-   * Custom storage for Auth
-   * @param {{stateKeyPrefix: string, tokenKey: string, onTokenRemove: Function}} config
-   */
-  constructor(config) {
-    this.messagePrefix = config.messagePrefix || '';
-    this.stateKeyPrefix = config.stateKeyPrefix;
-    this.tokenKey = config.tokenKey;
-    this.userKey = config.userKey || 'user-key';
-    this.stateTTL = config.stateTTL || DEFAULT_STATE_TTL;
-    this._lastMessage = null;
-    const StorageConstructor = config.storage || ActualStorage;
-    this.stateQuota = Math.min(config.stateQuota || DEFAULT_STATE_QUOTA, StorageConstructor.QUOTA || Infinity);
-    this._stateStorage = new StorageConstructor({
-      cookieName: 'ring-state'
-    });
-    this._tokenStorage = new StorageConstructor({
-      cookieName: 'ring-token'
-    });
-    this._messagesStorage = new StorageConstructor({
-      cookieName: 'ring-message'
-    });
-    this._currentUserStorage = new StorageConstructor({
-      cookieName: 'ring-user'
-    });
-  }
-  /**
-   * Add token change listener
-   * @param {function(string)} fn Token change listener
-   * @return {function()} remove listener function
-   */
-
-
-  onTokenChange(fn) {
-    return this._tokenStorage.on(this.tokenKey, fn);
-  }
-  /**
-   * Add state change listener
-   * @param {string} stateKey State key
-   * @param {function(string)} fn State change listener
-   * @return {function()} remove listener function
-   */
-
-
-  onStateChange(stateKey, fn) {
-    return this._stateStorage.on(this.stateKeyPrefix + stateKey, fn);
-  }
-  /**
-   * Add state change listener
-   * @param {string} key State key
-   * @param {function(string)} fn State change listener
-   * @return {function()} remove listener function
-   */
-
-
-  onMessage(key, fn) {
-    return this._messagesStorage.on(this.messagePrefix + key, message => fn(message));
-  }
-
-  sendMessage(key, message = null) {
-    this._lastMessage = message;
-
-    this._messagesStorage.set(this.messagePrefix + key, message);
-  }
-  /**
-   * Save authentication request state.
-   *
-   * @param {string} id Unique state identifier
-   * @param {StoredState} state State to store
-   * @param {boolean=} dontCleanAndRetryOnFail If falsy then remove all stored states and try again to save state
-   */
-
-
-  async saveState(id, state, dontCleanAndRetryOnFail) {
-    state.created = Date.now();
-
-    try {
-      await this._stateStorage.set(this.stateKeyPrefix + id, state);
-    } catch (e) {
-      if (!dontCleanAndRetryOnFail) {
-        await this.cleanStates();
-        return this.saveState(id, state, true);
-      } else {
-        throw e;
-      }
-    }
-
-    return undefined;
-  }
-  /**
-   * Remove all stored states
-   *
-   * @return {Promise} promise that is resolved when OLD states [and some selected] are removed
-   */
-
-
-  async cleanStates(removeStateId) {
-    const now = Date.now();
-    const removalResult = await this._stateStorage.each((key, state) => {
-      // Remove requested state
-      if (key === this.stateKeyPrefix + removeStateId) {
-        return this._stateStorage.remove(key);
-      }
-
-      if (key.indexOf(this.stateKeyPrefix) === 0) {
-        // Clean old states
-        if (state.created + this.stateTTL < now) {
-          return this._stateStorage.remove(key);
-        } // Data to clean up due quota
-
-
-        return {
-          key,
-          created: state.created,
-          size: JSON.stringify(state).length
-        };
-      }
-
-      return undefined;
-    });
-    const currentStates = removalResult.filter(state => state);
-    let stateStorageSize = currentStates.reduce((overallSize, state) => state.size + overallSize, 0);
-
-    if (stateStorageSize > this.stateQuota) {
-      currentStates.sort((a, b) => a.created > b.created);
-      const removalPromises = currentStates.filter(state => {
-        if (stateStorageSize > this.stateQuota) {
-          stateStorageSize -= state.size;
-          return true;
-        }
-
-        return false;
-      }).map(state => this._stateStorage.remove(state.key));
-      return removalPromises.length && Promise.all(removalPromises);
-    }
-
-    return undefined;
-  }
-  /**
-   * Get state by id and remove stored states from the storage.
-   *
-   * @param {string} id unique state identifier
-   * @return {Promise.<StoredState>}
-   */
-
-
-  async getState(id) {
-    try {
-      const result = await this._stateStorage.get(this.stateKeyPrefix + id);
-      await this.cleanStates(id);
-      return result;
-    } catch (e) {
-      await this.cleanStates(id);
-      throw e;
-    }
-  }
-  /**
-   * @param {StoredToken} token
-   * @return {Promise} promise that is resolved when the token is saved
-   */
-
-
-  saveToken(token) {
-    return this._tokenStorage.set(this.tokenKey, token);
-  }
-  /**
-   * @return {Promise.<StoredToken>} promise that is resolved to the stored token
-   */
-
-
-  getToken() {
-    return this._tokenStorage.get(this.tokenKey);
-  }
-  /**
-   * Remove stored token if any.
-   * @return {Promise} promise that is resolved when the token is wiped.
-   */
-
-
-  wipeToken() {
-    return this._tokenStorage.remove(this.tokenKey);
-  }
-  /**
-   * @param {function} loadUser user loader
-   * @return {Promise.<object>>} promise that is resolved to stored current user
-   */
-
-
-  async getCachedUser(loadUser) {
-    const user = await this._currentUserStorage.get(this.userKey);
-
-    const loadAndCache = () => loadUser().then(response => {
-      this._currentUserStorage.set(this.userKey, response);
-
-      return response;
-    });
-
-    if (user && user.id) {
-      setTimeout(loadAndCache, UPDATE_USER_TIMEOUT);
-      return user;
-    } else {
-      return loadAndCache();
-    }
-  }
-  /**
-   * Remove cached user if any
-   */
-
-
-  wipeCachedCurrentUser() {
-    return this._currentUserStorage.remove(this.userKey);
-  }
-  /**
-   * Wipes cache if user has changed
-   */
-
-
-  onUserChanged() {
-    this.wipeCachedCurrentUser();
-  }
-
-}
-
-class AuthRequestBuilder {
-  /**
-   * @param {{
-   *   authorization: string,
-   *   redirectUri: string?,
-   *   requestCredentials: string?,
-   *   clientId: string?,
-   *   scopes: string[]
-   * }} config
-   * @param {AuthStorage} storage
-   */
-  constructor(config, storage) {
-    this.config = config;
-    this.storage = storage;
-  }
-  /**
-   * @return {string} random string used for state
-   */
-
-
-  /**
-   * Save state and build an auth server redirect URL.
-   *
-   * @param {object=} extraParams additional query parameters for auth request
-   * @param {object=} extraState additional state parameters to save
-   * @return {Promise.<string>} promise that is resolved to authURL
-   */
-  async prepareAuthRequest(extraParams, extraState) {
-    const stateId = AuthRequestBuilder._uuid();
-
-    const scopes = this.config.scopes.map(scope => encodeURIComponent(scope));
-    /* eslint-disable camelcase */
-
-    const request = Object.assign({
-      response_type: 'token',
-      state: stateId,
-      redirect_uri: this.config.redirectUri,
-      request_credentials: this.config.requestCredentials,
-      client_id: this.config.clientId,
-      scope: scopes.join(' ')
-    }, extraParams || {});
-    /* eslint-enable camelcase */
-
-    const authURL = encodeURL(this.config.authorization, request);
-    const state = Object.assign({
-      restoreLocation: window.location.href,
-      scopes: this.config.scopes
-    }, extraState || {});
-    await this._saveState(stateId, state);
-    return {
-      url: authURL,
-      stateId
-    };
-  }
-  /**
-   * @param {string} id
-   * @param {StoredState} storedState
-   * @return {Promise}
-   * @private
-   */
-
-
-  _saveState(id, storedState) {
-    return this.storage.saveState(id, storedState);
-  }
-
-}
-
-_defineProperty(AuthRequestBuilder, "_uuid", uuid.generate);
-
-class TokenValidator {
-  constructor(config, getUser, storage) {
-    this._getUser = getUser;
-    this._config = config;
-    this._storage = storage;
-  }
-  /**
-   * Returns epoch - seconds since 1970.
-   * Used for calculation of expire times.
-   * @return {number} epoch, seconds since 1970
-   * @private
-   */
-
-
-  static _epoch() {
-    const milliseconds = 1000.0;
-    return Math.round(Date.now() / milliseconds);
-  }
-  /**
-   * @const {number}
-   */
-  // eslint-disable-next-line no-magic-numbers
-
-
-  /**
-   * Check token validity against all conditions.
-   * @returns {Promise.<string>}
-   */
-  validateTokenLocally() {
-    return this._getValidatedToken([TokenValidator._validateExistence, TokenValidator._validateExpiration, this._validateScopes.bind(this)]);
-  }
-  /**
-   * Check token validity against all conditions.
-   * @returns {Promise.<string>}
-   */
-
-
-  validateToken() {
-    return this._getValidatedToken([TokenValidator._validateExistence, TokenValidator._validateExpiration, this._validateScopes.bind(this), this._validateAgainstUser.bind(this)]);
-  }
-  /**
-   * Check if there is a token
-   * @param {StoredToken} storedToken
-   * @return {Promise.<StoredToken>}
-   * @private
-   */
-
-
-  static _validateExistence(storedToken) {
-    if (!storedToken || !storedToken.accessToken) {
-      throw new TokenValidator.TokenValidationError('Token not found');
-    }
-  }
-  /**
-   * Check expiration
-   * @param {StoredToken} storedToken
-   * @return {Promise.<StoredToken>}
-   * @private
-   */
-
-
-  static _validateExpiration({
-    expires,
-    lifeTime
-  }) {
-    const REFRESH_BEFORE_RATIO = 6;
-    const refreshBefore = lifeTime ? Math.ceil(lifeTime / REFRESH_BEFORE_RATIO) : TokenValidator.DEFAULT_REFRESH_BEFORE;
-
-    if (expires && expires < TokenValidator._epoch() + refreshBefore) {
-      throw new TokenValidator.TokenValidationError('Token expired');
-    }
-  }
-  /**
-   * Check scopes
-   * @param {StoredToken} storedToken
-   * @return {Promise.<StoredToken>}
-   * @private
-   */
-
-
-  _validateScopes(storedToken) {
-    const {
-      scope,
-      optionalScopes
-    } = this._config;
-    const requiredScopes = optionalScopes ? scope.filter(scopeId => !optionalScopes.includes(scopeId)) : scope;
-    const hasAllScopes = requiredScopes.every(scopeId => storedToken.scopes.includes(scopeId));
-
-    if (!hasAllScopes) {
-      throw new TokenValidator.TokenValidationError('Token doesn\'t match required scopes');
-    }
-  }
-  /**
-   * Check by error code if token should be refreshed
-   * @param {string} error
-   * @return {boolean}
-   */
-
-
-  static shouldRefreshToken(error) {
-    return error === 'invalid_grant' || error === 'invalid_request' || error === 'invalid_token';
-  }
-  /**
-   * Check scopes
-   * @param {StoredToken} storedToken
-   * @return {Promise.<StoredToken>}
-   * @private
-   */
-
-
-  async _validateAgainstUser(storedToken) {
-    try {
-      return await this._getUser(storedToken.accessToken);
-    } catch (errorResponse) {
-      let response = {};
-
-      try {
-        response = await errorResponse.response.json();
-      } catch (e) {// Skip JSON parsing errors
-      }
-
-      if (errorResponse.status === CODE.UNAUTHORIZED || TokenValidator.shouldRefreshToken(response.error)) {
-        // Token expired
-        throw new TokenValidator.TokenValidationError(response.error || errorResponse.message);
-      } // Request unexpectedly failed
-
-
-      throw errorResponse;
-    }
-  }
-  /**
-   * Token Validator function
-   * @typedef {(function(StoredToken): Promise<StoredToken>)} TokenValidator
-   */
-
-  /**
-   * Gets stored token and applies provided validators
-   * @param {TokenValidator[]} validators An array of validation
-   * functions to check the stored token against.
-   * @return {Promise.<string>} promise that is resolved to access token if the stored token is valid. If it is
-   * invalid then the promise is rejected. If invalid token should be re-requested then rejection object will
-   * have {authRedirect: true}.
-   * @private
-   */
-
-
-  async _getValidatedToken(validators) {
-    const storedToken = await this._storage.getToken();
-
-    for (let i = 0; i < validators.length; i++) {
-      await validators[i](storedToken);
-    }
-
-    return storedToken.accessToken;
-  }
-
-}
-
-_defineProperty(TokenValidator, "DEFAULT_REFRESH_BEFORE", 10 * 60);
-
-_defineProperty(TokenValidator, "TokenValidationError", class TokenValidationError extends ExtendableError {
-  constructor(message, cause) {
-    super(message);
-    this.cause = cause;
-    this.authRedirect = true;
-  }
-
-});
-
-/* eslint-disable no-magic-numbers */
-
-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;
-/* eslint-enable no-magic-numbers */
-
-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() {}
-
-const DEFAULT_CONFIG = {
-  cacheCurrentUser: false,
-  reloadOnUserChange: true,
-  embeddedLogin: false,
-  EmbeddedLoginFlow: null,
-  clientId: '0-0-0-0-0',
-  redirectUri: getAbsoluteBaseURL(),
-  redirect: false,
-  requestCredentials: 'default',
-  backgroundRefreshTimeout: null,
-  scope: [],
-  userFields: ['guest', 'id', 'name', 'login', 'profile/avatar/url'],
-  cleanHash: true,
-  onLogout: noop,
-  onPostponeChangedUser: () => {},
-  onPostponeLogout: () => {},
-  enableBackendStatusCheck: true,
-  backendCheckTimeout: DEFAULT_BACKEND_CHECK_TIMEOUT,
-  checkBackendIsUp: () => Promise.resolve(null),
-  onBackendDown: () => {},
-  defaultExpiresIn: DEFAULT_EXPIRES_TIMEOUT,
-  translations: {
-    login: 'Log in',
-    loginTo: 'Log in to %serviceName%',
-    cancel: 'Cancel',
-    postpone: 'Postpone',
-    youHaveLoggedInAs: 'You have logged in as another user: %userName%',
-    applyChange: 'Apply change',
-    backendIsNotAvailable: 'Connection lost',
-    checkAgain: 'try again',
-    nothingHappensLink: 'Click here if nothing happens',
-    errorMessage: 'There may be a problem with your network connection. Make sure that you are online and'
-  }
-};
-class Auth {
-  constructor(config) {
-    _defineProperty(this, "config", {});
-
-    _defineProperty(this, "listeners", new Listeners());
-
-    _defineProperty(this, "http", null);
-
-    _defineProperty(this, "_service", {});
-
-    _defineProperty(this, "_storage", null);
-
-    _defineProperty(this, "_responseParser", new AuthResponseParser());
-
-    _defineProperty(this, "_requestBuilder", null);
-
-    _defineProperty(this, "_backgroundFlow", null);
-
-    _defineProperty(this, "_embeddedFlow", null);
-
-    _defineProperty(this, "_tokenValidator", null);
-
-    _defineProperty(this, "_postponed", false);
-
-    _defineProperty(this, "_backendCheckPromise", null);
-
-    _defineProperty(this, "_authDialogService", undefined);
-
-    if (!config) {
-      throw new Error('Config is required');
-    }
-
-    if (config.serverUri == null) {
-      throw new Error('\"serverUri\" property is required');
-    }
-
-    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: ${unsupportedParams.join(', ')}. Please change them from snake_case to camelCase.`);
-    }
-
-    config.userFields = config.userFields || [];
-    this.config = _objectSpread2(_objectSpread2({}, 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: [...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: `${clientId}-message-`,
-      stateKeyPrefix: `${clientId}-states-`,
-      tokenKey: `${clientId}-token`,
-      userKey: `${clientId}-user-`
-    });
-    this._domainStorage = new AuthStorage({
-      messagePrefix: 'domain-message-'
-    });
-    this._requestBuilder = new AuthRequestBuilder({
-      authorization: this.config.serverUri + Auth.API_PATH + Auth.API_AUTH_PATH,
-      clientId,
-      redirect,
-      redirectUri,
-      requestCredentials,
-      scopes: scope
-    }, this._storage);
-    let {
-      backgroundRefreshTimeout
-    } = this.config;
-
-    if (!backgroundRefreshTimeout) {
-      backgroundRefreshTimeout = this.config.embeddedLogin ? DEFAULT_BACKGROUND_TIMEOUT : BACKGROUND_REDIRECT_TIMEOUT;
-    }
-
-    this._backgroundFlow = new BackgroundFlow(this._requestBuilder, this._storage, backgroundRefreshTimeout);
-
-    if (this.config.EmbeddedLoginFlow) {
-      this._embeddedFlow = new this.config.EmbeddedLoginFlow(this._requestBuilder, this._storage, this.config.translations);
-    }
-
-    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);
-
-    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 === true) {
-      this.addListener(USER_CHANGED_EVENT, () => this._reloadCurrentPage());
-    }
-
-    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 => user && this._updateDomainUser(user.id));
-
-    if (this.config.cacheCurrentUser) {
-      this.addListener(LOGOUT_EVENT, () => this._storage.wipeCachedCurrentUser());
-      this.addListener(USER_CHANGED_EVENT, () => this._storage.onUserChanged());
-    }
-
-    this._createInitDeferred();
-
-    this.setUpPreconnect(config.serverUri);
-  }
-
-  _setPostponed(postponed = 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() {
-    this._initDeferred = {};
-    this._initDeferred.promise = new Promise((resolve, reject) => {
-      this._initDeferred.resolve = resolve;
-      this._initDeferred.reject = reject;
-    });
-  }
-  /**
-   * @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(token => {
-      const isGuest = this.user ? this.user.guest : false;
-
-      if (isGuest && !token) {
-        return;
-      }
-
-      if (!token) {
-        this.logout();
-      } else {
-        this._detectUserChange(token.accessToken);
-      }
-    });
-
-    this._domainStorage.onMessage(DOMAIN_USER_CHANGED_EVENT, ({
-      userID,
-      serviceID
-    }) => {
-      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 this.handleInitError(error);
-    } // Return endless promise in the background to avoid service start
-
-
-    if (state && state.nonRedirect) {
-      return new Promise(noop);
-    }
-
-    try {
-      var _state;
-
-      // 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 = state) === null || _state === void 0 ? void 0 : _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 this.handleInitValidationError(error);
-    }
-  }
-
-  async sendRedirect(error) {
-    const authRequest = await this._requestBuilder.prepareAuthRequest();
-
-    this._redirectCurrentPage(authRequest.url);
-
-    throw error;
-  }
-
-  async handleInitError(error) {
-    if (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 orginal error instead below
-      }
-    }
-
-    throw error;
-  }
-
-  async handleInitValidationError(error) {
-    // Redirect flow
-    if (error.authRedirect && this.config.redirect) {
-      return this.sendRedirect(error);
-    } // Background flow
-
-
-    if (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 this.sendRedirect(validationError);
-      }
-    }
-
-    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 {
-      await this._initDeferred.promise;
-
-      if (Auth.storageIsUnavailable) {
-        return null; // Forever guest if storage is unavailable
-      }
-
-      return await this._tokenValidator.validateTokenLocally();
-    } 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();
-      }
-
-      await this._backendCheckPromise;
-    } catch (e) {
-      throw new Error('Cannot refresh token: backend is not available. Postponed by user.');
-    } finally {
-      this._backendCheckPromise = null;
-    }
-
-    try {
-      return await this._backgroundFlow.authorize();
-    } catch (error) {
-      if (this._canShowDialogs()) {
-        return this._showAuthDialog({
-          nonInteractive: true,
-          error
-        });
-      } else {
-        const authRequest = await this._requestBuilder.prepareAuthRequest();
-
-        this._redirectCurrentPage(authRequest.url);
-      }
-
-      throw new TokenValidator.TokenValidationError(error.message);
-    }
-  }
-
-  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;
-
-    try {
-      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;
-        }
-
-        if (user.guest) {
-          this._showAuthDialog({
-            nonInteractive: true
-          });
-
-          return;
-        }
-
-        await this._showUserChangedDialog({
-          newUser: user,
-          onApply,
-          onPostpone: () => {
-            this.listeners.trigger(USER_CHANGE_POSTPONED_EVENT);
-            this.config.onPostponeChangedUser(this.user, user);
-          }
-        });
-      }
-    } catch (e) {// noop
-    }
-  }
-
-  _beforeLogout(params) {
-    if (this._canShowDialogs()) {
-      this._showAuthDialog(params);
-
-      return;
-    }
-
-    this.logout();
-  }
-
-  _showAuthDialog({
-    nonInteractive,
-    error,
-    canCancel
-  } = {}) {
-    const {
-      embeddedLogin,
-      onPostponeLogout,
-      translations
-    } = this.config;
-    const cancelable = this.user.guest || canCancel;
-
-    this._createInitDeferred();
-
-    const closeDialog = () => {
-      /* eslint-disable no-use-before-define */
-      stopTokenListening();
-      stopMessageListening();
-      hide();
-      /* eslint-enable no-use-before-define */
-    };
-
-    const onConfirm = () => {
-      if (embeddedLogin !== true) {
-        closeDialog();
-        this.logout();
-        return;
-      }
-
-      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;
-      }
-
-      if (this.user.guest && nonInteractive) {
-        this.forceTokenUpdate();
-      } else {
-        this._initDeferred.resolve();
-      }
-    };
-
-    const hide = this._authDialogService(_objectSpread2(_objectSpread2({}, this._service), {}, {
-      loginCaption: translations.login,
-      loginToCaption: translations.loginTo,
-      confirmLabel: translations.login,
-      cancelLabel: cancelable ? translations.cancel : translations.postpone,
-      errorMessage: error && error.toString ? error.toString() : null,
-      onConfirm,
-      onCancel
-    }));
-
-    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({
-    newUser,
-    onApply,
-    onPostpone
-  } = {}) {
-    const {
-      translations
-    } = this.config;
-
-    this._createInitDeferred();
-
-    const done = () => {
-      this._initDeferred.resolve(); // eslint-disable-next-line no-use-before-define
-
-
-      hide();
-    };
-
-    const hide = this._authDialogService(_objectSpread2(_objectSpread2({}, this._service), {}, {
-      title: translations.youHaveLoggedInAs.replace('%userName%', newUser.name),
-      loginCaption: translations.login,
-      loginToCaption: translations.loginTo,
-      confirmLabel: translations.applyChange,
-      cancelLabel: translations.postpone,
-      onConfirm: () => {
-        done();
-        onApply();
-      },
-      onCancel: () => {
-        done();
-        onPostpone();
-      }
-    }));
-  }
-
-  _showBackendDownDialog(backendError) {
-    const {
-      onBackendDown,
-      translations
-    } = this.config;
-    const REPEAT_TIMEOUT = 5000;
-    let timerId = null;
-    return new Promise((resolve, reject) => {
-      const done = () => {
-        /* eslint-disable no-use-before-define */
-        hide();
-        window.removeEventListener('online', onCheckAgain);
-        stopListeningCloseMessage();
-        /* eslint-enable no-use-before-define */
-
-        this._storage.sendMessage(Auth.CLOSE_BACKEND_DOWN_MESSAGE, Date.now());
-
-        this._awaitingForBackendPromise = null;
-        clearTimeout(timerId);
-      };
-
-      const stopListeningCloseMessage = this._storage.onMessage(Auth.CLOSE_BACKEND_DOWN_MESSAGE, () => {
-        stopListeningCloseMessage();
-        done();
-        resolve();
-      });
-
-      const onCheckAgain = async () => {
-        await this._checkBackendsAreUp();
-        done();
-        resolve();
-      };
-
-      const onPostpone = () => {
-        done();
-        reject(new Error('Auth(@jetbrains/ring-ui): postponed by user'));
-      };
-
-      const hide = onBackendDown({
-        onCheckAgain,
-        onPostpone,
-        backendError,
-        translations
-      });
-      window.addEventListener('online', onCheckAgain);
-
-      function networkWatchdog() {
-        if (navigator && navigator.onLine) {
-          onCheckAgain();
-        }
-
-        timerId = setTimeout(networkWatchdog, REPEAT_TIMEOUT);
-      }
-
-      timerId = setTimeout(networkWatchdog, REPEAT_TIMEOUT);
-    });
-  }
-  /**
-   * Wipe accessToken and redirect to auth page with required authorization
-   */
-
-
-  async logout(extraParams) {
-    const requestParams = _objectSpread2({
-      // eslint-disable-next-line camelcase
-      request_credentials: 'required'
-    }, extraParams);
-
-    await this._checkBackendsStatusesIfEnabled();
-    await this.listeners.trigger(LOGOUT_EVENT);
-
-    this._updateDomainUser(null);
-
-    await this._storage.wipeToken();
-    const authRequest = await this._requestBuilder.prepareAuthRequest(requestParams);
-
-    this._redirectCurrentPage(authRequest.url);
-  }
-
-  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 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);
-      }
-    } catch (e) {
-      this._beforeLogout();
-    }
-  }
-
-  async switchUser() {
-    if (this.config.embeddedLogin) {
-      await this._runEmbeddedLogin();
-    }
-
-    throw new Error('Auth: switchUser only supported for "embeddedLogin" mode');
-  }
-  /**
-   * 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))) || {};
-    const scopes = scope ? scope.split(' ') : newState.scopes || defaultScope || [];
-    const effectiveExpiresIn = expiresIn ? parseInt(expiresIn, 10) : defaultExpiresIn;
-    const expires = TokenValidator._epoch() + effectiveExpiresIn;
-    await this._storage.saveToken({
-      accessToken,
-      scopes,
-      expires,
-      lifeTime: effectiveExpiresIn
-    });
-    return newState;
-  }
-
-  async _checkForStateRestoration() {
-    const authResponse = this._responseParser._authResponse;
-
-    if (authResponse && this.config.cleanHash) {
-      this.setHash('');
-    }
-
-    const stateId = authResponse === null || authResponse === void 0 ? void 0 : authResponse.restoreAuthState;
-    return (await (stateId && this._storage.getState(stateId))) || {};
-  }
-
-  _checkBackendsAreUp() {
-    const {
-      backendCheckTimeout
-    } = this.config;
-    return Promise.all([promiseWithTimeout(this.http.fetch('settings/public?fields=id'), backendCheckTimeout, {
-      error: new Error('The authorization server is taking too long to respond. Please try again later.')
-    }), 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;
-    }
-
-    try {
-      await this._checkBackendsAreUp();
-    } catch (backendDownErr) {
-      await this._showBackendDownDialog(backendDownErr);
-    }
-  }
-  /**
-   * 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 = fixUrl(url);
-  }
-  /**
-   * 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, 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);
-
-/**
- * @name Auth
- *
- * @prop {object} config
- * @prop {string} config.serverUri
- * @prop {string} config.redirectUri
- * @prop {string} config.clientId
- * @prop {boolean=false} config.redirect — use redirects instead of loading the token in the background.
- * @prop {string[]} config.scope
- * @prop {string[]} config.optionalScopes
- * @prop {boolean} config.cleanHash - whether or not location.hash will be cleaned after authorization is completed.
- * Should be set to false in angular > 1.2.26 apps to prevent infinite redirect in Firefox
- * @prop {User?} user
- * @prop {string[]} config.userFields List of user data fields to be returned by auth.requestUser (default list is used in Header.HeaderHelper)
- * @prop {string[]} config.fetchCredentials
- *
- * @param {{
- *   serverUri: string,
- *   redirectUri: string?,
- *   requestCredentials: string?,
- *   clientId: string?,
- *   scope: string[]?,
- *   optionalScopes: string[]?,
- *   cleanHash: boolean?,
- *   fetchCredentials: string?,
- *   userFields: string[]?
- * }} config
- *
- */
-
-/**
- * Extend Auth config with non-required and not pure-JS stuff
- */
-
-Auth.DEFAULT_CONFIG = _objectSpread2(_objectSpread2({}, Auth.DEFAULT_CONFIG), {}, {
-  EmbeddedLoginFlow: WindowFlow,
-  onBackendDown: onBackendDown
-});
-
-export default Auth;
-export { DEFAULT_BACKGROUND_TIMEOUT, DEFAULT_EXPIRES_TIMEOUT, DOMAIN_USER_CHANGED_EVENT, LOGOUT_EVENT, LOGOUT_POSTPONED_EVENT, USER_CHANGED_EVENT, USER_CHANGE_POSTPONED_EVENT };