angular-oauth2-oidc/esm2022/oauth-service.mjs

import { Injectable, Optional, Inject } from '@angular/core';
import { HttpHeaders, HttpParams, } from '@angular/common/http';
import { Subject, of, race, from, combineLatest, throwError, } from 'rxjs';
import { filter, delay, first, tap, map, switchMap, debounceTime, catchError, } from 'rxjs/operators';
import { DOCUMENT } from '@angular/common';
import { OAuthInfoEvent, OAuthErrorEvent, OAuthSuccessEvent, } from './events';
import { b64DecodeUnicode, base64UrlEncode } from './base64-helper';
import { AuthConfig } from './auth.config';
import { WebHttpUrlEncodingCodec } from './encoder';
import * as i0 from "@angular/core";
import * as i1 from "@angular/common/http";
import * as i2 from "./types";
import * as i3 from "./token-validation/validation-handler";
import * as i4 from "./auth.config";
import * as i5 from "./url-helper.service";
import * as i6 from "./token-validation/hash-handler";
import * as i7 from "./date-time-provider";
/**
 * Service for logging in and logging out with
 * OIDC and OAuth2. Supports implicit flow and
 * password flow.
 */
export class OAuthService extends AuthConfig {
    constructor(ngZone, http, storage, tokenValidationHandler, config, urlHelper, logger, crypto, document, dateTimeService) {
        super();
        this.ngZone = ngZone;
        this.http = http;
        this.config = config;
        this.urlHelper = urlHelper;
        this.logger = logger;
        this.crypto = crypto;
        this.dateTimeService = dateTimeService;
        /**
         * @internal
         * Deprecated:  use property events instead
         */
        this.discoveryDocumentLoaded = false;
        /**
         * The received (passed around) state, when logging
         * in with implicit flow.
         */
        this.state = '';
        this.eventsSubject = new Subject();
        this.discoveryDocumentLoadedSubject = new Subject();
        this.grantTypesSupported = [];
        this.inImplicitFlow = false;
        this.saveNoncesInLocalStorage = false;
        this.debug('angular-oauth2-oidc v10');
        // See https://github.com/manfredsteyer/angular-oauth2-oidc/issues/773 for why this is needed
        this.document = document;
        if (!config) {
            config = {};
        }
        this.discoveryDocumentLoaded$ =
            this.discoveryDocumentLoadedSubject.asObservable();
        this.events = this.eventsSubject.asObservable();
        if (tokenValidationHandler) {
            this.tokenValidationHandler = tokenValidationHandler;
        }
        if (config) {
            this.configure(config);
        }
        try {
            if (storage) {
                this.setStorage(storage);
            }
            else if (typeof sessionStorage !== 'undefined') {
                this.setStorage(sessionStorage);
            }
        }
        catch (e) {
            console.error('No OAuthStorage provided and cannot access default (sessionStorage).' +
                'Consider providing a custom OAuthStorage implementation in your module.', e);
        }
        // in IE, sessionStorage does not always survive a redirect
        if (this.checkLocalStorageAccessable()) {
            const ua = window?.navigator?.userAgent;
            const msie = ua?.includes('MSIE ') || ua?.includes('Trident');
            if (msie) {
                this.saveNoncesInLocalStorage = true;
            }
        }
        this.setupRefreshTimer();
    }
    checkLocalStorageAccessable() {
        if (typeof window === 'undefined')
            return false;
        const test = 'test';
        try {
            if (typeof window['localStorage'] === 'undefined')
                return false;
            localStorage.setItem(test, test);
            localStorage.removeItem(test);
            return true;
        }
        catch (e) {
            return false;
        }
    }
    /**
     * Use this method to configure the service
     * @param config the configuration
     */
    configure(config) {
        // For the sake of downward compatibility with
        // original configuration API
        Object.assign(this, new AuthConfig(), config);
        this.config = Object.assign({}, new AuthConfig(), config);
        if (this.sessionChecksEnabled) {
            this.setupSessionCheck();
        }
        this.configChanged();
    }
    configChanged() {
        this.setupRefreshTimer();
    }
    restartSessionChecksIfStillLoggedIn() {
        if (this.hasValidIdToken()) {
            this.initSessionCheck();
        }
    }
    restartRefreshTimerIfStillLoggedIn() {
        this.setupExpirationTimers();
    }
    setupSessionCheck() {
        this.events
            .pipe(filter((e) => e.type === 'token_received'))
            .subscribe(() => {
            this.initSessionCheck();
        });
    }
    /**
     * Will setup up silent refreshing for when the token is
     * about to expire. When the user is logged out via this.logOut method, the
     * silent refreshing will pause and not refresh the tokens until the user is
     * logged back in via receiving a new token.
     * @param params Additional parameter to pass
     * @param listenTo Setup automatic refresh of a specific token type
     */
    setupAutomaticSilentRefresh(params = {}, listenTo, noPrompt = true) {
        let shouldRunSilentRefresh = true;
        this.clearAutomaticRefreshTimer();
        this.automaticRefreshSubscription = this.events
            .pipe(tap((e) => {
            if (e.type === 'token_received') {
                shouldRunSilentRefresh = true;
            }
            else if (e.type === 'logout') {
                shouldRunSilentRefresh = false;
            }
        }), filter((e) => e.type === 'token_expires' &&
            (listenTo == null || listenTo === 'any' || e.info === listenTo)), debounceTime(1000))
            .subscribe(() => {
            if (shouldRunSilentRefresh) {
                // this.silentRefresh(params, noPrompt).catch(_ => {
                this.refreshInternal(params, noPrompt).catch(() => {
                    this.debug('Automatic silent refresh did not work');
                });
            }
        });
        this.restartRefreshTimerIfStillLoggedIn();
    }
    refreshInternal(params, noPrompt) {
        if (!this.useSilentRefresh && this.responseType === 'code') {
            return this.refreshToken();
        }
        else {
            return this.silentRefresh(params, noPrompt);
        }
    }
    /**
     * Convenience method that first calls `loadDiscoveryDocument(...)` and
     * directly chains using the `then(...)` part of the promise to call
     * the `tryLogin(...)` method.
     *
     * @param options LoginOptions to pass through to `tryLogin(...)`
     */
    loadDiscoveryDocumentAndTryLogin(options = null) {
        return this.loadDiscoveryDocument().then(() => {
            return this.tryLogin(options);
        });
    }
    /**
     * Convenience method that first calls `loadDiscoveryDocumentAndTryLogin(...)`
     * and if then chains to `initLoginFlow()`, but only if there is no valid
     * IdToken or no valid AccessToken.
     *
     * @param options LoginOptions to pass through to `tryLogin(...)`
     */
    loadDiscoveryDocumentAndLogin(options = null) {
        options = options || {};
        return this.loadDiscoveryDocumentAndTryLogin(options).then(() => {
            if (!this.hasValidIdToken() || !this.hasValidAccessToken()) {
                const state = typeof options.state === 'string' ? options.state : '';
                this.initLoginFlow(state);
                return false;
            }
            else {
                return true;
            }
        });
    }
    debug(...args) {
        if (this.showDebugInformation) {
            this.logger.debug(...args);
        }
    }
    validateUrlFromDiscoveryDocument(url) {
        const errors = [];
        const httpsCheck = this.validateUrlForHttps(url);
        const issuerCheck = this.validateUrlAgainstIssuer(url);
        if (!httpsCheck) {
            errors.push('https for all urls required. Also for urls received by discovery.');
        }
        if (!issuerCheck) {
            errors.push('Every url in discovery document has to start with the issuer url.' +
                'Also see property strictDiscoveryDocumentValidation.');
        }
        return errors;
    }
    validateUrlForHttps(url) {
        if (!url) {
            return true;
        }
        const lcUrl = url.toLowerCase();
        if (this.requireHttps === false) {
            return true;
        }
        if ((lcUrl.match(/^http:\/\/localhost($|[:/])/) ||
            lcUrl.match(/^http:\/\/localhost($|[:/])/)) &&
            this.requireHttps === 'remoteOnly') {
            return true;
        }
        return lcUrl.startsWith('https://');
    }
    assertUrlNotNullAndCorrectProtocol(url, description) {
        if (!url) {
            throw new Error(`'${description}' should not be null`);
        }
        if (!this.validateUrlForHttps(url)) {
            throw new Error(`'${description}' must use HTTPS (with TLS), or config value for property 'requireHttps' must be set to 'false' and allow HTTP (without TLS).`);
        }
    }
    validateUrlAgainstIssuer(url) {
        if (!this.strictDiscoveryDocumentValidation) {
            return true;
        }
        if (!url) {
            return true;
        }
        return url.toLowerCase().startsWith(this.issuer.toLowerCase());
    }
    setupRefreshTimer() {
        if (typeof window === 'undefined') {
            this.debug('timer not supported on this plattform');
            return;
        }
        if (this.hasValidIdToken() || this.hasValidAccessToken()) {
            this.clearAccessTokenTimer();
            this.clearIdTokenTimer();
            this.setupExpirationTimers();
        }
        if (this.tokenReceivedSubscription)
            this.tokenReceivedSubscription.unsubscribe();
        this.tokenReceivedSubscription = this.events
            .pipe(filter((e) => e.type === 'token_received'))
            .subscribe(() => {
            this.clearAccessTokenTimer();
            this.clearIdTokenTimer();
            this.setupExpirationTimers();
        });
    }
    setupExpirationTimers() {
        if (this.hasValidAccessToken()) {
            this.setupAccessTokenTimer();
        }
        if (!this.disableIdTokenTimer && this.hasValidIdToken()) {
            this.setupIdTokenTimer();
        }
    }
    setupAccessTokenTimer() {
        const expiration = this.getAccessTokenExpiration();
        const storedAt = this.getAccessTokenStoredAt();
        const timeout = this.calcTimeout(storedAt, expiration);
        this.ngZone.runOutsideAngular(() => {
            this.accessTokenTimeoutSubscription = of(new OAuthInfoEvent('token_expires', 'access_token'))
                .pipe(delay(timeout))
                .subscribe((e) => {
                this.ngZone.run(() => {
                    this.eventsSubject.next(e);
                });
            });
        });
    }
    setupIdTokenTimer() {
        const expiration = this.getIdTokenExpiration();
        const storedAt = this.getIdTokenStoredAt();
        const timeout = this.calcTimeout(storedAt, expiration);
        this.ngZone.runOutsideAngular(() => {
            this.idTokenTimeoutSubscription = of(new OAuthInfoEvent('token_expires', 'id_token'))
                .pipe(delay(timeout))
                .subscribe((e) => {
                this.ngZone.run(() => {
                    this.eventsSubject.next(e);
                });
            });
        });
    }
    /**
     * Stops timers for automatic refresh.
     * To restart it, call setupAutomaticSilentRefresh again.
     */
    stopAutomaticRefresh() {
        this.clearAccessTokenTimer();
        this.clearIdTokenTimer();
        this.clearAutomaticRefreshTimer();
    }
    clearAccessTokenTimer() {
        if (this.accessTokenTimeoutSubscription) {
            this.accessTokenTimeoutSubscription.unsubscribe();
        }
    }
    clearIdTokenTimer() {
        if (this.idTokenTimeoutSubscription) {
            this.idTokenTimeoutSubscription.unsubscribe();
        }
    }
    clearAutomaticRefreshTimer() {
        if (this.automaticRefreshSubscription) {
            this.automaticRefreshSubscription.unsubscribe();
        }
    }
    calcTimeout(storedAt, expiration) {
        const now = this.dateTimeService.now();
        const delta = (expiration - storedAt) * this.timeoutFactor - (now - storedAt);
        const duration = Math.max(0, delta);
        const maxTimeoutValue = 2147483647;
        return duration > maxTimeoutValue ? maxTimeoutValue : duration;
    }
    /**
     * DEPRECATED. Use a provider for OAuthStorage instead:
     *
     * { provide: OAuthStorage, useFactory: oAuthStorageFactory }
     * export function oAuthStorageFactory(): OAuthStorage { return localStorage; }
     * Sets a custom storage used to store the received
     * tokens on client side. By default, the browser's
     * sessionStorage is used.
     * @ignore
     *
     * @param storage
     */
    setStorage(storage) {
        this._storage = storage;
        this.configChanged();
    }
    /**
     * Loads the discovery document to configure most
     * properties of this service. The url of the discovery
     * document is infered from the issuer's url according
     * to the OpenId Connect spec. To use another url you
     * can pass it to to optional parameter fullUrl.
     *
     * @param fullUrl
     */
    loadDiscoveryDocument(fullUrl = null) {
        return new Promise((resolve, reject) => {
            if (!fullUrl) {
                fullUrl = this.issuer || '';
                if (!fullUrl.endsWith('/')) {
                    fullUrl += '/';
                }
                fullUrl += '.well-known/openid-configuration';
            }
            if (!this.validateUrlForHttps(fullUrl)) {
                reject("issuer  must use HTTPS (with TLS), or config value for property 'requireHttps' must be set to 'false' and allow HTTP (without TLS).");
                return;
            }
            this.http.get(fullUrl).subscribe((doc) => {
                if (!this.validateDiscoveryDocument(doc)) {
                    this.eventsSubject.next(new OAuthErrorEvent('discovery_document_validation_error', null));
                    reject('discovery_document_validation_error');
                    return;
                }
                this.loginUrl = doc.authorization_endpoint;
                this.logoutUrl = doc.end_session_endpoint || this.logoutUrl;
                this.grantTypesSupported = doc.grant_types_supported;
                this.issuer = doc.issuer;
                this.tokenEndpoint = doc.token_endpoint;
                this.userinfoEndpoint =
                    doc.userinfo_endpoint || this.userinfoEndpoint;
                this.jwksUri = doc.jwks_uri;
                this.sessionCheckIFrameUrl =
                    doc.check_session_iframe || this.sessionCheckIFrameUrl;
                this.discoveryDocumentLoaded = true;
                this.discoveryDocumentLoadedSubject.next(doc);
                this.revocationEndpoint =
                    doc.revocation_endpoint || this.revocationEndpoint;
                if (this.sessionChecksEnabled) {
                    this.restartSessionChecksIfStillLoggedIn();
                }
                this.loadJwks()
                    .then((jwks) => {
                    const result = {
                        discoveryDocument: doc,
                        jwks: jwks,
                    };
                    const event = new OAuthSuccessEvent('discovery_document_loaded', result);
                    this.eventsSubject.next(event);
                    resolve(event);
                    return;
                })
                    .catch((err) => {
                    this.eventsSubject.next(new OAuthErrorEvent('discovery_document_load_error', err));
                    reject(err);
                    return;
                });
            }, (err) => {
                this.logger.error('error loading discovery document', err);
                this.eventsSubject.next(new OAuthErrorEvent('discovery_document_load_error', err));
                reject(err);
            });
        });
    }
    loadJwks() {
        return new Promise((resolve, reject) => {
            if (this.jwksUri) {
                this.http.get(this.jwksUri).subscribe((jwks) => {
                    this.jwks = jwks;
                    // this.eventsSubject.next(
                    //   new OAuthSuccessEvent('discovery_document_loaded')
                    // );
                    resolve(jwks);
                }, (err) => {
                    this.logger.error('error loading jwks', err);
                    this.eventsSubject.next(new OAuthErrorEvent('jwks_load_error', err));
                    reject(err);
                });
            }
            else {
                resolve(null);
            }
        });
    }
    validateDiscoveryDocument(doc) {
        let errors;
        if (!this.skipIssuerCheck && doc.issuer !== this.issuer) {
            this.logger.error('invalid issuer in discovery document', 'expected: ' + this.issuer, 'current: ' + doc.issuer);
            return false;
        }
        errors = this.validateUrlFromDiscoveryDocument(doc.authorization_endpoint);
        if (errors.length > 0) {
            this.logger.error('error validating authorization_endpoint in discovery document', errors);
            return false;
        }
        errors = this.validateUrlFromDiscoveryDocument(doc.end_session_endpoint);
        if (errors.length > 0) {
            this.logger.error('error validating end_session_endpoint in discovery document', errors);
            return false;
        }
        errors = this.validateUrlFromDiscoveryDocument(doc.token_endpoint);
        if (errors.length > 0) {
            this.logger.error('error validating token_endpoint in discovery document', errors);
        }
        errors = this.validateUrlFromDiscoveryDocument(doc.revocation_endpoint);
        if (errors.length > 0) {
            this.logger.error('error validating revocation_endpoint in discovery document', errors);
        }
        errors = this.validateUrlFromDiscoveryDocument(doc.userinfo_endpoint);
        if (errors.length > 0) {
            this.logger.error('error validating userinfo_endpoint in discovery document', errors);
            return false;
        }
        errors = this.validateUrlFromDiscoveryDocument(doc.jwks_uri);
        if (errors.length > 0) {
            this.logger.error('error validating jwks_uri in discovery document', errors);
            return false;
        }
        if (this.sessionChecksEnabled && !doc.check_session_iframe) {
            this.logger.warn('sessionChecksEnabled is activated but discovery document' +
                ' does not contain a check_session_iframe field');
        }
        return true;
    }
    /**
     * Uses password flow to exchange userName and password for an
     * access_token. After receiving the access_token, this method
     * uses it to query the userinfo endpoint in order to get information
     * about the user in question.
     *
     * When using this, make sure that the property oidc is set to false.
     * Otherwise stricter validations take place that make this operation
     * fail.
     *
     * @param userName
     * @param password
     * @param headers Optional additional http-headers.
     */
    fetchTokenUsingPasswordFlowAndLoadUserProfile(userName, password, headers = new HttpHeaders()) {
        return this.fetchTokenUsingPasswordFlow(userName, password, headers).then(() => this.loadUserProfile());
    }
    /**
     * Loads the user profile by accessing the user info endpoint defined by OpenId Connect.
     *
     * When using this with OAuth2 password flow, make sure that the property oidc is set to false.
     * Otherwise stricter validations take place that make this operation fail.
     */
    loadUserProfile() {
        if (!this.hasValidAccessToken()) {
            throw new Error('Can not load User Profile without access_token');
        }
        if (!this.validateUrlForHttps(this.userinfoEndpoint)) {
            throw new Error("userinfoEndpoint must use HTTPS (with TLS), or config value for property 'requireHttps' must be set to 'false' and allow HTTP (without TLS).");
        }
        return new Promise((resolve, reject) => {
            const headers = new HttpHeaders().set('Authorization', 'Bearer ' + this.getAccessToken());
            this.http
                .get(this.userinfoEndpoint, {
                headers,
                observe: 'response',
                responseType: 'text',
            })
                .subscribe((response) => {
                this.debug('userinfo received', JSON.stringify(response));
                if (response.headers
                    .get('content-type')
                    .startsWith('application/json')) {
                    let info = JSON.parse(response.body);
                    const existingClaims = this.getIdentityClaims() || {};
                    if (!this.skipSubjectCheck) {
                        if (this.oidc &&
                            (!existingClaims['sub'] || info.sub !== existingClaims['sub'])) {
                            const err = 'if property oidc is true, the received user-id (sub) has to be the user-id ' +
                                'of the user that has logged in with oidc.\n' +
                                'if you are not using oidc but just oauth2 password flow set oidc to false';
                            reject(err);
                            return;
                        }
                    }
                    info = Object.assign({}, existingClaims, info);
                    this._storage.setItem('id_token_claims_obj', JSON.stringify(info));
                    this.eventsSubject.next(new OAuthSuccessEvent('user_profile_loaded'));
                    resolve({ info });
                }
                else {
                    this.debug('userinfo is not JSON, treating it as JWE/JWS');
                    this.eventsSubject.next(new OAuthSuccessEvent('user_profile_loaded'));
                    resolve(JSON.parse(response.body));
                }
            }, (err) => {
                this.logger.error('error loading user info', err);
                this.eventsSubject.next(new OAuthErrorEvent('user_profile_load_error', err));
                reject(err);
            });
        });
    }
    /**
     * Uses password flow to exchange userName and password for an access_token.
     * @param userName
     * @param password
     * @param headers Optional additional http-headers.
     */
    fetchTokenUsingPasswordFlow(userName, password, headers = new HttpHeaders()) {
        const parameters = {
            username: userName,
            password: password,
        };
        return this.fetchTokenUsingGrant('password', parameters, headers);
    }
    /**
     * Uses a custom grant type to retrieve tokens.
     * @param grantType Grant type.
     * @param parameters Parameters to pass.
     * @param headers Optional additional HTTP headers.
     */
    fetchTokenUsingGrant(grantType, parameters, headers = new HttpHeaders()) {
        this.assertUrlNotNullAndCorrectProtocol(this.tokenEndpoint, 'tokenEndpoint');
        /**
         * A `HttpParameterCodec` that uses `encodeURIComponent` and `decodeURIComponent` to
         * serialize and parse URL parameter keys and values.
         *
         * @stable
         */
        let params = new HttpParams({ encoder: new WebHttpUrlEncodingCodec() })
            .set('grant_type', grantType)
            .set('scope', this.scope);
        if (this.useHttpBasicAuth) {
            const header = btoa(`${this.clientId}:${this.dummyClientSecret}`);
            headers = headers.set('Authorization', 'Basic ' + header);
        }
        if (!this.useHttpBasicAuth) {
            params = params.set('client_id', this.clientId);
        }
        if (!this.useHttpBasicAuth && this.dummyClientSecret) {
            params = params.set('client_secret', this.dummyClientSecret);
        }
        if (this.customQueryParams) {
            for (const key of Object.getOwnPropertyNames(this.customQueryParams)) {
                params = params.set(key, this.customQueryParams[key]);
            }
        }
        // set explicit parameters last, to allow overwriting
        for (const key of Object.keys(parameters)) {
            params = params.set(key, parameters[key]);
        }
        headers = headers.set('Content-Type', 'application/x-www-form-urlencoded');
        return new Promise((resolve, reject) => {
            this.http
                .post(this.tokenEndpoint, params, { headers })
                .subscribe((tokenResponse) => {
                this.debug('tokenResponse', tokenResponse);
                this.storeAccessTokenResponse(tokenResponse.access_token, tokenResponse.refresh_token, tokenResponse.expires_in ||
                    this.fallbackAccessTokenExpirationTimeInSec, tokenResponse.scope, this.extractRecognizedCustomParameters(tokenResponse));
                if (this.oidc && tokenResponse.id_token) {
                    this.processIdToken(tokenResponse.id_token, tokenResponse.access_token).then((result) => {
                        this.storeIdToken(result);
                        resolve(tokenResponse);
                    });
                }
                this.eventsSubject.next(new OAuthSuccessEvent('token_received'));
                resolve(tokenResponse);
            }, (err) => {
                this.logger.error('Error performing ${grantType} flow', err);
                this.eventsSubject.next(new OAuthErrorEvent('token_error', err));
                reject(err);
            });
        });
    }
    /**
     * Refreshes the token using a refresh_token.
     * This does not work for implicit flow, b/c
     * there is no refresh_token in this flow.
     * A solution for this is provided by the
     * method silentRefresh.
     */
    refreshToken() {
        this.assertUrlNotNullAndCorrectProtocol(this.tokenEndpoint, 'tokenEndpoint');
        return new Promise((resolve, reject) => {
            let params = new HttpParams({ encoder: new WebHttpUrlEncodingCodec() })
                .set('grant_type', 'refresh_token')
                .set('scope', this.scope)
                .set('refresh_token', this._storage.getItem('refresh_token'));
            let headers = new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded');
            if (this.useHttpBasicAuth) {
                const header = btoa(`${this.clientId}:${this.dummyClientSecret}`);
                headers = headers.set('Authorization', 'Basic ' + header);
            }
            if (!this.useHttpBasicAuth) {
                params = params.set('client_id', this.clientId);
            }
            if (!this.useHttpBasicAuth && this.dummyClientSecret) {
                params = params.set('client_secret', this.dummyClientSecret);
            }
            if (this.customQueryParams) {
                for (const key of Object.getOwnPropertyNames(this.customQueryParams)) {
                    params = params.set(key, this.customQueryParams[key]);
                }
            }
            this.http
                .post(this.tokenEndpoint, params, { headers })
                .pipe(switchMap((tokenResponse) => {
                if (this.oidc && tokenResponse.id_token) {
                    return from(this.processIdToken(tokenResponse.id_token, tokenResponse.access_token, true)).pipe(tap((result) => this.storeIdToken(result)), map(() => tokenResponse));
                }
                else {
                    return of(tokenResponse);
                }
            }))
                .subscribe((tokenResponse) => {
                this.debug('refresh tokenResponse', tokenResponse);
                this.storeAccessTokenResponse(tokenResponse.access_token, tokenResponse.refresh_token, tokenResponse.expires_in ||
                    this.fallbackAccessTokenExpirationTimeInSec, tokenResponse.scope, this.extractRecognizedCustomParameters(tokenResponse));
                this.eventsSubject.next(new OAuthSuccessEvent('token_received'));
                this.eventsSubject.next(new OAuthSuccessEvent('token_refreshed'));
                resolve(tokenResponse);
            }, (err) => {
                this.logger.error('Error refreshing token', err);
                this.eventsSubject.next(new OAuthErrorEvent('token_refresh_error', err));
                reject(err);
            });
        });
    }
    removeSilentRefreshEventListener() {
        if (this.silentRefreshPostMessageEventListener) {
            window.removeEventListener('message', this.silentRefreshPostMessageEventListener);
            this.silentRefreshPostMessageEventListener = null;
        }
    }
    setupSilentRefreshEventListener() {
        this.removeSilentRefreshEventListener();
        this.silentRefreshPostMessageEventListener = (e) => {
            const message = this.processMessageEventMessage(e);
            if (this.checkOrigin && e.origin !== location.origin) {
                console.error('wrong origin requested silent refresh!');
            }
            this.tryLogin({
                customHashFragment: message,
                preventClearHashAfterLogin: true,
                customRedirectUri: this.silentRefreshRedirectUri || this.redirectUri,
            }).catch((err) => this.debug('tryLogin during silent refresh failed', err));
        };
        window.addEventListener('message', this.silentRefreshPostMessageEventListener);
    }
    /**
     * Performs a silent refresh for implicit flow.
     * Use this method to get new tokens when/before
     * the existing tokens expire.
     */
    silentRefresh(params = {}, noPrompt = true) {
        const claims = this.getIdentityClaims() || {};
        if (this.useIdTokenHintForSilentRefresh && this.hasValidIdToken()) {
            params['id_token_hint'] = this.getIdToken();
        }
        if (!this.validateUrlForHttps(this.loginUrl)) {
            throw new Error("loginUrl  must use HTTPS (with TLS), or config value for property 'requireHttps' must be set to 'false' and allow HTTP (without TLS).");
        }
        if (typeof this.document === 'undefined') {
            throw new Error('silent refresh is not supported on this platform');
        }
        const existingIframe = this.document.getElementById(this.silentRefreshIFrameName);
        if (existingIframe) {
            this.document.body.removeChild(existingIframe);
        }
        this.silentRefreshSubject = claims['sub'];
        const iframe = this.document.createElement('iframe');
        iframe.id = this.silentRefreshIFrameName;
        this.setupSilentRefreshEventListener();
        const redirectUri = this.silentRefreshRedirectUri || this.redirectUri;
        this.createLoginUrl(null, null, redirectUri, noPrompt, params).then((url) => {
            iframe.setAttribute('src', url);
            if (!this.silentRefreshShowIFrame) {
                iframe.style['display'] = 'none';
            }
            this.document.body.appendChild(iframe);
        });
        const errors = this.events.pipe(filter((e) => e instanceof OAuthErrorEvent), first());
        const success = this.events.pipe(filter((e) => e.type === 'token_received'), first());
        const timeout = of(new OAuthErrorEvent('silent_refresh_timeout', null)).pipe(delay(this.silentRefreshTimeout));
        return race([errors, success, timeout])
            .pipe(map((e) => {
            if (e instanceof OAuthErrorEvent) {
                if (e.type === 'silent_refresh_timeout') {
                    this.eventsSubject.next(e);
                }
                else {
                    e = new OAuthErrorEvent('silent_refresh_error', e);
                    this.eventsSubject.next(e);
                }
                throw e;
            }
            else if (e.type === 'token_received') {
                e = new OAuthSuccessEvent('silently_refreshed');
                this.eventsSubject.next(e);
            }
            return e;
        }))
            .toPromise();
    }
    /**
     * This method exists for backwards compatibility.
     * {@link OAuthService#initLoginFlowInPopup} handles both code
     * and implicit flows.
     */
    initImplicitFlowInPopup(options) {
        return this.initLoginFlowInPopup(options);
    }
    initLoginFlowInPopup(options) {
        options = options || {};
        return this.createLoginUrl(null, null, this.silentRefreshRedirectUri, false, {
            display: 'popup',
        }).then((url) => {
            return new Promise((resolve, reject) => {
                /**
                 * Error handling section
                 */
                const checkForPopupClosedInterval = 500;
                let windowRef = null;
                // If we got no window reference we open a window
                // else we are using the window already opened
                if (!options.windowRef) {
                    windowRef = window.open(url, 'ngx-oauth2-oidc-login', this.calculatePopupFeatures(options));
                }
                else if (options.windowRef && !options.windowRef.closed) {
                    windowRef = options.windowRef;
                    windowRef.location.href = url;
                }
                let checkForPopupClosedTimer;
                const tryLogin = (hash) => {
                    this.tryLogin({
                        customHashFragment: hash,
                        preventClearHashAfterLogin: true,
                        customRedirectUri: this.silentRefreshRedirectUri,
                    }).then(() => {
                        cleanup();
                        resolve(true);
                    }, (err) => {
                        cleanup();
                        reject(err);
                    });
                };
                const checkForPopupClosed = () => {
                    if (!windowRef || windowRef.closed) {
                        cleanup();
                        reject(new OAuthErrorEvent('popup_closed', {}));
                    }
                };
                if (!windowRef) {
                    reject(new OAuthErrorEvent('popup_blocked', {}));
                }
                else {
                    checkForPopupClosedTimer = window.setInterval(checkForPopupClosed, checkForPopupClosedInterval);
                }
                const cleanup = () => {
                    window.clearInterval(checkForPopupClosedTimer);
                    window.removeEventListener('storage', storageListener);
                    window.removeEventListener('message', listener);
                    if (windowRef !== null) {
                        windowRef.close();
                    }
                    windowRef = null;
                };
                const listener = (e) => {
                    const message = this.processMessageEventMessage(e);
                    if (message && message !== null) {
                        window.removeEventListener('storage', storageListener);
                        tryLogin(message);
                    }
                    else {
                        console.log('false event firing');
                    }
                };
                const storageListener = (event) => {
                    if (event.key === 'auth_hash') {
                        window.removeEventListener('message', listener);
                        tryLogin(event.newValue);
                    }
                };
                window.addEventListener('message', listener);
                window.addEventListener('storage', storageListener);
            });
        });
    }
    calculatePopupFeatures(options) {
        // Specify an static height and width and calculate centered position
        const height = options.height || 470;
        const width = options.width || 500;
        const left = window.screenLeft + (window.outerWidth - width) / 2;
        const top = window.screenTop + (window.outerHeight - height) / 2;
        return `location=no,toolbar=no,width=${width},height=${height},top=${top},left=${left}`;
    }
    processMessageEventMessage(e) {
        let expectedPrefix = '#';
        if (this.silentRefreshMessagePrefix) {
            expectedPrefix += this.silentRefreshMessagePrefix;
        }
        if (!e || !e.data || typeof e.data !== 'string') {
            return;
        }
        const prefixedMessage = e.data;
        if (!prefixedMessage.startsWith(expectedPrefix)) {
            return;
        }
        return '#' + prefixedMessage.substr(expectedPrefix.length);
    }
    canPerformSessionCheck() {
        if (!this.sessionChecksEnabled) {
            return false;
        }
        if (!this.sessionCheckIFrameUrl) {
            console.warn('sessionChecksEnabled is activated but there is no sessionCheckIFrameUrl');
            return false;
        }
        const sessionState = this.getSessionState();
        if (!sessionState) {
            console.warn('sessionChecksEnabled is activated but there is no session_state');
            return false;
        }
        if (typeof this.document === 'undefined') {
            return false;
        }
        return true;
    }
    setupSessionCheckEventListener() {
        this.removeSessionCheckEventListener();
        this.sessionCheckEventListener = (e) => {
            const origin = e.origin.toLowerCase();
            const issuer = this.issuer.toLowerCase();
            this.debug('sessionCheckEventListener');
            if (!issuer.startsWith(origin)) {
                this.debug('sessionCheckEventListener', 'wrong origin', origin, 'expected', issuer, 'event', e);
                return;
            }
            // only run in Angular zone if it is 'changed' or 'error'
            switch (e.data) {
                case 'unchanged':
                    this.ngZone.run(() => {
                        this.handleSessionUnchanged();
                    });
                    break;
                case 'changed':
                    this.ngZone.run(() => {
                        this.handleSessionChange();
                    });
                    break;
                case 'error':
                    this.ngZone.run(() => {
                        this.handleSessionError();
                    });
                    break;
            }
            this.debug('got info from session check inframe', e);
        };
        // prevent Angular from refreshing the view on every message (runs in intervals)
        this.ngZone.runOutsideAngular(() => {
            window.addEventListener('message', this.sessionCheckEventListener);
        });
    }
    handleSessionUnchanged() {
        this.debug('session check', 'session unchanged');
        this.eventsSubject.next(new OAuthInfoEvent('session_unchanged'));
    }
    handleSessionChange() {
        this.eventsSubject.next(new OAuthInfoEvent('session_changed'));
        this.stopSessionCheckTimer();
        if (!this.useSilentRefresh && this.responseType === 'code') {
            this.refreshToken()
                .then(() => {
                this.debug('token refresh after session change worked');
            })
                .catch(() => {
                this.debug('token refresh did not work after session changed');
                this.eventsSubject.next(new OAuthInfoEvent('session_terminated'));
                this.logOut(true);
            });
        }
        else if (this.silentRefreshRedirectUri) {
            this.silentRefresh().catch(() => this.debug('silent refresh failed after session changed'));
            this.waitForSilentRefreshAfterSessionChange();
        }
        else {
            this.eventsSubject.next(new OAuthInfoEvent('session_terminated'));
            this.logOut(true);
        }
    }
    waitForSilentRefreshAfterSessionChange() {
        this.events
            .pipe(filter((e) => e.type === 'silently_refreshed' ||
            e.type === 'silent_refresh_timeout' ||
            e.type === 'silent_refresh_error'), first())
            .subscribe((e) => {
            if (e.type !== 'silently_refreshed') {
                this.debug('silent refresh did not work after session changed');
                this.eventsSubject.next(new OAuthInfoEvent('session_terminated'));
                this.logOut(true);
            }
        });
    }
    handleSessionError() {
        this.stopSessionCheckTimer();
        this.eventsSubject.next(new OAuthInfoEvent('session_error'));
    }
    removeSessionCheckEventListener() {
        if (this.sessionCheckEventListener) {
            window.removeEventListener('message', this.sessionCheckEventListener);
            this.sessionCheckEventListener = null;
        }
    }
    initSessionCheck() {
        if (!this.canPerformSessionCheck()) {
            return;
        }
        const existingIframe = this.document.getElementById(this.sessionCheckIFrameName);
        if (existingIframe) {
            this.document.body.removeChild(existingIframe);
        }
        const iframe = this.document.createElement('iframe');
        iframe.id = this.sessionCheckIFrameName;
        this.setupSessionCheckEventListener();
        const url = this.sessionCheckIFrameUrl;
        iframe.setAttribute('src', url);
        iframe.style.display = 'none';
        this.document.body.appendChild(iframe);
        this.startSessionCheckTimer();
    }
    startSessionCheckTimer() {
        this.stopSessionCheckTimer();
        this.ngZone.runOutsideAngular(() => {
            this.sessionCheckTimer = setInterval(this.checkSession.bind(this), this.sessionCheckIntervall);
        });
    }
    stopSessionCheckTimer() {
        if (this.sessionCheckTimer) {
            clearInterval(this.sessionCheckTimer);
            this.sessionCheckTimer = null;
        }
    }
    checkSession() {
        const iframe = this.document.getElementById(this.sessionCheckIFrameName);
        if (!iframe) {
            this.logger.warn('checkSession did not find iframe', this.sessionCheckIFrameName);
        }
        const sessionState = this.getSessionState();
        if (!sessionState) {
            this.stopSessionCheckTimer();
        }
        const message = this.clientId + ' ' + sessionState;
        iframe.contentWindow.postMessage(message, this.issuer);
    }
    async createLoginUrl(state = '', loginHint = '', customRedirectUri = '', noPrompt = false, params = {}) {
        const that = this; // eslint-disable-line @typescript-eslint/no-this-alias
        let redirectUri;
        if (customRedirectUri) {
            redirectUri = customRedirectUri;
        }
        else {
            redirectUri = this.redirectUri;
        }
        const nonce = await this.createAndSaveNonce();
        if (state) {
            state =
                nonce + this.config.nonceStateSeparator + encodeURIComponent(state);
        }
        else {
            state = nonce;
        }
        if (!this.requestAccessToken && !this.oidc) {
            throw new Error('Either requestAccessToken or oidc or both must be true');
        }
        if (this.config.responseType) {
            this.responseType = this.config.responseType;
        }
        else {
            if (this.oidc && this.requestAccessToken) {
                this.responseType = 'id_token token';
            }
            else if (this.oidc && !this.requestAccessToken) {
                this.responseType = 'id_token';
            }
            else {
                this.responseType = 'token';
            }
        }
        const seperationChar = that.loginUrl.indexOf('?') > -1 ? '&' : '?';
        let scope = that.scope;
        if (this.oidc && !scope.match(/(^|\s)openid($|\s)/)) {
            scope = 'openid ' + scope;
        }
        let url = that.loginUrl +
            seperationChar +
            'response_type=' +
            encodeURIComponent(that.responseType) +
            '&client_id=' +
            encodeURIComponent(that.clientId) +
            '&state=' +
            encodeURIComponent(state) +
            '&redirect_uri=' +
            encodeURIComponent(redirectUri) +
            '&scope=' +
            encodeURIComponent(scope);
        if (this.responseType.includes('code') && !this.disablePKCE) {
            const [challenge, verifier] = await this.createChallangeVerifierPairForPKCE();
            if (this.saveNoncesInLocalStorage &&
                typeof window['localStorage'] !== 'undefined') {
                localStorage.setItem('PKCE_verifier', verifier);
            }
            else {
                this._storage.setItem('PKCE_verifier', verifier);
            }
            url += '&code_challenge=' + challenge;
            url += '&code_challenge_method=S256';
        }
        if (loginHint) {
            url += '&login_hint=' + encodeURIComponent(loginHint);
        }
        if (that.resource) {
            url += '&resource=' + encodeURIComponent(that.resource);
        }
        if (that.oidc) {
            url += '&nonce=' + encodeURIComponent(nonce);
        }
        if (noPrompt) {
            url += '&prompt=none';
        }
        for (const key of Object.keys(params)) {
            url +=
                '&' + encodeURIComponent(key) + '=' + encodeURIComponent(params[key]);
        }
        if (this.customQueryParams) {
            for (const key of Object.getOwnPropertyNames(this.customQueryParams)) {
                url +=
                    '&' + key + '=' + encodeURIComponent(this.customQueryParams[key]);
            }
        }
        return url;
    }
    initImplicitFlowInternal(additionalState = '', params = '') {
        if (this.inImplicitFlow) {
            return;
        }
        this.inImplicitFlow = true;
        if (!this.validateUrlForHttps(this.loginUrl)) {
            throw new Error("loginUrl  must use HTTPS (with TLS), or config value for property 'requireHttps' must be set to 'false' and allow HTTP (without TLS).");
        }
        let addParams = {};
        let loginHint = null;
        if (typeof params === 'string') {
            loginHint = params;
        }
        else if (typeof params === 'object') {
            addParams = params;
        }
        this.createLoginUrl(additionalState, loginHint, null, false, addParams)
            .then(this.config.openUri)
            .catch((error) => {
            console.error('Error in initImplicitFlow', error);
            this.inImplicitFlow = false;
        });
    }
    /**
     * Starts the implicit flow and redirects to user to
     * the auth servers' login url.
     *
     * @param additionalState Optional state that is passed around.
     *  You'll find this state in the property `state` after `tryLogin` logged in the user.
     * @param params Hash with additional parameter. If it is a string, it is used for the
     *               parameter loginHint (for the sake of compatibility with former versions)
     */
    initImplicitFlow(additionalState = '', params = '') {
        if (this.loginUrl !== '') {
            this.initImplicitFlowInternal(additionalState, params);
        }
        else {
            this.events
                .pipe(filter((e) => e.type === 'discovery_document_loaded'))
                .subscribe(() => this.initImplicitFlowInternal(additionalState, params));
        }
    }
    /**
     * Reset current implicit flow
     *
     * @description This method allows resetting the current implict flow in order to be initialized again.
     */
    resetImplicitFlow() {
        this.inImplicitFlow = false;
    }
    callOnTokenReceivedIfExists(options) {
        const that = this; // eslint-disable-line @typescript-eslint/no-this-alias
        if (options.onTokenReceived) {
            const tokenParams = {
                idClaims: that.getIdentityClaims(),
                idToken: that.getIdToken(),
                accessToken: that.getAccessToken(),
                state: that.state,
            };
            options.onTokenReceived(tokenParams);
        }
    }
    storeAccessTokenResponse(accessToken, refreshToken, expiresIn, grantedScopes, customParameters) {
        this._storage.setItem('access_token', accessToken);
        if (grantedScopes && !Array.isArray(grantedScopes)) {
            this._storage.setItem('granted_scopes', JSON.stringify(grantedScopes.split(' ')));
        }
        else if (grantedScopes && Array.isArray(grantedScopes)) {
            this._storage.setItem('granted_scopes', JSON.stringify(grantedScopes));
        }
        this._storage.setItem('access_token_stored_at', '' + this.dateTimeService.now());
        if (expiresIn) {
            const expiresInMilliSeconds = expiresIn * 1000;
            const now = this.dateTimeService.new();
            const expiresAt = now.getTime() + expiresInMilliSeconds;
            this._storage.setItem('expires_at', '' + expiresAt);
        }
        if (refreshToken) {
            this._storage.setItem('refresh_token', refreshToken);
        }
        if (customParameters) {
            customParameters.forEach((value, key) => {
                this._storage.setItem(key, value);
            });
        }
    }
    /**
     * Delegates to tryLoginImplicitFlow for the sake of competability
     * @param options Optional options.
     */
    tryLogin(options = null) {
        if (this.config.responseType === 'code') {
            return this.tryLoginCodeFlow(options).then(() => true);
        }
        else {
            return this.tryLoginImplicitFlow(options);
        }
    }
    parseQueryString(queryString) {
        if (!queryString || queryString.length === 0) {
            return {};
        }
        if (queryString.charAt(0) === '?') {
            queryString = queryString.substr(1);
        }
        return this.urlHelper.parseQueryString(queryString);
    }
    async tryLoginCodeFlow(options = null) {
        options = options || {};
        const querySource = options.customHashFragment
            ? options.customHashFragment.substring(1)
            : window.location.search;
        const parts = this.getCodePartsFromUrl(querySource);
        const code = parts['code'];
        const state = parts['state'];
        const sessionState = parts['session_state'];
        if (!options.preventClearHashAfterLogin) {
            const href = location.origin +
                location.pathname +
                location.search
                    .replace(/code=[^&$]*/, '')
                    .replace(/scope=[^&$]*/, '')
                    .replace(/state=[^&$]*/, '')
                    .replace(/session_state=[^&$]*/, '')
                    .replace(/^\?&/, '?')
                    .replace(/&$/, '')
                    .replace(/^\?$/, '')
                    .replace(/&+/g, '&')
                    .replace(/\?&/, '?')
                    .replace(/\?$/, '') +
                location.hash;
            history.replaceState(null, window.name, href);
        }
        const [nonceInState, userState] = this.parseState(state);
        this.state = userState;
        if (parts['error']) {
            this.debug('error trying to login');
            this.handleLoginError(options, parts);
            const err = new OAuthErrorEvent('code_error', {}, parts);
            this.eventsSubject.next(err);
            return Promise.reject(err);
        }
        if (!options.disableNonceCheck) {
            if (!nonceInState) {
                this.saveRequestedRoute();
                return Promise.resolve();
            }
            if (!options.disableOAuth2StateCheck) {
                const success = this.validateNonce(nonceInState);
                if (!success) {
                    const event = new OAuthErrorEvent('invalid_nonce_in_state', null);
                    this.eventsSubject.next(event);
                    return Promise.reject(event);
                }
            }
        }
        this.storeSessionState(sessionState);
        if (code) {
            await this.getTokenFromCode(code, options);
            this.restoreRequestedRoute();
            return Promise.resolve();
        }
        else {
            return Promise.resolve();
        }
    }
    saveRequestedRoute() {
        if (this.config.preserveRequestedRoute) {
            this._storage.setItem('requested_route', window.location.pathname + window.location.search);
        }
    }
    restoreRequestedRoute() {
        const requestedRoute = this._storage.getItem('requested_route');
        if (requestedRoute) {
            history.replaceState(null, '', window.location.origin + requestedRoute);
        }
    }
    /**
     * Retrieve the returned auth code from the redirect uri that has been called.
     * If required also check hash, as we could use hash location strategy.
     */
    getCodePartsFromUrl(queryString) {
        if (!queryString || queryString.length === 0) {
            return this.urlHelper.getHashFragmentParams();
        }
        // normalize query string
        if (queryString.charAt(0) === '?') {
            queryString = queryString.substr(1);
        }
        return this.urlHelper.parseQueryString(queryString);
    }
    /**
     * Get token using an intermediate code. Works for the Authorization Code flow.
     */
    getTokenFromCode(code, options) {
        let params = new HttpParams({ encoder: new WebHttpUrlEncodingCodec() })
            .set('grant_type', 'authorization_code')
            .set('code', code)
            .set('redirect_uri', options.customRedirectUri || this.redirectUri);
        if (!this.disablePKCE) {
            let PKCEVerifier;
            if (this.saveNoncesInLocalStorage &&
                typeof window['localStorage'] !== 'undefined') {
                PKCEVerifier = localStorage.getItem('PKCE_verifier');
            }
            else {
                PKCEVerifier = this._storage.getItem('PKCE_verifier');
            }
            if (!PKCEVerifier) {
                console.warn('No PKCE verifier found in oauth storage!');
            }
            else {
                params = params.set('code_verifier', PKCEVerifier);
            }
        }
        return this.fetchAndProcessToken(params, options);
    }
    fetchAndProcessToken(params, options) {
        options = options || {};
        this.assertUrlNotNullAndCorrectProtocol(this.tokenEndpoint, 'tokenEndpoint');
        let headers = new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded');
        if (this.useHttpBasicAuth) {
            const header = btoa(`${this.clientId}:${this.dummyClientSecret}`);
            headers = headers.set('Authorization', 'Basic ' + header);
        }
        if (!this.useHttpBasicAuth) {
            params = params.set('client_id', this.clientId);
        }
        if (!this.useHttpBasicAuth && this.dummyClientSecret) {
            params = params.set('client_secret', this.dummyClientSecret);
        }
        return new Promise((resolve, reject) => {
            if (this.customQueryParams) {
                for (const key of Object.getOwnPropertyNames(this.customQueryParams)) {
                    params = params.set(key, this.customQueryParams[key]);
                }
            }
            this.http
                .post(this.tokenEndpoint, params, { headers })
                .subscribe((tokenResponse) => {
                this.debug('refresh tokenResponse', tokenResponse);
                this.storeAccessTokenResponse(tokenResponse.access_token, tokenResponse.refresh_token, tokenResponse.expires_in ||
                    this.fallbackAccessTokenExpirationTimeInSec, tokenResponse.scope, this.extractRecognizedCustomParameters(tokenResponse));
                if (this.oidc && tokenResponse.id_token) {
                    this.processIdToken(tokenResponse.id_token, tokenResponse.access_token, options.disableNonceCheck)
                        .then((result) => {
                        this.storeIdToken(result);
                        this.eventsSubject.next(new OAuthSuccessEvent('token_received'));
                        this.eventsSubject.next(new OAuthSuccessEvent('token_refreshed'));
                        resolve(tokenResponse);
                    })
                        .catch((reason) => {
                        this.eventsSubject.next(new OAuthErrorEvent('token_validation_error', reason));
                        console.error('Error validating tokens');
                        console.error(reason);
                        reject(reason);
                    });
                }
                else {
                    this.eventsSubject.next(new OAuthSuccessEvent('token_received'));
                    this.eventsSubject.next(new OAuthSuccessEvent('token_refreshed'));
                    resolve(tokenResponse);
                }
            }, (err) => {
                console.error('Error getting token', err);
                this.eventsSubject.next(new OAuthErrorEvent('token_refresh_error', err));
                reject(err);
            });
        });
    }
    /**
     * Checks whether there are tokens in the hash fragment
     * as a result of the implicit flow. These tokens are
     * parsed, validated and used to sign the user in to the
     * current client.
     *
     * @param options Optional options.
     */
    tryLoginImplicitFlow(options = null) {
        options = options || {};
        let parts;
        if (options.customHashFragment) {
            parts = this.urlHelper.getHashFragmentParams(options.customHashFragment);
        }
        else {
            parts = this.urlHelper.getHashFragmentParams();
        }
        this.debug('parsed url', parts);
        const state = parts['state'];
        const [nonceInState, userState] = this.parseState(state);
        this.state = userState;
        if (parts['error']) {
            this.debug('error trying to login');
            this.handleLoginError(options, parts);
            const err = new OAuthErrorEvent('token_error', {}, parts);
            this.eventsSubject.next(err);
            return Promise.reject(err);
        }
        const accessToken = parts['access_token'];
        const idToken = parts['id_token'];
        const sessionState = parts['session_state'];
        const grantedScopes = parts['scope'];
        if (!this.requestAccessToken && !this.oidc) {
            return Promise.reject('Either requestAccessToken or oidc (or both) must be true.');
        }
        if (this.requestAccessToken && !accessToken) {
            return Promise.resolve(false);
        }
        if (this.requestAccessToken && !options.disableOAuth2StateCheck && !state) {
            return Promise.resolve(false);
        }
        if (this.oidc && !idToken) {
            return Promise.resolve(false);
        }
        if (this.sessionChecksEnabled && !sessionState) {
            this.logger.warn('session checks (Session Status Change Notification) ' +
                'were activated in the configuration but the id_token ' +
                'does not contain a session_state claim');
        }
        if (this.requestAccessToken && !options.disableNonceCheck) {
            const success = this.validateNonce(nonceInState);
            if (!success) {
                const event = new OAuthErrorEvent('invalid_nonce_in_state', null);
                this.eventsSubject.next(event);
                return Promise.reject(event);
            }
        }
        if (this.requestAccessToken) {
            this.storeAccessTokenResponse(accessToken, null, parts['expires_in'] || this.fallbackAccessTokenExpirationTimeInSec, grantedScopes);
        }
        if (!this.oidc) {
            this.eventsSubject.next(new OAuthSuccessEvent('token_received'));
            if (this.clearHashAfterLogin && !options.preventClearHashAfterLogin) {
                this.clearLocationHash();
            }
            this.callOnTokenReceivedIfExists(options);
            return Promise.resolve(true);
        }
        return this.processIdToken(idToken, accessToken, options.disableNonceCheck)
            .then((result) => {
            if (options.validationHandler) {
                return options
                    .validationHandler({
                    accessToken: accessToken,
                    idClaims: result.idTokenClaims,
                    idToken: result.idToken,
                    state: state,
                })
                    .then(() => result);
            }
            return result;
        })
            .then((result) => {
            this.storeIdToken(result);
            this.storeSessionState(sessionState);
            if (this.clearHashAfterLogin && !options.preventClearHashAfterLogin) {
                this.clearLocationHash();
            }
            this.eventsSubject.next(new OAuthSuccessEvent('token_received'));
            this.callOnTokenReceivedIfExists(options);
            this.inImplicitFlow = false;
            return true;
        })
            .catch((reason) => {
            this.eventsSubject.next(new OAuthErrorEvent('token_validation_error', reason));
            this.logger.error('Error validating tokens');
            this.logger.error(reason);
            return Promise.reject(reason);
        });
    }
    parseState(state) {
        let nonce = state;
        let userState = '';
        if (state) {
            const idx = state.indexOf(this.config.nonceStateSeparator);
            if (idx > -1) {
                nonce = state.substr(0, idx);
                userState = state.substr(idx + this.config.nonceStateSeparator.length);
            }
        }
        return [nonce, userState];
    }
    validateNonce(nonceInState) {
        let savedNonce;
        if (this.saveNoncesInLocalStorage &&
            typeof window['localStorage'] !== 'undefined') {
            savedNonce = localStorage.getItem('nonce');
        }
        else {
            savedNonce = this._storage.getItem('nonce');
        }
        if (savedNonce !== nonceInState) {
            const err = 'Validating access_token failed, wrong state/nonce.';
            console.error(err, savedNonce, nonceInState);
            return false;
        }
        return true;
    }
    storeIdToken(idToken) {
        this._storage.setItem('id_token', idToken.idToken);
        this._storage.setItem('id_token_claims_obj', idToken.idTokenClaimsJson);
        this._storage.setItem('id_token_expires_at', '' + idToken.idTokenExpiresAt);
        this._storage.setItem('id_token_stored_at', '' + this.dateTimeService.now());
    }
    storeSessionState(sessionState) {
        this._storage.setItem('session_state', sessionState);
    }
    getSessionState() {
        return this._storage.getItem('session_state');
    }
    handleLoginError(options, parts) {
        if (options.onLoginError) {
            options.onLoginError(parts);
        }
        if (this.clearHashAfterLogin && !options.preventClearHashAfterLogin) {
            this.clearLocationHash();
        }
    }
    getClockSkewInMsec(defaultSkewMsc = 600000) {
        if (!this.clockSkewInSec && this.clockSkewInSec !== 0) {
            return defaultSkewMsc;
        }
        return this.clockSkewInSec * 1000;
    }
    /**
     * @ignore
     */
    processIdToken(idToken, accessToken, skipNonceCheck = false) {
        const tokenParts = idToken.split('.');
        const headerBase64 = this.padBase64(tokenParts[0]);
        const headerJson = b64DecodeUnicode(headerBase64);
        const header = JSON.parse(headerJson);
        const claimsBase64 = this.padBase64(tokenParts[1]);
        const claimsJson = b64DecodeUnicode(claimsBase64);
        const claims = JSON.parse(claimsJson);
        let savedNonce;
        if (this.saveNoncesInLocalStorage &&
            typeof window['localStorage'] !== 'undefined') {
            savedNonce = localStorage.getItem('nonce');
        }
        else {
            savedNonce = this._storage.getItem('nonce');
        }
        if (Array.isArray(claims.aud)) {
            if (claims.aud.every((v) => v !== this.clientId)) {
                const err = 'Wrong audience: ' + claims.aud.join(',');
                this.logger.warn(err);
                return Promise.reject(err);
            }
        }
        else {
            if (claims.aud !== this.clientId) {
                const err = 'Wrong audience: ' + claims.aud;
                this.logger.warn(err);
                return Promise.reject(err);
            }
        }
        if (!claims.sub) {
            const err = 'No sub claim in id_token';
            this.logger.warn(err);
            return Promise.reject(err);
        }
        /* For now, we only check whether the sub against
         * silentRefreshSubject when sessionChecksEnabled is on
         * We will reconsider in a later version to do this
         * in every other case too.
         */
        if (this.sessionChecksEnabled &&
            this.silentRefreshSubject &&
            this.silentRefreshSubject !== claims['sub']) {
            const err = 'After refreshing, we got an id_token for another user (sub). ' +
                `Expected sub: ${this.silentRefreshSubject}, received sub: ${claims['sub']}`;
            this.logger.warn(err);
            return Promise.reject(err);
        }
        if (!claims.iat) {
            const err = 'No iat claim in id_token';
            this.logger.warn(err);
            return Promise.reject(err);
        }
        if (!this.skipIssuerCheck && claims.iss !== this.issuer) {
            const err = 'Wrong issuer: ' + claims.iss;
            this.logger.warn(err);
            return Promise.reject(err);
        }
        if (!skipNonceCheck && claims.nonce !== savedNonce) {
            const err = 'Wrong nonce: ' + claims.nonce;
            this.logger.warn(err);
            return Promise.reject(err);
        }
        // at_hash is not applicable to authorization code flow
        // addressing https://github.com/manfredsteyer/angular-oauth2-oidc/issues/661
        // i.e. Based on spec the at_hash check is only true for implicit code flow on Ping Federate
        // https://www.pingidentity.com/developer/en/resources/openid-connect-developers-guide.html
        if (Object.prototype.hasOwnProperty.call(this, 'responseType') &&
            (this.responseType === 'code' || this.responseType === 'id_token')) {
            this.disableAtHashCheck = true;
        }
        if (!this.disableAtHashCheck &&
            this.requestAccessToken &&
            !claims['at_hash']) {
            const err = 'An at_hash is needed!';
            this.logger.warn(err);
            return Promise.reject(err);
        }
        const now = this.dateTimeService.now();
        const issuedAtMSec = claims.iat * 1000;
        const expiresAtMSec = claims.exp * 1000;
        const clockSkewInMSec = this.getClockSkewInMsec(); // (this.getClockSkewInMsec() || 600) * 1000;
        if (issuedAtMSec - clockSkewInMSec >= now ||
            expiresAtMSec + clockSkewInMSec - this.decreaseExpirationBySec <= now) {
            const err = 'Token has expired';
            console.error(err);
            console.error({
                now: now,
                issuedAtMSec: issuedAtMSec,
                expiresAtMSec: expiresAtMSec,
            });
            return Promise.reject(err);
        }
        const validationParams = {
            accessToken: accessToken,
            idToken: idToken,
            jwks: this.jwks,
            idTokenClaims: claims,
            idTokenHeader: header,
            loadKeys: () => this.loadJwks(),
        };
        if (this.disableAtHashCheck) {
            return this.checkSignature(validationParams).then(() => {
                const result = {
                    idToken: idToken,
                    idTokenClaims: claims,
                    idTokenClaimsJson: claimsJson,
                    idTokenHeader: header,
                    idTokenHeaderJson: headerJson,
                    idTokenExpiresAt: expiresAtMSec,
                };
                return result;
            });
        }
        return this.checkAtHash(validationParams).then((atHashValid) => {
            if (!this.disableAtHashCheck && this.requestAccessToken && !atHashValid) {
                const err = 'Wrong at_hash';
                this.logger.warn(err);
                return Promise.reject(err);
            }
            return this.checkSignature(validationParams).then(() => {
                const atHashCheckEnabled = !this.disableAtHashCheck;
                const result = {
                    idToken: idToken,
                    idTokenClaims: claims,
                    idTokenClaimsJson: claimsJson,
                    idTokenHeader: header,
                    idTokenHeaderJson: headerJson,
                    idTokenExpiresAt: expiresAtMSec,
                };
                if (atHashCheckEnabled) {
                    return this.checkAtHash(validationParams).then((atHashValid) => {
                        if (this.requestAccessToken && !atHashValid) {
                            const err = 'Wrong at_hash';
                            this.logger.warn(err);
                            return Promise.reject(err);
                        }
                        else {
                            return result;
                        }
                    });
                }
                else {
                    return result;
                }
            });
        });
    }
    /**
     * Returns the received claims about the user.
     */
    getIdentityClaims() {
        const claims = this._storage.getItem('id_token_claims_obj');
        if (!claims) {
            return null;
        }
        return JSON.parse(claims);
    }
    /**
     * Returns the granted scopes from the server.
     */
    getGrantedScopes() {
        const scopes = this._storage.getItem('granted_scopes');
        if (!scopes) {
            return null;
        }
        return JSON.parse(scopes);
    }
    /**
     * Returns the current id_token.
     */
    getIdToken() {
        return this._storage ? this._storage.getItem('id_token') : null;
    }
    padBase64(base64data) {
        while (base64data.length % 4 !== 0) {
            base64data += '=';
        }
        return base64data;
    }
    /**
     * Returns the current access_token.
     */
    getAccessToken() {
        return this._storage ? this._storage.getItem('access_token') : null;
    }
    getRefreshToken() {
        return this._storage ? this._storage.getItem('refresh_token') : null;
    }
    /**
     * Returns the expiration date of the access_token
     * as milliseconds since 1970.
     */
    getAccessTokenExpiration() {
        if (!this._storage.getItem('expires_at')) {
            return null;
        }
        return parseInt(this._storage.getItem('expires_at'), 10);
    }
    getAccessTokenStoredAt() {
        return parseInt(this._storage.getItem('access_token_stored_at'), 10);
    }
    getIdTokenStoredAt() {
        return parseInt(this._storage.getItem('id_token_stored_at'), 10);
    }
    /**
     * Returns the expiration date of the id_token
     * as milliseconds since 1970.
     */
    getIdTokenExpiration() {
        if (!this._storage.getItem('id_token_expires_at')) {
            return null;
        }
        return parseInt(this._storage.getItem('id_token_expires_at'), 10);
    }
    /**
     * Checkes, whether there is a valid access_token.
     */
    hasValidAccessToken() {
        if (this.getAccessToken()) {
            const expiresAt = this._storage.getItem('expires_at');
            const now = this.dateTimeService.new();
            if (expiresAt &&
                parseInt(expiresAt, 10) - this.decreaseExpirationBySec <
                    now.getTime() - this.getClockSkewInMsec()) {
                return false;
            }
            return true;
        }
        return false;
    }
    /**
     * Checks whether there is a valid id_token.
     */
    hasValidIdToken() {
        if (this.getIdToken()) {
            const expiresAt = this._storage.getItem('id_token_expires_at');
            const now = this.dateTimeService.new();
            if (expiresAt &&
                parseInt(expiresAt, 10) - this.decreaseExpirationBySec <
                    now.getTime() - this.getClockSkewInMsec()) {
                return false;
            }
            return true;
        }
        return false;
    }
    /**
     * Retrieve a saved custom property of the TokenReponse object. Only if predefined in authconfig.
     */
    getCustomTokenResponseProperty(requestedProperty) {
        return this._storage &&
            this.config.customTokenParameters &&
            this.config.customTokenParameters.indexOf(requestedProperty) >= 0 &&
            this._storage.getItem(requestedProperty) !== null
            ? JSON.parse(this._storage.getItem(requestedProperty))
            : null;
    }
    /**
     * Returns the auth-header that can be used
     * to transmit the access_token to a service
     */
    authorizationHeader() {
        return 'Bearer ' + this.getAccessToken();
    }
    logOut(customParameters = {}, state = '') {
        let noRedirectToLogoutUrl = false;
        if (typeof customParameters === 'boolean') {
            noRedirectToLogoutUrl = customParameters;
            customParameters = {};
        }
        const id_token = this.getIdToken();
        this._storage.removeItem('access_token');
        this._storage.removeItem('id_token');
        this._storage.removeItem('refresh_token');
        if (this.saveNoncesInLocalStorage) {
            localStorage.removeItem('nonce');
            localStorage.removeItem('PKCE_verifier');
        }
        else {
            this._storage.removeItem('nonce');
            this._storage.removeItem('PKCE_verifier');
        }
        this._storage.removeItem('expires_at');
        this._storage.removeItem('id_token_claims_obj');
        this._storage.removeItem('id_token_expires_at');
        this._storage.removeItem('id_token_stored_at');
        this._storage.removeItem('access_token_stored_at');
        this._storage.removeItem('granted_scopes');
        this._storage.removeItem('session_state');
        if (this.config.customTokenParameters) {
            this.config.customTokenParameters.forEach((customParam) => this._storage.removeItem(customParam));
        }
        this.silentRefreshSubject = null;
        this.eventsSubject.next(new OAuthInfoEvent('logout'));
        if (!this.logoutUrl) {
            return;
        }
        if (noRedirectToLogoutUrl) {
            return;
        }
        // if (!id_token && !this.postLogoutRedirectUri) {
        //   return;
        // }
        let logoutUrl;
        if (!this.validateUrlForHttps(this.logoutUrl)) {
            throw new Error("logoutUrl  must use HTTPS (with TLS), or config value for property 'requireHttps' must be set to 'false' and allow HTTP (without TLS).");
        }
        // For backward compatibility
        if (this.logoutUrl.indexOf('{{') > -1) {
            logoutUrl = this.logoutUrl
                .replace(/\{\{id_token\}\}/, encodeURIComponent(id_token))
                .replace(/\{\{client_id\}\}/, encodeURIComponent(this.clientId));
        }
        else {
            let params = new HttpParams({ encoder: new WebHttpUrlEncodingCodec() });
            if (id_token) {
                params = params.set('id_token_hint', id_token);
            }
            const postLogoutUrl = this.postLogoutRedirectUri ||
                (this.redirectUriAsPostLogoutRedirectUriFallback && this.redirectUri) ||
                '';
            if (postLogoutUrl) {
                params = params.set('post_logout_redirect_uri', postLogoutUrl);
                if (state) {
                    params = params.set('state', state);
                }
            }
            for (const key in customParameters) {
                params = params.set(key, customParameters[key]);
            }
            logoutUrl =
                this.logoutUrl +
                    (this.logoutUrl.indexOf('?') > -1 ? '&' : '?') +
                    params.toString();
        }
        this.config.openUri(logoutUrl);
    }
    /**
     * @ignore
     */
    createAndSaveNonce() {
        const that = this; // eslint-disable-line @typescript-eslint/no-this-alias
        return this.createNonce().then(function (nonce) {
            // Use localStorage for nonce if possible
            // localStorage is the only storage who survives a
            // redirect in ALL browsers (also IE)
            // Otherwiese we'd force teams who have to support
            // IE into using localStorage for everything
            if (that.saveNoncesInLocalStorage &&
                typeof window['localStorage'] !== 'undefined') {
                localStorage.setItem('nonce', nonce);
            }
            else {
                that._storage.setItem('nonce', nonce);
            }
            return nonce;
        });
    }
    /**
     * @ignore
     */
    ngOnDestroy() {
        this.clearAccessTokenTimer();
        this.clearIdTokenTimer();
        this.removeSilentRefreshEventListener();
        const silentRefreshFrame = this.document.getElementById(this.silentRefreshIFrameName);
        if (silentRefreshFrame) {
            silentRefreshFrame.remove();
        }
        this.stopSessionCheckTimer();
        this.removeSessionCheckEventListener();
        const sessionCheckFrame = this.document.getElementById(this.sessionCheckIFrameName);
        if (sessionCheckFrame) {
            sessionCheckFrame.remove();
        }
    }
    createNonce() {
        return new Promise((resolve) => {
            if (this.rngUrl) {
                throw new Error('createNonce with rng-web-api has not been implemented so far');
            }
            /*
             * This alphabet is from:
             * https://tools.ietf.org/html/rfc7636#section-4.1
             *
             * [A-Z] / [a-z] / [0-9] / "-" / "." / "_" / "~"
             */
            const unreserved = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~';
            let size = 45;
            let id = '';
            const crypto = typeof self === 'undefined' ? null : self.crypto || self['msCrypto'];
            if (crypto) {
                let bytes = new Uint8Array(size);
                crypto.getRandomValues(bytes);
                // Needed for IE
                if (!bytes.map) {
                    bytes.map = Array.prototype.map;
                }
                bytes = bytes.map((x) => unreserved.charCodeAt(x % unreserved.length));
                id = String.fromCharCode.apply(null, bytes);
            }
            else {
                while (0 < size--) {
                    id += unreserved[(Math.random() * unreserved.length) | 0];
                }
            }
            resolve(base64UrlEncode(id));
        });
    }
    async checkAtHash(params) {
        if (!this.tokenValidationHandler) {
            this.logger.warn('No tokenValidationHandler configured. Cannot check at_hash.');
            return true;
        }
        return this.tokenValidationHandler.validateAtHash(params);
    }
    checkSignature(params) {
        if (!this.tokenValidationHandler) {
            this.logger.warn('No tokenValidationHandler configured. Cannot check signature.');
            return Promise.resolve(null);
        }
        return this.tokenValidationHandler.validateSignature(params);
    }
    /**
     * Start the implicit flow or the code flow,
     * depending on your configuration.
     */
    initLoginFlow(additionalState = '', params = {}) {
        if (this.responseType === 'code') {
            return this.initCodeFlow(additionalState, params);
        }
        else {
            return this.initImplicitFlow(additionalState, params);
        }
    }
    /**
     * Starts the authorization code flow and redirects to user to
     * the auth servers login url.
     */
    initCodeFlow(additionalState = '', params = {}) {
        if (this.loginUrl !== '') {
            this.initCodeFlowInternal(additionalState, params);
        }
        else {
            this.events
                .pipe(filter((e) => e.type === 'discovery_document_loaded'))
                .subscribe(() => this.initCodeFlowInternal(additionalState, params));
        }
    }
    initCodeFlowInternal(additionalState = '', params = {}) {
        if (!this.validateUrlForHttps(this.loginUrl)) {
            throw new Error("loginUrl  must use HTTPS (with TLS), or config value for property 'requireHttps' must be set to 'false' and allow HTTP (without TLS).");
        }
        let addParams = {};
        let loginHint = null;
        if (typeof params === 'string') {
            loginHint = params;
        }
        else if (typeof params === 'object') {
            addParams = params;
        }
        this.createLoginUrl(additionalState, loginHint, null, false, addParams)
            .then(this.config.openUri)
            .catch((error) => {
            console.error('Error in initAuthorizationCodeFlow');
            console.error(error);
        });
    }
    async createChallangeVerifierPairForPKCE() {
        if (!this.crypto) {
            throw new Error('PKCE support for code flow needs a CryptoHander. Did you import the OAuthModule using forRoot() ?');
        }
        const verifier = await this.createNonce();
        const challengeRaw = await this.crypto.calcHash(verifier, 'sha-256');
        const challenge = base64UrlEncode(challengeRaw);
        return [challenge, verifier];
    }
    extractRecognizedCustomParameters(tokenResponse) {
        const foundParameters = new Map();
        if (!this.config.customTokenParameters) {
            return foundParameters;
        }
        this.config.customTokenParameters.forEach((recognizedParameter) => {
            if (tokenResponse[recognizedParameter]) {
                foundParameters.set(recognizedParameter, JSON.stringify(tokenResponse[recognizedParameter]));
            }
        });
        return foundParameters;
    }
    /**
     * Revokes the auth token to secure the vulnarability
     * of the token issued allowing the authorization server to clean
     * up any security credentials associated with the authorization
     */
    revokeTokenAndLogout(customParameters = {}, ignoreCorsIssues = false) {
        const revokeEndpoint = this.revocationEndpoint;
        const accessToken = this.getAccessToken();
        const refreshToken = this.getRefreshToken();
        if (!accessToken) {
            return Promise.resolve();
        }
        let params = new HttpParams({ encoder: new WebHttpUrlEncodingCodec() });
        let headers = new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded');
        if (this.useHttpBasicAuth) {
            const header = btoa(`${this.clientId}:${this.dummyClientSecret}`);
            headers = headers.set('Authorization', 'Basic ' + header);
        }
        if (!this.useHttpBasicAuth) {
            params = params.set('client_id', this.clientId);
        }
        if (!this.useHttpBasicAuth && this.dummyClientSecret) {
            params = params.set('client_secret', this.dummyClientSecret);
        }
        if (this.customQueryParams) {
            for (const key of Object.getOwnPropertyNames(this.customQueryParams)) {
                params = params.set(key, this.customQueryParams[key]);
            }
        }
        return new Promise((resolve, reject) => {
            let revokeAccessToken;
            let revokeRefreshToken;
            if (accessToken) {
                const revokationParams = params
                    .set('token', accessToken)
                    .set('token_type_hint', 'access_token');
                revokeAccessToken = this.http.post(revokeEndpoint, revokationParams, { headers });
            }
            else {
                revokeAccessToken = of(null);
            }
            if (refreshToken) {
                const revokationParams = params
                    .set('token', refreshToken)
                    .set('token_type_hint', 'refresh_token');
                revokeRefreshToken = this.http.post(revokeEndpoint, revokationParams, { headers });
            }
            else {
                revokeRefreshToken = of(null);
            }
            if (ignoreCorsIssues) {
                revokeAccessToken = revokeAccessToken.pipe(catchError((err) => {
                    if (err.status === 0) {
                        return of(null);
                    }
                    return throwError(err);
                }));
                revokeRefreshToken = revokeRefreshToken.pipe(catchError((err) => {
                    if (err.status === 0) {
                        return of(null);
                    }
                    return throwError(err);
                }));
            }
            combineLatest([revokeAccessToken, revokeRefreshToken]).subscribe((res) => {
                this.logOut(customParameters);
                resolve(res);
                this.logger.info('Token successfully revoked');
            }, (err) => {
                this.logger.error('Error revoking token', err);
                this.eventsSubject.next(new OAuthErrorEvent('token_revoke_error', err));
                reject(err);
            });
        });
    }
    /**
     * Clear location.hash if it's present
     */
    clearLocationHash() {
        // Checking for empty hash is necessary for Firefox
        // as setting an empty hash to an empty string adds # to the URL
        if (location.hash != '') {
            location.hash = '';
        }
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: OAuthService, deps: [{ token: i0.NgZone }, { token: i1.HttpClient }, { token: i2.OAuthStorage, optional: true }, { token: i3.ValidationHandler, optional: true }, { token: i4.AuthConfig, optional: true }, { token: i5.UrlHelperService }, { token: i2.OAuthLogger }, { token: i6.HashHandler, optional: true }, { token: DOCUMENT }, { token: i7.DateTimeProvider }], target: i0.ɵɵFactoryTarget.Injectable }); }
    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: OAuthService }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: OAuthService, decorators: [{
            type: Injectable
        }], ctorParameters: () => [{ type: i0.NgZone }, { type: i1.HttpClient }, { type: i2.OAuthStorage, decorators: [{
                    type: Optional
                }] }, { type: i3.ValidationHandler, decorators: [{
                    type: Optional
                }] }, { type: i4.AuthConfig, decorators: [{
                    type: Optional
                }] }, { type: i5.UrlHelperService }, { type: i2.OAuthLogger }, { type: i6.HashHandler, decorators: [{
                    type: Optional
                }] }, { type: Document, decorators: [{
                    type: Inject,
                    args: [DOCUMENT]
                }] }, { type: i7.DateTimeProvider }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"oauth-service.js","sourceRoot":"","sources":["../../../projects/lib/src/oauth-service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone, Optional, OnDestroy, Inject } from '@angular/core';\nimport {\n  HttpClient,\n  HttpHeaders,\n  HttpParams,\n  HttpErrorResponse,\n} from '@angular/common/http';\nimport {\n  Observable,\n  Subject,\n  Subscription,\n  of,\n  race,\n  from,\n  combineLatest,\n  throwError,\n} from 'rxjs';\nimport {\n  filter,\n  delay,\n  first,\n  tap,\n  map,\n  switchMap,\n  debounceTime,\n  catchError,\n} from 'rxjs/operators';\nimport { DOCUMENT } from '@angular/common';\nimport { DateTimeProvider } from './date-time-provider';\n\nimport {\n  ValidationHandler,\n  ValidationParams,\n} from './token-validation/validation-handler';\nimport { UrlHelperService } from './url-helper.service';\nimport {\n  OAuthEvent,\n  OAuthInfoEvent,\n  OAuthErrorEvent,\n  OAuthSuccessEvent,\n} from './events';\nimport {\n  OAuthLogger,\n  OAuthStorage,\n  LoginOptions,\n  ParsedIdToken,\n  OidcDiscoveryDoc,\n  TokenResponse,\n} from './types';\nimport { b64DecodeUnicode, base64UrlEncode } from './base64-helper';\nimport { AuthConfig } from './auth.config';\nimport { WebHttpUrlEncodingCodec } from './encoder';\nimport { HashHandler } from './token-validation/hash-handler';\n\n/**\n * Service for logging in and logging out with\n * OIDC and OAuth2. Supports implicit flow and\n * password flow.\n */\n@Injectable()\nexport class OAuthService extends AuthConfig implements OnDestroy {\n  // Extending AuthConfig ist just for LEGACY reasons\n  // to not break existing code.\n\n  /**\n   * The ValidationHandler used to validate received\n   * id_tokens.\n   */\n  public tokenValidationHandler: ValidationHandler;\n\n  /**\n   * @internal\n   * Deprecated:  use property events instead\n   */\n  public discoveryDocumentLoaded = false;\n\n  /**\n   * @internal\n   * Deprecated:  use property events instead\n   */\n  public discoveryDocumentLoaded$: Observable<OidcDiscoveryDoc>;\n\n  /**\n   * Informs about events, like token_received or token_expires.\n   * See the string enum EventType for a full list of event types.\n   */\n  public events: Observable<OAuthEvent>;\n\n  /**\n   * The received (passed around) state, when logging\n   * in with implicit flow.\n   */\n  public state? = '';\n\n  protected eventsSubject: Subject<OAuthEvent> = new Subject<OAuthEvent>();\n  protected discoveryDocumentLoadedSubject: Subject<OidcDiscoveryDoc> =\n    new Subject<OidcDiscoveryDoc>();\n  protected silentRefreshPostMessageEventListener: EventListener;\n  protected grantTypesSupported: Array<string> = [];\n  protected _storage: OAuthStorage;\n  protected accessTokenTimeoutSubscription: Subscription;\n  protected idTokenTimeoutSubscription: Subscription;\n  protected tokenReceivedSubscription: Subscription;\n  protected automaticRefreshSubscription: Subscription;\n  protected sessionCheckEventListener: EventListener;\n  protected jwksUri: string;\n  protected sessionCheckTimer: any;\n  protected silentRefreshSubject: string;\n  protected inImplicitFlow = false;\n\n  protected saveNoncesInLocalStorage = false;\n  private document: Document;\n\n  constructor(\n    protected ngZone: NgZone,\n    protected http: HttpClient,\n    @Optional() storage: OAuthStorage,\n    @Optional() tokenValidationHandler: ValidationHandler,\n    @Optional() protected config: AuthConfig,\n    protected urlHelper: UrlHelperService,\n    protected logger: OAuthLogger,\n    @Optional() protected crypto: HashHandler,\n    @Inject(DOCUMENT) document: Document,\n    protected dateTimeService: DateTimeProvider\n  ) {\n    super();\n\n    this.debug('angular-oauth2-oidc v10');\n\n    // See https://github.com/manfredsteyer/angular-oauth2-oidc/issues/773 for why this is needed\n    this.document = document;\n\n    if (!config) {\n      config = {};\n    }\n\n    this.discoveryDocumentLoaded$ =\n      this.discoveryDocumentLoadedSubject.asObservable();\n    this.events = this.eventsSubject.asObservable();\n\n    if (tokenValidationHandler) {\n      this.tokenValidationHandler = tokenValidationHandler;\n    }\n\n    if (config) {\n      this.configure(config);\n    }\n\n    try {\n      if (storage) {\n        this.setStorage(storage);\n      } else if (typeof sessionStorage !== 'undefined') {\n        this.setStorage(sessionStorage);\n      }\n    } catch (e) {\n      console.error(\n        'No OAuthStorage provided and cannot access default (sessionStorage).' +\n          'Consider providing a custom OAuthStorage implementation in your module.',\n        e\n      );\n    }\n\n    // in IE, sessionStorage does not always survive a redirect\n    if (this.checkLocalStorageAccessable()) {\n      const ua = window?.navigator?.userAgent;\n      const msie = ua?.includes('MSIE ') || ua?.includes('Trident');\n\n      if (msie) {\n        this.saveNoncesInLocalStorage = true;\n      }\n    }\n\n    this.setupRefreshTimer();\n  }\n\n  private checkLocalStorageAccessable() {\n    if (typeof window === 'undefined') return false;\n\n    const test = 'test';\n    try {\n      if (typeof window['localStorage'] === 'undefined') return false;\n\n      localStorage.setItem(test, test);\n      localStorage.removeItem(test);\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /**\n   * Use this method to configure the service\n   * @param config the configuration\n   */\n  public configure(config: AuthConfig): void {\n    // For the sake of downward compatibility with\n    // original configuration API\n    Object.assign(this, new AuthConfig(), config);\n\n    this.config = Object.assign({} as AuthConfig, new AuthConfig(), config);\n\n    if (this.sessionChecksEnabled) {\n      this.setupSessionCheck();\n    }\n\n    this.configChanged();\n  }\n\n  protected configChanged(): void {\n    this.setupRefreshTimer();\n  }\n\n  public restartSessionChecksIfStillLoggedIn(): void {\n    if (this.hasValidIdToken()) {\n      this.initSessionCheck();\n    }\n  }\n\n  protected restartRefreshTimerIfStillLoggedIn(): void {\n    this.setupExpirationTimers();\n  }\n\n  protected setupSessionCheck(): void {\n    this.events\n      .pipe(filter((e) => e.type === 'token_received'))\n      .subscribe(() => {\n        this.initSessionCheck();\n      });\n  }\n\n  /**\n   * Will setup up silent refreshing for when the token is\n   * about to expire. When the user is logged out via this.logOut method, the\n   * silent refreshing will pause and not refresh the tokens until the user is\n   * logged back in via receiving a new token.\n   * @param params Additional parameter to pass\n   * @param listenTo Setup automatic refresh of a specific token type\n   */\n  public setupAutomaticSilentRefresh(\n    params: object = {},\n    listenTo?: 'access_token' | 'id_token' | 'any',\n    noPrompt = true\n  ): void {\n    let shouldRunSilentRefresh = true;\n    this.clearAutomaticRefreshTimer();\n    this.automaticRefreshSubscription = this.events\n      .pipe(\n        tap((e) => {\n          if (e.type === 'token_received') {\n            shouldRunSilentRefresh = true;\n          } else if (e.type === 'logout') {\n            shouldRunSilentRefresh = false;\n          }\n        }),\n        filter(\n          (e: OAuthInfoEvent) =>\n            e.type === 'token_expires' &&\n            (listenTo == null || listenTo === 'any' || e.info === listenTo)\n        ),\n        debounceTime(1000)\n      )\n      .subscribe(() => {\n        if (shouldRunSilentRefresh) {\n          // this.silentRefresh(params, noPrompt).catch(_ => {\n          this.refreshInternal(params, noPrompt).catch(() => {\n            this.debug('Automatic silent refresh did not work');\n          });\n        }\n      });\n\n    this.restartRefreshTimerIfStillLoggedIn();\n  }\n\n  protected refreshInternal(\n    params,\n    noPrompt\n  ): Promise<TokenResponse | OAuthEvent> {\n    if (!this.useSilentRefresh && this.responseType === 'code') {\n      return this.refreshToken();\n    } else {\n      return this.silentRefresh(params, noPrompt);\n    }\n  }\n\n  /**\n   * Convenience method that first calls `loadDiscoveryDocument(...)` and\n   * directly chains using the `then(...)` part of the promise to call\n   * the `tryLogin(...)` method.\n   *\n   * @param options LoginOptions to pass through to `tryLogin(...)`\n   */\n  public loadDiscoveryDocumentAndTryLogin(\n    options: LoginOptions = null\n  ): Promise<boolean> {\n    return this.loadDiscoveryDocument().then(() => {\n      return this.tryLogin(options);\n    });\n  }\n\n  /**\n   * Convenience method that first calls `loadDiscoveryDocumentAndTryLogin(...)`\n   * and if then chains to `initLoginFlow()`, but only if there is no valid\n   * IdToken or no valid AccessToken.\n   *\n   * @param options LoginOptions to pass through to `tryLogin(...)`\n   */\n  public loadDiscoveryDocumentAndLogin(\n    options: LoginOptions & { state?: string } = null\n  ): Promise<boolean> {\n    options = options || {};\n    return this.loadDiscoveryDocumentAndTryLogin(options).then(() => {\n      if (!this.hasValidIdToken() || !this.hasValidAccessToken()) {\n        const state = typeof options.state === 'string' ? options.state : '';\n        this.initLoginFlow(state);\n        return false;\n      } else {\n        return true;\n      }\n    });\n  }\n\n  protected debug(...args): void {\n    if (this.showDebugInformation) {\n      this.logger.debug(...args);\n    }\n  }\n\n  protected validateUrlFromDiscoveryDocument(url: string): string[] {\n    const errors: string[] = [];\n    const httpsCheck = this.validateUrlForHttps(url);\n    const issuerCheck = this.validateUrlAgainstIssuer(url);\n\n    if (!httpsCheck) {\n      errors.push(\n        'https for all urls required. Also for urls received by discovery.'\n      );\n    }\n\n    if (!issuerCheck) {\n      errors.push(\n        'Every url in discovery document has to start with the issuer url.' +\n          'Also see property strictDiscoveryDocumentValidation.'\n      );\n    }\n\n    return errors;\n  }\n\n  protected validateUrlForHttps(url: string): boolean {\n    if (!url) {\n      return true;\n    }\n\n    const lcUrl = url.toLowerCase();\n\n    if (this.requireHttps === false) {\n      return true;\n    }\n\n    if (\n      (lcUrl.match(/^http:\\/\\/localhost($|[:/])/) ||\n        lcUrl.match(/^http:\\/\\/localhost($|[:/])/)) &&\n      this.requireHttps === 'remoteOnly'\n    ) {\n      return true;\n    }\n\n    return lcUrl.startsWith('https://');\n  }\n\n  protected assertUrlNotNullAndCorrectProtocol(\n    url: string | undefined,\n    description: string\n  ) {\n    if (!url) {\n      throw new Error(`'${description}' should not be null`);\n    }\n    if (!this.validateUrlForHttps(url)) {\n      throw new Error(\n        `'${description}' must use HTTPS (with TLS), or config value for property 'requireHttps' must be set to 'false' and allow HTTP (without TLS).`\n      );\n    }\n  }\n\n  protected validateUrlAgainstIssuer(url: string) {\n    if (!this.strictDiscoveryDocumentValidation) {\n      return true;\n    }\n    if (!url) {\n      return true;\n    }\n    return url.toLowerCase().startsWith(this.issuer.toLowerCase());\n  }\n\n  protected setupRefreshTimer(): void {\n    if (typeof window === 'undefined') {\n      this.debug('timer not supported on this plattform');\n      return;\n    }\n\n    if (this.hasValidIdToken() || this.hasValidAccessToken()) {\n      this.clearAccessTokenTimer();\n      this.clearIdTokenTimer();\n      this.setupExpirationTimers();\n    }\n\n    if (this.tokenReceivedSubscription)\n      this.tokenReceivedSubscription.unsubscribe();\n\n    this.tokenReceivedSubscription = this.events\n      .pipe(filter((e) => e.type === 'token_received'))\n      .subscribe(() => {\n        this.clearAccessTokenTimer();\n        this.clearIdTokenTimer();\n        this.setupExpirationTimers();\n      });\n  }\n\n  protected setupExpirationTimers(): void {\n    if (this.hasValidAccessToken()) {\n      this.setupAccessTokenTimer();\n    }\n\n    if (!this.disableIdTokenTimer && this.hasValidIdToken()) {\n      this.setupIdTokenTimer();\n    }\n  }\n\n  protected setupAccessTokenTimer(): void {\n    const expiration = this.getAccessTokenExpiration();\n    const storedAt = this.getAccessTokenStoredAt();\n    const timeout = this.calcTimeout(storedAt, expiration);\n\n    this.ngZone.runOutsideAngular(() => {\n      this.accessTokenTimeoutSubscription = of(\n        new OAuthInfoEvent('token_expires', 'access_token')\n      )\n        .pipe(delay(timeout))\n        .subscribe((e) => {\n          this.ngZone.run(() => {\n            this.eventsSubject.next(e);\n          });\n        });\n    });\n  }\n\n  protected setupIdTokenTimer(): void {\n    const expiration = this.getIdTokenExpiration();\n    const storedAt = this.getIdTokenStoredAt();\n    const timeout = this.calcTimeout(storedAt, expiration);\n\n    this.ngZone.runOutsideAngular(() => {\n      this.idTokenTimeoutSubscription = of(\n        new OAuthInfoEvent('token_expires', 'id_token')\n      )\n        .pipe(delay(timeout))\n        .subscribe((e) => {\n          this.ngZone.run(() => {\n            this.eventsSubject.next(e);\n          });\n        });\n    });\n  }\n\n  /**\n   * Stops timers for automatic refresh.\n   * To restart it, call setupAutomaticSilentRefresh again.\n   */\n  public stopAutomaticRefresh() {\n    this.clearAccessTokenTimer();\n    this.clearIdTokenTimer();\n    this.clearAutomaticRefreshTimer();\n  }\n\n  protected clearAccessTokenTimer(): void {\n    if (this.accessTokenTimeoutSubscription) {\n      this.accessTokenTimeoutSubscription.unsubscribe();\n    }\n  }\n\n  protected clearIdTokenTimer(): void {\n    if (this.idTokenTimeoutSubscription) {\n      this.idTokenTimeoutSubscription.unsubscribe();\n    }\n  }\n\n  protected clearAutomaticRefreshTimer(): void {\n    if (this.automaticRefreshSubscription) {\n      this.automaticRefreshSubscription.unsubscribe();\n    }\n  }\n\n  protected calcTimeout(storedAt: number, expiration: number): number {\n    const now = this.dateTimeService.now();\n    const delta =\n      (expiration - storedAt) * this.timeoutFactor - (now - storedAt);\n    const duration = Math.max(0, delta);\n    const maxTimeoutValue = 2_147_483_647;\n    return duration > maxTimeoutValue ? maxTimeoutValue : duration;\n  }\n\n  /**\n   * DEPRECATED. Use a provider for OAuthStorage instead:\n   *\n   * { provide: OAuthStorage, useFactory: oAuthStorageFactory }\n   * export function oAuthStorageFactory(): OAuthStorage { return localStorage; }\n   * Sets a custom storage used to store the received\n   * tokens on client side. By default, the browser's\n   * sessionStorage is used.\n   * @ignore\n   *\n   * @param storage\n   */\n  public setStorage(storage: OAuthStorage): void {\n    this._storage = storage;\n    this.configChanged();\n  }\n\n  /**\n   * Loads the discovery document to configure most\n   * properties of this service. The url of the discovery\n   * document is infered from the issuer's url according\n   * to the OpenId Connect spec. To use another url you\n   * can pass it to to optional parameter fullUrl.\n   *\n   * @param fullUrl\n   */\n  public loadDiscoveryDocument(\n    fullUrl: string = null\n  ): Promise<OAuthSuccessEvent> {\n    return new Promise((resolve, reject) => {\n      if (!fullUrl) {\n        fullUrl = this.issuer || '';\n        if (!fullUrl.endsWith('/')) {\n          fullUrl += '/';\n        }\n        fullUrl += '.well-known/openid-configuration';\n      }\n\n      if (!this.validateUrlForHttps(fullUrl)) {\n        reject(\n          \"issuer  must use HTTPS (with TLS), or config value for property 'requireHttps' must be set to 'false' and allow HTTP (without TLS).\"\n        );\n        return;\n      }\n\n      this.http.get<OidcDiscoveryDoc>(fullUrl).subscribe(\n        (doc) => {\n          if (!this.validateDiscoveryDocument(doc)) {\n            this.eventsSubject.next(\n              new OAuthErrorEvent('discovery_document_validation_error', null)\n            );\n            reject('discovery_document_validation_error');\n            return;\n          }\n\n          this.loginUrl = doc.authorization_endpoint;\n          this.logoutUrl = doc.end_session_endpoint || this.logoutUrl;\n          this.grantTypesSupported = doc.grant_types_supported;\n          this.issuer = doc.issuer;\n          this.tokenEndpoint = doc.token_endpoint;\n          this.userinfoEndpoint =\n            doc.userinfo_endpoint || this.userinfoEndpoint;\n          this.jwksUri = doc.jwks_uri;\n          this.sessionCheckIFrameUrl =\n            doc.check_session_iframe || this.sessionCheckIFrameUrl;\n\n          this.discoveryDocumentLoaded = true;\n          this.discoveryDocumentLoadedSubject.next(doc);\n          this.revocationEndpoint =\n            doc.revocation_endpoint || this.revocationEndpoint;\n\n          if (this.sessionChecksEnabled) {\n            this.restartSessionChecksIfStillLoggedIn();\n          }\n\n          this.loadJwks()\n            .then((jwks) => {\n              const result: object = {\n                discoveryDocument: doc,\n                jwks: jwks,\n              };\n\n              const event = new OAuthSuccessEvent(\n                'discovery_document_loaded',\n                result\n              );\n              this.eventsSubject.next(event);\n              resolve(event);\n              return;\n            })\n            .catch((err) => {\n              this.eventsSubject.next(\n                new OAuthErrorEvent('discovery_document_load_error', err)\n              );\n              reject(err);\n              return;\n            });\n        },\n        (err) => {\n          this.logger.error('error loading discovery document', err);\n          this.eventsSubject.next(\n            new OAuthErrorEvent('discovery_document_load_error', err)\n          );\n          reject(err);\n        }\n      );\n    });\n  }\n\n  protected loadJwks(): Promise<object> {\n    return new Promise<object>((resolve, reject) => {\n      if (this.jwksUri) {\n        this.http.get(this.jwksUri).subscribe(\n          (jwks) => {\n            this.jwks = jwks;\n            // this.eventsSubject.next(\n            //   new OAuthSuccessEvent('discovery_document_loaded')\n            // );\n            resolve(jwks);\n          },\n          (err) => {\n            this.logger.error('error loading jwks', err);\n            this.eventsSubject.next(\n              new OAuthErrorEvent('jwks_load_error', err)\n            );\n            reject(err);\n          }\n        );\n      } else {\n        resolve(null);\n      }\n    });\n  }\n\n  protected validateDiscoveryDocument(doc: OidcDiscoveryDoc): boolean {\n    let errors: string[];\n\n    if (!this.skipIssuerCheck && doc.issuer !== this.issuer) {\n      this.logger.error(\n        'invalid issuer in discovery document',\n        'expected: ' + this.issuer,\n        'current: ' + doc.issuer\n      );\n      return false;\n    }\n\n    errors = this.validateUrlFromDiscoveryDocument(doc.authorization_endpoint);\n    if (errors.length > 0) {\n      this.logger.error(\n        'error validating authorization_endpoint in discovery document',\n        errors\n      );\n      return false;\n    }\n\n    errors = this.validateUrlFromDiscoveryDocument(doc.end_session_endpoint);\n    if (errors.length > 0) {\n      this.logger.error(\n        'error validating end_session_endpoint in discovery document',\n        errors\n      );\n      return false;\n    }\n\n    errors = this.validateUrlFromDiscoveryDocument(doc.token_endpoint);\n    if (errors.length > 0) {\n      this.logger.error(\n        'error validating token_endpoint in discovery document',\n        errors\n      );\n    }\n\n    errors = this.validateUrlFromDiscoveryDocument(doc.revocation_endpoint);\n    if (errors.length > 0) {\n      this.logger.error(\n        'error validating revocation_endpoint in discovery document',\n        errors\n      );\n    }\n\n    errors = this.validateUrlFromDiscoveryDocument(doc.userinfo_endpoint);\n    if (errors.length > 0) {\n      this.logger.error(\n        'error validating userinfo_endpoint in discovery document',\n        errors\n      );\n      return false;\n    }\n\n    errors = this.validateUrlFromDiscoveryDocument(doc.jwks_uri);\n    if (errors.length > 0) {\n      this.logger.error(\n        'error validating jwks_uri in discovery document',\n        errors\n      );\n      return false;\n    }\n\n    if (this.sessionChecksEnabled && !doc.check_session_iframe) {\n      this.logger.warn(\n        'sessionChecksEnabled is activated but discovery document' +\n          ' does not contain a check_session_iframe field'\n      );\n    }\n\n    return true;\n  }\n\n  /**\n   * Uses password flow to exchange userName and password for an\n   * access_token. After receiving the access_token, this method\n   * uses it to query the userinfo endpoint in order to get information\n   * about the user in question.\n   *\n   * When using this, make sure that the property oidc is set to false.\n   * Otherwise stricter validations take place that make this operation\n   * fail.\n   *\n   * @param userName\n   * @param password\n   * @param headers Optional additional http-headers.\n   */\n  public fetchTokenUsingPasswordFlowAndLoadUserProfile(\n    userName: string,\n    password: string,\n    headers: HttpHeaders = new HttpHeaders()\n  ): Promise<object> {\n    return this.fetchTokenUsingPasswordFlow(userName, password, headers).then(\n      () => this.loadUserProfile()\n    );\n  }\n\n  /**\n   * Loads the user profile by accessing the user info endpoint defined by OpenId Connect.\n   *\n   * When using this with OAuth2 password flow, make sure that the property oidc is set to false.\n   * Otherwise stricter validations take place that make this operation fail.\n   */\n  public loadUserProfile(): Promise<object> {\n    if (!this.hasValidAccessToken()) {\n      throw new Error('Can not load User Profile without access_token');\n    }\n    if (!this.validateUrlForHttps(this.userinfoEndpoint)) {\n      throw new Error(\n        \"userinfoEndpoint must use HTTPS (with TLS), or config value for property 'requireHttps' must be set to 'false' and allow HTTP (without TLS).\"\n      );\n    }\n\n    return new Promise((resolve, reject) => {\n      const headers = new HttpHeaders().set(\n        'Authorization',\n        'Bearer ' + this.getAccessToken()\n      );\n\n      this.http\n        .get(this.userinfoEndpoint, {\n          headers,\n          observe: 'response',\n          responseType: 'text',\n        })\n        .subscribe(\n          (response) => {\n            this.debug('userinfo received', JSON.stringify(response));\n            if (\n              response.headers\n                .get('content-type')\n                .startsWith('application/json')\n            ) {\n              let info = JSON.parse(response.body);\n              const existingClaims = this.getIdentityClaims() || {};\n\n              if (!this.skipSubjectCheck) {\n                if (\n                  this.oidc &&\n                  (!existingClaims['sub'] || info.sub !== existingClaims['sub'])\n                ) {\n                  const err =\n                    'if property oidc is true, the received user-id (sub) has to be the user-id ' +\n                    'of the user that has logged in with oidc.\\n' +\n                    'if you are not using oidc but just oauth2 password flow set oidc to false';\n\n                  reject(err);\n                  return;\n                }\n              }\n\n              info = Object.assign({}, existingClaims, info);\n\n              this._storage.setItem(\n                'id_token_claims_obj',\n                JSON.stringify(info)\n              );\n              this.eventsSubject.next(\n                new OAuthSuccessEvent('user_profile_loaded')\n              );\n              resolve({ info });\n            } else {\n              this.debug('userinfo is not JSON, treating it as JWE/JWS');\n              this.eventsSubject.next(\n                new OAuthSuccessEvent('user_profile_loaded')\n              );\n              resolve(JSON.parse(response.body));\n            }\n          },\n          (err) => {\n            this.logger.error('error loading user info', err);\n            this.eventsSubject.next(\n              new OAuthErrorEvent('user_profile_load_error', err)\n            );\n            reject(err);\n          }\n        );\n    });\n  }\n\n  /**\n   * Uses password flow to exchange userName and password for an access_token.\n   * @param userName\n   * @param password\n   * @param headers Optional additional http-headers.\n   */\n  public fetchTokenUsingPasswordFlow(\n    userName: string,\n    password: string,\n    headers: HttpHeaders = new HttpHeaders()\n  ): Promise<TokenResponse> {\n    const parameters = {\n      username: userName,\n      password: password,\n    };\n    return this.fetchTokenUsingGrant('password', parameters, headers);\n  }\n\n  /**\n   * Uses a custom grant type to retrieve tokens.\n   * @param grantType Grant type.\n   * @param parameters Parameters to pass.\n   * @param headers Optional additional HTTP headers.\n   */\n  public fetchTokenUsingGrant(\n    grantType: string,\n    parameters: object,\n    headers: HttpHeaders = new HttpHeaders()\n  ): Promise<TokenResponse> {\n    this.assertUrlNotNullAndCorrectProtocol(\n      this.tokenEndpoint,\n      'tokenEndpoint'\n    );\n\n    /**\n     * A `HttpParameterCodec` that uses `encodeURIComponent` and `decodeURIComponent` to\n     * serialize and parse URL parameter keys and values.\n     *\n     * @stable\n     */\n    let params = new HttpParams({ encoder: new WebHttpUrlEncodingCodec() })\n      .set('grant_type', grantType)\n      .set('scope', this.scope);\n\n    if (this.useHttpBasicAuth) {\n      const header = btoa(`${this.clientId}:${this.dummyClientSecret}`);\n      headers = headers.set('Authorization', 'Basic ' + header);\n    }\n\n    if (!this.useHttpBasicAuth) {\n      params = params.set('client_id', this.clientId);\n    }\n\n    if (!this.useHttpBasicAuth && this.dummyClientSecret) {\n      params = params.set('client_secret', this.dummyClientSecret);\n    }\n\n    if (this.customQueryParams) {\n      for (const key of Object.getOwnPropertyNames(this.customQueryParams)) {\n        params = params.set(key, this.customQueryParams[key]);\n      }\n    }\n\n    // set explicit parameters last, to allow overwriting\n    for (const key of Object.keys(parameters)) {\n      params = params.set(key, parameters[key]);\n    }\n\n    headers = headers.set('Content-Type', 'application/x-www-form-urlencoded');\n\n    return new Promise((resolve, reject) => {\n      this.http\n        .post<TokenResponse>(this.tokenEndpoint, params, { headers })\n        .subscribe(\n          (tokenResponse) => {\n            this.debug('tokenResponse', tokenResponse);\n            this.storeAccessTokenResponse(\n              tokenResponse.access_token,\n              tokenResponse.refresh_token,\n              tokenResponse.expires_in ||\n                this.fallbackAccessTokenExpirationTimeInSec,\n              tokenResponse.scope,\n              this.extractRecognizedCustomParameters(tokenResponse)\n            );\n            if (this.oidc && tokenResponse.id_token) {\n              this.processIdToken(\n                tokenResponse.id_token,\n                tokenResponse.access_token\n              ).then((result) => {\n                this.storeIdToken(result);\n                resolve(tokenResponse);\n              });\n            }\n            this.eventsSubject.next(new OAuthSuccessEvent('token_received'));\n            resolve(tokenResponse);\n          },\n          (err) => {\n            this.logger.error('Error performing ${grantType} flow', err);\n            this.eventsSubject.next(new OAuthErrorEvent('token_error', err));\n            reject(err);\n          }\n        );\n    });\n  }\n\n  /**\n   * Refreshes the token using a refresh_token.\n   * This does not work for implicit flow, b/c\n   * there is no refresh_token in this flow.\n   * A solution for this is provided by the\n   * method silentRefresh.\n   */\n  public refreshToken(): Promise<TokenResponse> {\n    this.assertUrlNotNullAndCorrectProtocol(\n      this.tokenEndpoint,\n      'tokenEndpoint'\n    );\n    return new Promise((resolve, reject) => {\n      let params = new HttpParams({ encoder: new WebHttpUrlEncodingCodec() })\n        .set('grant_type', 'refresh_token')\n        .set('scope', this.scope)\n        .set('refresh_token', this._storage.getItem('refresh_token'));\n\n      let headers = new HttpHeaders().set(\n        'Content-Type',\n        'application/x-www-form-urlencoded'\n      );\n\n      if (this.useHttpBasicAuth) {\n        const header = btoa(`${this.clientId}:${this.dummyClientSecret}`);\n        headers = headers.set('Authorization', 'Basic ' + header);\n      }\n\n      if (!this.useHttpBasicAuth) {\n        params = params.set('client_id', this.clientId);\n      }\n\n      if (!this.useHttpBasicAuth && this.dummyClientSecret) {\n        params = params.set('client_secret', this.dummyClientSecret);\n      }\n\n      if (this.customQueryParams) {\n        for (const key of Object.getOwnPropertyNames(this.customQueryParams)) {\n          params = params.set(key, this.customQueryParams[key]);\n        }\n      }\n\n      this.http\n        .post<TokenResponse>(this.tokenEndpoint, params, { headers })\n        .pipe(\n          switchMap((tokenResponse) => {\n            if (this.oidc && tokenResponse.id_token) {\n              return from(\n                this.processIdToken(\n                  tokenResponse.id_token,\n                  tokenResponse.access_token,\n                  true\n                )\n              ).pipe(\n                tap((result) => this.storeIdToken(result)),\n                map(() => tokenResponse)\n              );\n            } else {\n              return of(tokenResponse);\n            }\n          })\n        )\n        .subscribe(\n          (tokenResponse) => {\n            this.debug('refresh tokenResponse', tokenResponse);\n            this.storeAccessTokenResponse(\n              tokenResponse.access_token,\n              tokenResponse.refresh_token,\n              tokenResponse.expires_in ||\n                this.fallbackAccessTokenExpirationTimeInSec,\n              tokenResponse.scope,\n              this.extractRecognizedCustomParameters(tokenResponse)\n            );\n\n            this.eventsSubject.next(new OAuthSuccessEvent('token_received'));\n            this.eventsSubject.next(new OAuthSuccessEvent('token_refreshed'));\n            resolve(tokenResponse);\n          },\n          (err) => {\n            this.logger.error('Error refreshing token', err);\n            this.eventsSubject.next(\n              new OAuthErrorEvent('token_refresh_error', err)\n            );\n            reject(err);\n          }\n        );\n    });\n  }\n\n  protected removeSilentRefreshEventListener(): void {\n    if (this.silentRefreshPostMessageEventListener) {\n      window.removeEventListener(\n        'message',\n        this.silentRefreshPostMessageEventListener\n      );\n      this.silentRefreshPostMessageEventListener = null;\n    }\n  }\n\n  protected setupSilentRefreshEventListener(): void {\n    this.removeSilentRefreshEventListener();\n\n    this.silentRefreshPostMessageEventListener = (e: MessageEvent) => {\n      const message = this.processMessageEventMessage(e);\n\n      if (this.checkOrigin && e.origin !== location.origin) {\n        console.error('wrong origin requested silent refresh!');\n      }\n\n      this.tryLogin({\n        customHashFragment: message,\n        preventClearHashAfterLogin: true,\n        customRedirectUri: this.silentRefreshRedirectUri || this.redirectUri,\n      }).catch((err) =>\n        this.debug('tryLogin during silent refresh failed', err)\n      );\n    };\n\n    window.addEventListener(\n      'message',\n      this.silentRefreshPostMessageEventListener\n    );\n  }\n\n  /**\n   * Performs a silent refresh for implicit flow.\n   * Use this method to get new tokens when/before\n   * the existing tokens expire.\n   */\n  public silentRefresh(\n    params: object = {},\n    noPrompt = true\n  ): Promise<OAuthEvent> {\n    const claims: object = this.getIdentityClaims() || {};\n\n    if (this.useIdTokenHintForSilentRefresh && this.hasValidIdToken()) {\n      params['id_token_hint'] = this.getIdToken();\n    }\n\n    if (!this.validateUrlForHttps(this.loginUrl)) {\n      throw new Error(\n        \"loginUrl  must use HTTPS (with TLS), or config value for property 'requireHttps' must be set to 'false' and allow HTTP (without TLS).\"\n      );\n    }\n\n    if (typeof this.document === 'undefined') {\n      throw new Error('silent refresh is not supported on this platform');\n    }\n\n    const existingIframe = this.document.getElementById(\n      this.silentRefreshIFrameName\n    );\n\n    if (existingIframe) {\n      this.document.body.removeChild(existingIframe);\n    }\n\n    this.silentRefreshSubject = claims['sub'];\n\n    const iframe = this.document.createElement('iframe');\n    iframe.id = this.silentRefreshIFrameName;\n\n    this.setupSilentRefreshEventListener();\n\n    const redirectUri = this.silentRefreshRedirectUri || this.redirectUri;\n    this.createLoginUrl(null, null, redirectUri, noPrompt, params).then(\n      (url) => {\n        iframe.setAttribute('src', url);\n\n        if (!this.silentRefreshShowIFrame) {\n          iframe.style['display'] = 'none';\n        }\n        this.document.body.appendChild(iframe);\n      }\n    );\n\n    const errors = this.events.pipe(\n      filter((e) => e instanceof OAuthErrorEvent),\n      first()\n    );\n    const success = this.events.pipe(\n      filter((e) => e.type === 'token_received'),\n      first()\n    );\n    const timeout = of(\n      new OAuthErrorEvent('silent_refresh_timeout', null)\n    ).pipe(delay(this.silentRefreshTimeout));\n\n    return race([errors, success, timeout])\n      .pipe(\n        map((e) => {\n          if (e instanceof OAuthErrorEvent) {\n            if (e.type === 'silent_refresh_timeout') {\n              this.eventsSubject.next(e);\n            } else {\n              e = new OAuthErrorEvent('silent_refresh_error', e);\n              this.eventsSubject.next(e);\n            }\n            throw e;\n          } else if (e.type === 'token_received') {\n            e = new OAuthSuccessEvent('silently_refreshed');\n            this.eventsSubject.next(e);\n          }\n          return e;\n        })\n      )\n      .toPromise();\n  }\n\n  /**\n   * This method exists for backwards compatibility.\n   * {@link OAuthService#initLoginFlowInPopup} handles both code\n   * and implicit flows.\n   */\n  public initImplicitFlowInPopup(options?: {\n    height?: number;\n    width?: number;\n    windowRef?: Window;\n  }) {\n    return this.initLoginFlowInPopup(options);\n  }\n\n  public initLoginFlowInPopup(options?: {\n    height?: number;\n    width?: number;\n    windowRef?: Window;\n  }) {\n    options = options || {};\n    return this.createLoginUrl(\n      null,\n      null,\n      this.silentRefreshRedirectUri,\n      false,\n      {\n        display: 'popup',\n      }\n    ).then((url) => {\n      return new Promise((resolve, reject) => {\n        /**\n         * Error handling section\n         */\n        const checkForPopupClosedInterval = 500;\n\n        let windowRef = null;\n        // If we got no window reference we open a window\n        // else we are using the window already opened\n        if (!options.windowRef) {\n          windowRef = window.open(\n            url,\n            'ngx-oauth2-oidc-login',\n            this.calculatePopupFeatures(options)\n          );\n        } else if (options.windowRef && !options.windowRef.closed) {\n          windowRef = options.windowRef;\n          windowRef.location.href = url;\n        }\n\n        let checkForPopupClosedTimer: any;\n\n        const tryLogin = (hash: string) => {\n          this.tryLogin({\n            customHashFragment: hash,\n            preventClearHashAfterLogin: true,\n            customRedirectUri: this.silentRefreshRedirectUri,\n          }).then(\n            () => {\n              cleanup();\n              resolve(true);\n            },\n            (err) => {\n              cleanup();\n              reject(err);\n            }\n          );\n        };\n\n        const checkForPopupClosed = () => {\n          if (!windowRef || windowRef.closed) {\n            cleanup();\n            reject(new OAuthErrorEvent('popup_closed', {}));\n          }\n        };\n        if (!windowRef) {\n          reject(new OAuthErrorEvent('popup_blocked', {}));\n        } else {\n          checkForPopupClosedTimer = window.setInterval(\n            checkForPopupClosed,\n            checkForPopupClosedInterval\n          );\n        }\n\n        const cleanup = () => {\n          window.clearInterval(checkForPopupClosedTimer);\n          window.removeEventListener('storage', storageListener);\n          window.removeEventListener('message', listener);\n          if (windowRef !== null) {\n            windowRef.close();\n          }\n          windowRef = null;\n        };\n\n        const listener = (e: MessageEvent) => {\n          const message = this.processMessageEventMessage(e);\n\n          if (message && message !== null) {\n            window.removeEventListener('storage', storageListener);\n            tryLogin(message);\n          } else {\n            console.log('false event firing');\n          }\n        };\n\n        const storageListener = (event: StorageEvent) => {\n          if (event.key === 'auth_hash') {\n            window.removeEventListener('message', listener);\n            tryLogin(event.newValue);\n          }\n        };\n\n        window.addEventListener('message', listener);\n        window.addEventListener('storage', storageListener);\n      });\n    });\n  }\n\n  protected calculatePopupFeatures(options: {\n    height?: number;\n    width?: number;\n  }): string {\n    // Specify an static height and width and calculate centered position\n\n    const height = options.height || 470;\n    const width = options.width || 500;\n    const left = window.screenLeft + (window.outerWidth - width) / 2;\n    const top = window.screenTop + (window.outerHeight - height) / 2;\n    return `location=no,toolbar=no,width=${width},height=${height},top=${top},left=${left}`;\n  }\n\n  protected processMessageEventMessage(e: MessageEvent): string {\n    let expectedPrefix = '#';\n\n    if (this.silentRefreshMessagePrefix) {\n      expectedPrefix += this.silentRefreshMessagePrefix;\n    }\n\n    if (!e || !e.data || typeof e.data !== 'string') {\n      return;\n    }\n\n    const prefixedMessage: string = e.data;\n\n    if (!prefixedMessage.startsWith(expectedPrefix)) {\n      return;\n    }\n\n    return '#' + prefixedMessage.substr(expectedPrefix.length);\n  }\n\n  protected canPerformSessionCheck(): boolean {\n    if (!this.sessionChecksEnabled) {\n      return false;\n    }\n    if (!this.sessionCheckIFrameUrl) {\n      console.warn(\n        'sessionChecksEnabled is activated but there is no sessionCheckIFrameUrl'\n      );\n      return false;\n    }\n    const sessionState = this.getSessionState();\n    if (!sessionState) {\n      console.warn(\n        'sessionChecksEnabled is activated but there is no session_state'\n      );\n      return false;\n    }\n    if (typeof this.document === 'undefined') {\n      return false;\n    }\n\n    return true;\n  }\n\n  protected setupSessionCheckEventListener(): void {\n    this.removeSessionCheckEventListener();\n\n    this.sessionCheckEventListener = (e: MessageEvent) => {\n      const origin = e.origin.toLowerCase();\n      const issuer = this.issuer.toLowerCase();\n\n      this.debug('sessionCheckEventListener');\n\n      if (!issuer.startsWith(origin)) {\n        this.debug(\n          'sessionCheckEventListener',\n          'wrong origin',\n          origin,\n          'expected',\n          issuer,\n          'event',\n          e\n        );\n\n        return;\n      }\n\n      // only run in Angular zone if it is 'changed' or 'error'\n      switch (e.data) {\n        case 'unchanged':\n          this.ngZone.run(() => {\n            this.handleSessionUnchanged();\n          });\n          break;\n        case 'changed':\n          this.ngZone.run(() => {\n            this.handleSessionChange();\n          });\n          break;\n        case 'error':\n          this.ngZone.run(() => {\n            this.handleSessionError();\n          });\n          break;\n      }\n\n      this.debug('got info from session check inframe', e);\n    };\n\n    // prevent Angular from refreshing the view on every message (runs in intervals)\n    this.ngZone.runOutsideAngular(() => {\n      window.addEventListener('message', this.sessionCheckEventListener);\n    });\n  }\n\n  protected handleSessionUnchanged(): void {\n    this.debug('session check', 'session unchanged');\n    this.eventsSubject.next(new OAuthInfoEvent('session_unchanged'));\n  }\n\n  protected handleSessionChange(): void {\n    this.eventsSubject.next(new OAuthInfoEvent('session_changed'));\n    this.stopSessionCheckTimer();\n\n    if (!this.useSilentRefresh && this.responseType === 'code') {\n      this.refreshToken()\n        .then(() => {\n          this.debug('token refresh after session change worked');\n        })\n        .catch(() => {\n          this.debug('token refresh did not work after session changed');\n          this.eventsSubject.next(new OAuthInfoEvent('session_terminated'));\n          this.logOut(true);\n        });\n    } else if (this.silentRefreshRedirectUri) {\n      this.silentRefresh().catch(() =>\n        this.debug('silent refresh failed after session changed')\n      );\n      this.waitForSilentRefreshAfterSessionChange();\n    } else {\n      this.eventsSubject.next(new OAuthInfoEvent('session_terminated'));\n      this.logOut(true);\n    }\n  }\n\n  protected waitForSilentRefreshAfterSessionChange(): void {\n    this.events\n      .pipe(\n        filter(\n          (e: OAuthEvent) =>\n            e.type === 'silently_refreshed' ||\n            e.type === 'silent_refresh_timeout' ||\n            e.type === 'silent_refresh_error'\n        ),\n        first()\n      )\n      .subscribe((e) => {\n        if (e.type !== 'silently_refreshed') {\n          this.debug('silent refresh did not work after session changed');\n          this.eventsSubject.next(new OAuthInfoEvent('session_terminated'));\n          this.logOut(true);\n        }\n      });\n  }\n\n  protected handleSessionError(): void {\n    this.stopSessionCheckTimer();\n    this.eventsSubject.next(new OAuthInfoEvent('session_error'));\n  }\n\n  protected removeSessionCheckEventListener(): void {\n    if (this.sessionCheckEventListener) {\n      window.removeEventListener('message', this.sessionCheckEventListener);\n      this.sessionCheckEventListener = null;\n    }\n  }\n\n  protected initSessionCheck(): void {\n    if (!this.canPerformSessionCheck()) {\n      return;\n    }\n\n    const existingIframe = this.document.getElementById(\n      this.sessionCheckIFrameName\n    );\n    if (existingIframe) {\n      this.document.body.removeChild(existingIframe);\n    }\n\n    const iframe = this.document.createElement('iframe');\n    iframe.id = this.sessionCheckIFrameName;\n\n    this.setupSessionCheckEventListener();\n\n    const url = this.sessionCheckIFrameUrl;\n    iframe.setAttribute('src', url);\n    iframe.style.display = 'none';\n    this.document.body.appendChild(iframe);\n\n    this.startSessionCheckTimer();\n  }\n\n  protected startSessionCheckTimer(): void {\n    this.stopSessionCheckTimer();\n    this.ngZone.runOutsideAngular(() => {\n      this.sessionCheckTimer = setInterval(\n        this.checkSession.bind(this),\n        this.sessionCheckIntervall\n      );\n    });\n  }\n\n  protected stopSessionCheckTimer(): void {\n    if (this.sessionCheckTimer) {\n      clearInterval(this.sessionCheckTimer);\n      this.sessionCheckTimer = null;\n    }\n  }\n\n  public checkSession(): void {\n    const iframe: any = this.document.getElementById(\n      this.sessionCheckIFrameName\n    );\n\n    if (!iframe) {\n      this.logger.warn(\n        'checkSession did not find iframe',\n        this.sessionCheckIFrameName\n      );\n    }\n\n    const sessionState = this.getSessionState();\n\n    if (!sessionState) {\n      this.stopSessionCheckTimer();\n    }\n\n    const message = this.clientId + ' ' + sessionState;\n    iframe.contentWindow.postMessage(message, this.issuer);\n  }\n\n  protected async createLoginUrl(\n    state = '',\n    loginHint = '',\n    customRedirectUri = '',\n    noPrompt = false,\n    params: object = {}\n  ): Promise<string> {\n    const that = this; // eslint-disable-line @typescript-eslint/no-this-alias\n\n    let redirectUri: string;\n\n    if (customRedirectUri) {\n      redirectUri = customRedirectUri;\n    } else {\n      redirectUri = this.redirectUri;\n    }\n\n    const nonce = await this.createAndSaveNonce();\n\n    if (state) {\n      state =\n        nonce + this.config.nonceStateSeparator + encodeURIComponent(state);\n    } else {\n      state = nonce;\n    }\n\n    if (!this.requestAccessToken && !this.oidc) {\n      throw new Error('Either requestAccessToken or oidc or both must be true');\n    }\n\n    if (this.config.responseType) {\n      this.responseType = this.config.responseType;\n    } else {\n      if (this.oidc && this.requestAccessToken) {\n        this.responseType = 'id_token token';\n      } else if (this.oidc && !this.requestAccessToken) {\n        this.responseType = 'id_token';\n      } else {\n        this.responseType = 'token';\n      }\n    }\n\n    const seperationChar = that.loginUrl.indexOf('?') > -1 ? '&' : '?';\n\n    let scope = that.scope;\n\n    if (this.oidc && !scope.match(/(^|\\s)openid($|\\s)/)) {\n      scope = 'openid ' + scope;\n    }\n\n    let url =\n      that.loginUrl +\n      seperationChar +\n      'response_type=' +\n      encodeURIComponent(that.responseType) +\n      '&client_id=' +\n      encodeURIComponent(that.clientId) +\n      '&state=' +\n      encodeURIComponent(state) +\n      '&redirect_uri=' +\n      encodeURIComponent(redirectUri) +\n      '&scope=' +\n      encodeURIComponent(scope);\n\n    if (this.responseType.includes('code') && !this.disablePKCE) {\n      const [challenge, verifier] =\n        await this.createChallangeVerifierPairForPKCE();\n\n      if (\n        this.saveNoncesInLocalStorage &&\n        typeof window['localStorage'] !== 'undefined'\n      ) {\n        localStorage.setItem('PKCE_verifier', verifier);\n      } else {\n        this._storage.setItem('PKCE_verifier', verifier);\n      }\n\n      url += '&code_challenge=' + challenge;\n      url += '&code_challenge_method=S256';\n    }\n\n    if (loginHint) {\n      url += '&login_hint=' + encodeURIComponent(loginHint);\n    }\n\n    if (that.resource) {\n      url += '&resource=' + encodeURIComponent(that.resource);\n    }\n\n    if (that.oidc) {\n      url += '&nonce=' + encodeURIComponent(nonce);\n    }\n\n    if (noPrompt) {\n      url += '&prompt=none';\n    }\n\n    for (const key of Object.keys(params)) {\n      url +=\n        '&' + encodeURIComponent(key) + '=' + encodeURIComponent(params[key]);\n    }\n\n    if (this.customQueryParams) {\n      for (const key of Object.getOwnPropertyNames(this.customQueryParams)) {\n        url +=\n          '&' + key + '=' + encodeURIComponent(this.customQueryParams[key]);\n      }\n    }\n\n    return url;\n  }\n\n  initImplicitFlowInternal(\n    additionalState = '',\n    params: string | object = ''\n  ): void {\n    if (this.inImplicitFlow) {\n      return;\n    }\n\n    this.inImplicitFlow = true;\n\n    if (!this.validateUrlForHttps(this.loginUrl)) {\n      throw new Error(\n        \"loginUrl  must use HTTPS (with TLS), or config value for property 'requireHttps' must be set to 'false' and allow HTTP (without TLS).\"\n      );\n    }\n\n    let addParams: object = {};\n    let loginHint: string = null;\n\n    if (typeof params === 'string') {\n      loginHint = params;\n    } else if (typeof params === 'object') {\n      addParams = params;\n    }\n\n    this.createLoginUrl(additionalState, loginHint, null, false, addParams)\n      .then(this.config.openUri)\n      .catch((error) => {\n        console.error('Error in initImplicitFlow', error);\n        this.inImplicitFlow = false;\n      });\n  }\n\n  /**\n   * Starts the implicit flow and redirects to user to\n   * the auth servers' login url.\n   *\n   * @param additionalState Optional state that is passed around.\n   *  You'll find this state in the property `state` after `tryLogin` logged in the user.\n   * @param params Hash with additional parameter. If it is a string, it is used for the\n   *               parameter loginHint (for the sake of compatibility with former versions)\n   */\n  public initImplicitFlow(\n    additionalState = '',\n    params: string | object = ''\n  ): void {\n    if (this.loginUrl !== '') {\n      this.initImplicitFlowInternal(additionalState, params);\n    } else {\n      this.events\n        .pipe(filter((e) => e.type === 'discovery_document_loaded'))\n        .subscribe(() =>\n          this.initImplicitFlowInternal(additionalState, params)\n        );\n    }\n  }\n\n  /**\n   * Reset current implicit flow\n   *\n   * @description This method allows resetting the current implict flow in order to be initialized again.\n   */\n  public resetImplicitFlow(): void {\n    this.inImplicitFlow = false;\n  }\n\n  protected callOnTokenReceivedIfExists(options: LoginOptions): void {\n    const that = this; // eslint-disable-line @typescript-eslint/no-this-alias\n    if (options.onTokenReceived) {\n      const tokenParams = {\n        idClaims: that.getIdentityClaims(),\n        idToken: that.getIdToken(),\n        accessToken: that.getAccessToken(),\n        state: that.state,\n      };\n      options.onTokenReceived(tokenParams);\n    }\n  }\n\n  protected storeAccessTokenResponse(\n    accessToken: string,\n    refreshToken: string,\n    expiresIn: number,\n    grantedScopes: string,\n    customParameters?: Map<string, string>\n  ): void {\n    this._storage.setItem('access_token', accessToken);\n    if (grantedScopes && !Array.isArray(grantedScopes)) {\n      this._storage.setItem(\n        'granted_scopes',\n        JSON.stringify(grantedScopes.split(' '))\n      );\n    } else if (grantedScopes && Array.isArray(grantedScopes)) {\n      this._storage.setItem('granted_scopes', JSON.stringify(grantedScopes));\n    }\n\n    this._storage.setItem(\n      'access_token_stored_at',\n      '' + this.dateTimeService.now()\n    );\n    if (expiresIn) {\n      const expiresInMilliSeconds = expiresIn * 1000;\n      const now = this.dateTimeService.new();\n      const expiresAt = now.getTime() + expiresInMilliSeconds;\n      this._storage.setItem('expires_at', '' + expiresAt);\n    }\n\n    if (refreshToken) {\n      this._storage.setItem('refresh_token', refreshToken);\n    }\n    if (customParameters) {\n      customParameters.forEach((value: string, key: string) => {\n        this._storage.setItem(key, value);\n      });\n    }\n  }\n\n  /**\n   * Delegates to tryLoginImplicitFlow for the sake of competability\n   * @param options Optional options.\n   */\n  public tryLogin(options: LoginOptions = null): Promise<boolean> {\n    if (this.config.responseType === 'code') {\n      return this.tryLoginCodeFlow(options).then(() => true);\n    } else {\n      return this.tryLoginImplicitFlow(options);\n    }\n  }\n\n  private parseQueryString(queryString: string): object {\n    if (!queryString || queryString.length === 0) {\n      return {};\n    }\n\n    if (queryString.charAt(0) === '?') {\n      queryString = queryString.substr(1);\n    }\n\n    return this.urlHelper.parseQueryString(queryString);\n  }\n\n  public async tryLoginCodeFlow(options: LoginOptions = null): Promise<void> {\n    options = options || {};\n\n    const querySource = options.customHashFragment\n      ? options.customHashFragment.substring(1)\n      : window.location.search;\n\n    const parts = this.getCodePartsFromUrl(querySource);\n\n    const code = parts['code'];\n    const state = parts['state'];\n\n    const sessionState = parts['session_state'];\n\n    if (!options.preventClearHashAfterLogin) {\n      const href =\n        location.origin +\n        location.pathname +\n        location.search\n          .replace(/code=[^&$]*/, '')\n          .replace(/scope=[^&$]*/, '')\n          .replace(/state=[^&$]*/, '')\n          .replace(/session_state=[^&$]*/, '')\n          .replace(/^\\?&/, '?')\n          .replace(/&$/, '')\n          .replace(/^\\?$/, '')\n          .replace(/&+/g, '&')\n          .replace(/\\?&/, '?')\n          .replace(/\\?$/, '') +\n        location.hash;\n\n      history.replaceState(null, window.name, href);\n    }\n\n    const [nonceInState, userState] = this.parseState(state);\n    this.state = userState;\n\n    if (parts['error']) {\n      this.debug('error trying to login');\n      this.handleLoginError(options, parts);\n      const err = new OAuthErrorEvent('code_error', {}, parts);\n      this.eventsSubject.next(err);\n      return Promise.reject(err);\n    }\n\n    if (!options.disableNonceCheck) {\n      if (!nonceInState) {\n        this.saveRequestedRoute();\n        return Promise.resolve();\n      }\n\n      if (!options.disableOAuth2StateCheck) {\n        const success = this.validateNonce(nonceInState);\n        if (!success) {\n          const event = new OAuthErrorEvent('invalid_nonce_in_state', null);\n          this.eventsSubject.next(event);\n          return Promise.reject(event);\n        }\n      }\n    }\n\n    this.storeSessionState(sessionState);\n\n    if (code) {\n      await this.getTokenFromCode(code, options);\n      this.restoreRequestedRoute();\n      return Promise.resolve();\n    } else {\n      return Promise.resolve();\n    }\n  }\n\n  private saveRequestedRoute() {\n    if (this.config.preserveRequestedRoute) {\n      this._storage.setItem(\n        'requested_route',\n        window.location.pathname + window.location.search\n      );\n    }\n  }\n\n  private restoreRequestedRoute() {\n    const requestedRoute = this._storage.getItem('requested_route');\n    if (requestedRoute) {\n      history.replaceState(null, '', window.location.origin + requestedRoute);\n    }\n  }\n\n  /**\n   * Retrieve the returned auth code from the redirect uri that has been called.\n   * If required also check hash, as we could use hash location strategy.\n   */\n  private getCodePartsFromUrl(queryString: string): object {\n    if (!queryString || queryString.length === 0) {\n      return this.urlHelper.getHashFragmentParams();\n    }\n\n    // normalize query string\n    if (queryString.charAt(0) === '?') {\n      queryString = queryString.substr(1);\n    }\n\n    return this.urlHelper.parseQueryString(queryString);\n  }\n\n  /**\n   * Get token using an intermediate code. Works for the Authorization Code flow.\n   */\n  private getTokenFromCode(\n    code: string,\n    options: LoginOptions\n  ): Promise<object> {\n    let params = new HttpParams({ encoder: new WebHttpUrlEncodingCodec() })\n      .set('grant_type', 'authorization_code')\n      .set('code', code)\n      .set('redirect_uri', options.customRedirectUri || this.redirectUri);\n\n    if (!this.disablePKCE) {\n      let PKCEVerifier;\n\n      if (\n        this.saveNoncesInLocalStorage &&\n        typeof window['localStorage'] !== 'undefined'\n      ) {\n        PKCEVerifier = localStorage.getItem('PKCE_verifier');\n      } else {\n        PKCEVerifier = this._storage.getItem('PKCE_verifier');\n      }\n\n      if (!PKCEVerifier) {\n        console.warn('No PKCE verifier found in oauth storage!');\n      } else {\n        params = params.set('code_verifier', PKCEVerifier);\n      }\n    }\n\n    return this.fetchAndProcessToken(params, options);\n  }\n\n  private fetchAndProcessToken(\n    params: HttpParams,\n    options: LoginOptions\n  ): Promise<TokenResponse> {\n    options = options || {};\n\n    this.assertUrlNotNullAndCorrectProtocol(\n      this.tokenEndpoint,\n      'tokenEndpoint'\n    );\n    let headers = new HttpHeaders().set(\n      'Content-Type',\n      'application/x-www-form-urlencoded'\n    );\n\n    if (this.useHttpBasicAuth) {\n      const header = btoa(`${this.clientId}:${this.dummyClientSecret}`);\n      headers = headers.set('Authorization', 'Basic ' + header);\n    }\n\n    if (!this.useHttpBasicAuth) {\n      params = params.set('client_id', this.clientId);\n    }\n\n    if (!this.useHttpBasicAuth && this.dummyClientSecret) {\n      params = params.set('client_secret', this.dummyClientSecret);\n    }\n\n    return new Promise((resolve, reject) => {\n      if (this.customQueryParams) {\n        for (const key of Object.getOwnPropertyNames(this.customQueryParams)) {\n          params = params.set(key, this.customQueryParams[key]);\n        }\n      }\n\n      this.http\n        .post<TokenResponse>(this.tokenEndpoint, params, { headers })\n        .subscribe(\n          (tokenResponse) => {\n            this.debug('refresh tokenResponse', tokenResponse);\n            this.storeAccessTokenResponse(\n              tokenResponse.access_token,\n              tokenResponse.refresh_token,\n              tokenResponse.expires_in ||\n                this.fallbackAccessTokenExpirationTimeInSec,\n              tokenResponse.scope,\n              this.extractRecognizedCustomParameters(tokenResponse)\n            );\n\n            if (this.oidc && tokenResponse.id_token) {\n              this.processIdToken(\n                tokenResponse.id_token,\n                tokenResponse.access_token,\n                options.disableNonceCheck\n              )\n                .then((result) => {\n                  this.storeIdToken(result);\n\n                  this.eventsSubject.next(\n                    new OAuthSuccessEvent('token_received')\n                  );\n                  this.eventsSubject.next(\n                    new OAuthSuccessEvent('token_refreshed')\n                  );\n\n                  resolve(tokenResponse);\n                })\n                .catch((reason) => {\n                  this.eventsSubject.next(\n                    new OAuthErrorEvent('token_validation_error', reason)\n                  );\n                  console.error('Error validating tokens');\n                  console.error(reason);\n\n                  reject(reason);\n                });\n            } else {\n              this.eventsSubject.next(new OAuthSuccessEvent('token_received'));\n              this.eventsSubject.next(new OAuthSuccessEvent('token_refreshed'));\n\n              resolve(tokenResponse);\n            }\n          },\n          (err) => {\n            console.error('Error getting token', err);\n            this.eventsSubject.next(\n              new OAuthErrorEvent('token_refresh_error', err)\n            );\n            reject(err);\n          }\n        );\n    });\n  }\n\n  /**\n   * Checks whether there are tokens in the hash fragment\n   * as a result of the implicit flow. These tokens are\n   * parsed, validated and used to sign the user in to the\n   * current client.\n   *\n   * @param options Optional options.\n   */\n  public tryLoginImplicitFlow(options: LoginOptions = null): Promise<boolean> {\n    options = options || {};\n\n    let parts: object;\n\n    if (options.customHashFragment) {\n      parts = this.urlHelper.getHashFragmentParams(options.customHashFragment);\n    } else {\n      parts = this.urlHelper.getHashFragmentParams();\n    }\n\n    this.debug('parsed url', parts);\n\n    const state = parts['state'];\n\n    const [nonceInState, userState] = this.parseState(state);\n    this.state = userState;\n\n    if (parts['error']) {\n      this.debug('error trying to login');\n      this.handleLoginError(options, parts);\n      const err = new OAuthErrorEvent('token_error', {}, parts);\n      this.eventsSubject.next(err);\n      return Promise.reject(err);\n    }\n\n    const accessToken = parts['access_token'];\n    const idToken = parts['id_token'];\n    const sessionState = parts['session_state'];\n    const grantedScopes = parts['scope'];\n\n    if (!this.requestAccessToken && !this.oidc) {\n      return Promise.reject(\n        'Either requestAccessToken or oidc (or both) must be true.'\n      );\n    }\n\n    if (this.requestAccessToken && !accessToken) {\n      return Promise.resolve(false);\n    }\n    if (this.requestAccessToken && !options.disableOAuth2StateCheck && !state) {\n      return Promise.resolve(false);\n    }\n    if (this.oidc && !idToken) {\n      return Promise.resolve(false);\n    }\n\n    if (this.sessionChecksEnabled && !sessionState) {\n      this.logger.warn(\n        'session checks (Session Status Change Notification) ' +\n          'were activated in the configuration but the id_token ' +\n          'does not contain a session_state claim'\n      );\n    }\n\n    if (this.requestAccessToken && !options.disableNonceCheck) {\n      const success = this.validateNonce(nonceInState);\n\n      if (!success) {\n        const event = new OAuthErrorEvent('invalid_nonce_in_state', null);\n        this.eventsSubject.next(event);\n        return Promise.reject(event);\n      }\n    }\n\n    if (this.requestAccessToken) {\n      this.storeAccessTokenResponse(\n        accessToken,\n        null,\n        parts['expires_in'] || this.fallbackAccessTokenExpirationTimeInSec,\n        grantedScopes\n      );\n    }\n\n    if (!this.oidc) {\n      this.eventsSubject.next(new OAuthSuccessEvent('token_received'));\n      if (this.clearHashAfterLogin && !options.preventClearHashAfterLogin) {\n        this.clearLocationHash();\n      }\n\n      this.callOnTokenReceivedIfExists(options);\n      return Promise.resolve(true);\n    }\n\n    return this.processIdToken(idToken, accessToken, options.disableNonceCheck)\n      .then((result) => {\n        if (options.validationHandler) {\n          return options\n            .validationHandler({\n              accessToken: accessToken,\n              idClaims: result.idTokenClaims,\n              idToken: result.idToken,\n              state: state,\n            })\n            .then(() => result);\n        }\n        return result;\n      })\n      .then((result) => {\n        this.storeIdToken(result);\n        this.storeSessionState(sessionState);\n        if (this.clearHashAfterLogin && !options.preventClearHashAfterLogin) {\n          this.clearLocationHash();\n        }\n        this.eventsSubject.next(new OAuthSuccessEvent('token_received'));\n        this.callOnTokenReceivedIfExists(options);\n        this.inImplicitFlow = false;\n        return true;\n      })\n      .catch((reason) => {\n        this.eventsSubject.next(\n          new OAuthErrorEvent('token_validation_error', reason)\n        );\n        this.logger.error('Error validating tokens');\n        this.logger.error(reason);\n        return Promise.reject(reason);\n      });\n  }\n\n  private parseState(state: string): [string, string] {\n    let nonce = state;\n    let userState = '';\n\n    if (state) {\n      const idx = state.indexOf(this.config.nonceStateSeparator);\n      if (idx > -1) {\n        nonce = state.substr(0, idx);\n        userState = state.substr(idx + this.config.nonceStateSeparator.length);\n      }\n    }\n    return [nonce, userState];\n  }\n\n  protected validateNonce(nonceInState: string): boolean {\n    let savedNonce;\n\n    if (\n      this.saveNoncesInLocalStorage &&\n      typeof window['localStorage'] !== 'undefined'\n    ) {\n      savedNonce = localStorage.getItem('nonce');\n    } else {\n      savedNonce = this._storage.getItem('nonce');\n    }\n\n    if (savedNonce !== nonceInState) {\n      const err = 'Validating access_token failed, wrong state/nonce.';\n      console.error(err, savedNonce, nonceInState);\n      return false;\n    }\n    return true;\n  }\n\n  protected storeIdToken(idToken: ParsedIdToken): void {\n    this._storage.setItem('id_token', idToken.idToken);\n    this._storage.setItem('id_token_claims_obj', idToken.idTokenClaimsJson);\n    this._storage.setItem('id_token_expires_at', '' + idToken.idTokenExpiresAt);\n    this._storage.setItem(\n      'id_token_stored_at',\n      '' + this.dateTimeService.now()\n    );\n  }\n\n  protected storeSessionState(sessionState: string): void {\n    this._storage.setItem('session_state', sessionState);\n  }\n\n  protected getSessionState(): string {\n    return this._storage.getItem('session_state');\n  }\n\n  protected handleLoginError(options: LoginOptions, parts: object): void {\n    if (options.onLoginError) {\n      options.onLoginError(parts);\n    }\n    if (this.clearHashAfterLogin && !options.preventClearHashAfterLogin) {\n      this.clearLocationHash();\n    }\n  }\n\n  private getClockSkewInMsec(defaultSkewMsc = 600_000) {\n    if (!this.clockSkewInSec && this.clockSkewInSec !== 0) {\n      return defaultSkewMsc;\n    }\n    return this.clockSkewInSec * 1000;\n  }\n\n  /**\n   * @ignore\n   */\n  public processIdToken(\n    idToken: string,\n    accessToken: string,\n    skipNonceCheck = false\n  ): Promise<ParsedIdToken> {\n    const tokenParts = idToken.split('.');\n    const headerBase64 = this.padBase64(tokenParts[0]);\n    const headerJson = b64DecodeUnicode(headerBase64);\n    const header = JSON.parse(headerJson);\n    const claimsBase64 = this.padBase64(tokenParts[1]);\n    const claimsJson = b64DecodeUnicode(claimsBase64);\n    const claims = JSON.parse(claimsJson);\n\n    let savedNonce;\n    if (\n      this.saveNoncesInLocalStorage &&\n      typeof window['localStorage'] !== 'undefined'\n    ) {\n      savedNonce = localStorage.getItem('nonce');\n    } else {\n      savedNonce = this._storage.getItem('nonce');\n    }\n\n    if (Array.isArray(claims.aud)) {\n      if (claims.aud.every((v) => v !== this.clientId)) {\n        const err = 'Wrong audience: ' + claims.aud.join(',');\n        this.logger.warn(err);\n        return Promise.reject(err);\n      }\n    } else {\n      if (claims.aud !== this.clientId) {\n        const err = 'Wrong audience: ' + claims.aud;\n        this.logger.warn(err);\n        return Promise.reject(err);\n      }\n    }\n\n    if (!claims.sub) {\n      const err = 'No sub claim in id_token';\n      this.logger.warn(err);\n      return Promise.reject(err);\n    }\n\n    /* For now, we only check whether the sub against\n     * silentRefreshSubject when sessionChecksEnabled is on\n     * We will reconsider in a later version to do this\n     * in every other case too.\n     */\n    if (\n      this.sessionChecksEnabled &&\n      this.silentRefreshSubject &&\n      this.silentRefreshSubject !== claims['sub']\n    ) {\n      const err =\n        'After refreshing, we got an id_token for another user (sub). ' +\n        `Expected sub: ${this.silentRefreshSubject}, received sub: ${claims['sub']}`;\n\n      this.logger.warn(err);\n      return Promise.reject(err);\n    }\n\n    if (!claims.iat) {\n      const err = 'No iat claim in id_token';\n      this.logger.warn(err);\n      return Promise.reject(err);\n    }\n\n    if (!this.skipIssuerCheck && claims.iss !== this.issuer) {\n      const err = 'Wrong issuer: ' + claims.iss;\n      this.logger.warn(err);\n      return Promise.reject(err);\n    }\n\n    if (!skipNonceCheck && claims.nonce !== savedNonce) {\n      const err = 'Wrong nonce: ' + claims.nonce;\n      this.logger.warn(err);\n      return Promise.reject(err);\n    }\n    // at_hash is not applicable to authorization code flow\n    // addressing https://github.com/manfredsteyer/angular-oauth2-oidc/issues/661\n    // i.e. Based on spec the at_hash check is only true for implicit code flow on Ping Federate\n    // https://www.pingidentity.com/developer/en/resources/openid-connect-developers-guide.html\n    if (\n      Object.prototype.hasOwnProperty.call(this, 'responseType') &&\n      (this.responseType === 'code' || this.responseType === 'id_token')\n    ) {\n      this.disableAtHashCheck = true;\n    }\n    if (\n      !this.disableAtHashCheck &&\n      this.requestAccessToken &&\n      !claims['at_hash']\n    ) {\n      const err = 'An at_hash is needed!';\n      this.logger.warn(err);\n      return Promise.reject(err);\n    }\n\n    const now = this.dateTimeService.now();\n    const issuedAtMSec = claims.iat * 1000;\n    const expiresAtMSec = claims.exp * 1000;\n    const clockSkewInMSec = this.getClockSkewInMsec(); // (this.getClockSkewInMsec() || 600) * 1000;\n\n    if (\n      issuedAtMSec - clockSkewInMSec >= now ||\n      expiresAtMSec + clockSkewInMSec - this.decreaseExpirationBySec <= now\n    ) {\n      const err = 'Token has expired';\n      console.error(err);\n      console.error({\n        now: now,\n        issuedAtMSec: issuedAtMSec,\n        expiresAtMSec: expiresAtMSec,\n      });\n      return Promise.reject(err);\n    }\n\n    const validationParams: ValidationParams = {\n      accessToken: accessToken,\n      idToken: idToken,\n      jwks: this.jwks,\n      idTokenClaims: claims,\n      idTokenHeader: header,\n      loadKeys: () => this.loadJwks(),\n    };\n\n    if (this.disableAtHashCheck) {\n      return this.checkSignature(validationParams).then(() => {\n        const result: ParsedIdToken = {\n          idToken: idToken,\n          idTokenClaims: claims,\n          idTokenClaimsJson: claimsJson,\n          idTokenHeader: header,\n          idTokenHeaderJson: headerJson,\n          idTokenExpiresAt: expiresAtMSec,\n        };\n        return result;\n      });\n    }\n\n    return this.checkAtHash(validationParams).then((atHashValid) => {\n      if (!this.disableAtHashCheck && this.requestAccessToken && !atHashValid) {\n        const err = 'Wrong at_hash';\n        this.logger.warn(err);\n        return Promise.reject(err);\n      }\n\n      return this.checkSignature(validationParams).then(() => {\n        const atHashCheckEnabled = !this.disableAtHashCheck;\n        const result: ParsedIdToken = {\n          idToken: idToken,\n          idTokenClaims: claims,\n          idTokenClaimsJson: claimsJson,\n          idTokenHeader: header,\n          idTokenHeaderJson: headerJson,\n          idTokenExpiresAt: expiresAtMSec,\n        };\n        if (atHashCheckEnabled) {\n          return this.checkAtHash(validationParams).then((atHashValid) => {\n            if (this.requestAccessToken && !atHashValid) {\n              const err = 'Wrong at_hash';\n              this.logger.warn(err);\n              return Promise.reject(err);\n            } else {\n              return result;\n            }\n          });\n        } else {\n          return result;\n        }\n      });\n    });\n  }\n\n  /**\n   * Returns the received claims about the user.\n   */\n  public getIdentityClaims(): Record<string, any> {\n    const claims = this._storage.getItem('id_token_claims_obj');\n    if (!claims) {\n      return null;\n    }\n    return JSON.parse(claims);\n  }\n\n  /**\n   * Returns the granted scopes from the server.\n   */\n  public getGrantedScopes(): object {\n    const scopes = this._storage.getItem('granted_scopes');\n    if (!scopes) {\n      return null;\n    }\n    return JSON.parse(scopes);\n  }\n\n  /**\n   * Returns the current id_token.\n   */\n  public getIdToken(): string {\n    return this._storage ? this._storage.getItem('id_token') : null;\n  }\n\n  protected padBase64(base64data): string {\n    while (base64data.length % 4 !== 0) {\n      base64data += '=';\n    }\n    return base64data;\n  }\n\n  /**\n   * Returns the current access_token.\n   */\n  public getAccessToken(): string {\n    return this._storage ? this._storage.getItem('access_token') : null;\n  }\n\n  public getRefreshToken(): string {\n    return this._storage ? this._storage.getItem('refresh_token') : null;\n  }\n\n  /**\n   * Returns the expiration date of the access_token\n   * as milliseconds since 1970.\n   */\n  public getAccessTokenExpiration(): number {\n    if (!this._storage.getItem('expires_at')) {\n      return null;\n    }\n    return parseInt(this._storage.getItem('expires_at'), 10);\n  }\n\n  protected getAccessTokenStoredAt(): number {\n    return parseInt(this._storage.getItem('access_token_stored_at'), 10);\n  }\n\n  protected getIdTokenStoredAt(): number {\n    return parseInt(this._storage.getItem('id_token_stored_at'), 10);\n  }\n\n  /**\n   * Returns the expiration date of the id_token\n   * as milliseconds since 1970.\n   */\n  public getIdTokenExpiration(): number {\n    if (!this._storage.getItem('id_token_expires_at')) {\n      return null;\n    }\n\n    return parseInt(this._storage.getItem('id_token_expires_at'), 10);\n  }\n\n  /**\n   * Checkes, whether there is a valid access_token.\n   */\n  public hasValidAccessToken(): boolean {\n    if (this.getAccessToken()) {\n      const expiresAt = this._storage.getItem('expires_at');\n      const now = this.dateTimeService.new();\n      if (\n        expiresAt &&\n        parseInt(expiresAt, 10) - this.decreaseExpirationBySec <\n          now.getTime() - this.getClockSkewInMsec()\n      ) {\n        return false;\n      }\n\n      return true;\n    }\n\n    return false;\n  }\n\n  /**\n   * Checks whether there is a valid id_token.\n   */\n  public hasValidIdToken(): boolean {\n    if (this.getIdToken()) {\n      const expiresAt = this._storage.getItem('id_token_expires_at');\n      const now = this.dateTimeService.new();\n      if (\n        expiresAt &&\n        parseInt(expiresAt, 10) - this.decreaseExpirationBySec <\n          now.getTime() - this.getClockSkewInMsec()\n      ) {\n        return false;\n      }\n\n      return true;\n    }\n\n    return false;\n  }\n\n  /**\n   * Retrieve a saved custom property of the TokenReponse object. Only if predefined in authconfig.\n   */\n  public getCustomTokenResponseProperty(requestedProperty: string): any {\n    return this._storage &&\n      this.config.customTokenParameters &&\n      this.config.customTokenParameters.indexOf(requestedProperty) >= 0 &&\n      this._storage.getItem(requestedProperty) !== null\n      ? JSON.parse(this._storage.getItem(requestedProperty))\n      : null;\n  }\n\n  /**\n   * Returns the auth-header that can be used\n   * to transmit the access_token to a service\n   */\n  public authorizationHeader(): string {\n    return 'Bearer ' + this.getAccessToken();\n  }\n\n  /**\n   * Removes all tokens and logs the user out.\n   * If a logout url is configured, the user is\n   * redirected to it with optional state parameter.\n   * @param noRedirectToLogoutUrl\n   * @param state\n   */\n  public logOut(): void;\n  public logOut(customParameters: boolean | object): void;\n  public logOut(noRedirectToLogoutUrl: boolean): void;\n  public logOut(noRedirectToLogoutUrl: boolean, state: string): void;\n  public logOut(customParameters: boolean | object = {}, state = ''): void {\n    let noRedirectToLogoutUrl = false;\n    if (typeof customParameters === 'boolean') {\n      noRedirectToLogoutUrl = customParameters;\n      customParameters = {};\n    }\n\n    const id_token = this.getIdToken();\n    this._storage.removeItem('access_token');\n    this._storage.removeItem('id_token');\n    this._storage.removeItem('refresh_token');\n\n    if (this.saveNoncesInLocalStorage) {\n      localStorage.removeItem('nonce');\n      localStorage.removeItem('PKCE_verifier');\n    } else {\n      this._storage.removeItem('nonce');\n      this._storage.removeItem('PKCE_verifier');\n    }\n\n    this._storage.removeItem('expires_at');\n    this._storage.removeItem('id_token_claims_obj');\n    this._storage.removeItem('id_token_expires_at');\n    this._storage.removeItem('id_token_stored_at');\n    this._storage.removeItem('access_token_stored_at');\n    this._storage.removeItem('granted_scopes');\n    this._storage.removeItem('session_state');\n    if (this.config.customTokenParameters) {\n      this.config.customTokenParameters.forEach((customParam) =>\n        this._storage.removeItem(customParam)\n      );\n    }\n    this.silentRefreshSubject = null;\n\n    this.eventsSubject.next(new OAuthInfoEvent('logout'));\n\n    if (!this.logoutUrl) {\n      return;\n    }\n    if (noRedirectToLogoutUrl) {\n      return;\n    }\n\n    // if (!id_token && !this.postLogoutRedirectUri) {\n    //   return;\n    // }\n\n    let logoutUrl: string;\n\n    if (!this.validateUrlForHttps(this.logoutUrl)) {\n      throw new Error(\n        \"logoutUrl  must use HTTPS (with TLS), or config value for property 'requireHttps' must be set to 'false' and allow HTTP (without TLS).\"\n      );\n    }\n\n    // For backward compatibility\n    if (this.logoutUrl.indexOf('{{') > -1) {\n      logoutUrl = this.logoutUrl\n        .replace(/\\{\\{id_token\\}\\}/, encodeURIComponent(id_token))\n        .replace(/\\{\\{client_id\\}\\}/, encodeURIComponent(this.clientId));\n    } else {\n      let params = new HttpParams({ encoder: new WebHttpUrlEncodingCodec() });\n\n      if (id_token) {\n        params = params.set('id_token_hint', id_token);\n      }\n\n      const postLogoutUrl =\n        this.postLogoutRedirectUri ||\n        (this.redirectUriAsPostLogoutRedirectUriFallback && this.redirectUri) ||\n        '';\n      if (postLogoutUrl) {\n        params = params.set('post_logout_redirect_uri', postLogoutUrl);\n\n        if (state) {\n          params = params.set('state', state);\n        }\n      }\n\n      for (const key in customParameters) {\n        params = params.set(key, customParameters[key]);\n      }\n\n      logoutUrl =\n        this.logoutUrl +\n        (this.logoutUrl.indexOf('?') > -1 ? '&' : '?') +\n        params.toString();\n    }\n    this.config.openUri(logoutUrl);\n  }\n\n  /**\n   * @ignore\n   */\n  public createAndSaveNonce(): Promise<string> {\n    const that = this; // eslint-disable-line @typescript-eslint/no-this-alias\n    return this.createNonce().then(function (nonce: any) {\n      // Use localStorage for nonce if possible\n      // localStorage is the only storage who survives a\n      // redirect in ALL browsers (also IE)\n      // Otherwiese we'd force teams who have to support\n      // IE into using localStorage for everything\n      if (\n        that.saveNoncesInLocalStorage &&\n        typeof window['localStorage'] !== 'undefined'\n      ) {\n        localStorage.setItem('nonce', nonce);\n      } else {\n        that._storage.setItem('nonce', nonce);\n      }\n      return nonce;\n    });\n  }\n\n  /**\n   * @ignore\n   */\n  public ngOnDestroy(): void {\n    this.clearAccessTokenTimer();\n    this.clearIdTokenTimer();\n\n    this.removeSilentRefreshEventListener();\n    const silentRefreshFrame = this.document.getElementById(\n      this.silentRefreshIFrameName\n    );\n    if (silentRefreshFrame) {\n      silentRefreshFrame.remove();\n    }\n\n    this.stopSessionCheckTimer();\n    this.removeSessionCheckEventListener();\n    const sessionCheckFrame = this.document.getElementById(\n      this.sessionCheckIFrameName\n    );\n    if (sessionCheckFrame) {\n      sessionCheckFrame.remove();\n    }\n  }\n\n  protected createNonce(): Promise<string> {\n    return new Promise((resolve) => {\n      if (this.rngUrl) {\n        throw new Error(\n          'createNonce with rng-web-api has not been implemented so far'\n        );\n      }\n\n      /*\n       * This alphabet is from:\n       * https://tools.ietf.org/html/rfc7636#section-4.1\n       *\n       * [A-Z] / [a-z] / [0-9] / \"-\" / \".\" / \"_\" / \"~\"\n       */\n      const unreserved =\n        'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~';\n      let size = 45;\n      let id = '';\n\n      const crypto =\n        typeof self === 'undefined' ? null : self.crypto || self['msCrypto'];\n      if (crypto) {\n        let bytes = new Uint8Array(size);\n        crypto.getRandomValues(bytes);\n\n        // Needed for IE\n        if (!bytes.map) {\n          (bytes as any).map = Array.prototype.map;\n        }\n\n        bytes = bytes.map((x) => unreserved.charCodeAt(x % unreserved.length));\n        id = String.fromCharCode.apply(null, bytes);\n      } else {\n        while (0 < size--) {\n          id += unreserved[(Math.random() * unreserved.length) | 0];\n        }\n      }\n\n      resolve(base64UrlEncode(id));\n    });\n  }\n\n  protected async checkAtHash(params: ValidationParams): Promise<boolean> {\n    if (!this.tokenValidationHandler) {\n      this.logger.warn(\n        'No tokenValidationHandler configured. Cannot check at_hash.'\n      );\n      return true;\n    }\n    return this.tokenValidationHandler.validateAtHash(params);\n  }\n\n  protected checkSignature(params: ValidationParams): Promise<any> {\n    if (!this.tokenValidationHandler) {\n      this.logger.warn(\n        'No tokenValidationHandler configured. Cannot check signature.'\n      );\n      return Promise.resolve(null);\n    }\n    return this.tokenValidationHandler.validateSignature(params);\n  }\n\n  /**\n   * Start the implicit flow or the code flow,\n   * depending on your configuration.\n   */\n  public initLoginFlow(additionalState = '', params = {}): void {\n    if (this.responseType === 'code') {\n      return this.initCodeFlow(additionalState, params);\n    } else {\n      return this.initImplicitFlow(additionalState, params);\n    }\n  }\n\n  /**\n   * Starts the authorization code flow and redirects to user to\n   * the auth servers login url.\n   */\n  public initCodeFlow(additionalState = '', params = {}): void {\n    if (this.loginUrl !== '') {\n      this.initCodeFlowInternal(additionalState, params);\n    } else {\n      this.events\n        .pipe(filter((e) => e.type === 'discovery_document_loaded'))\n        .subscribe(() => this.initCodeFlowInternal(additionalState, params));\n    }\n  }\n\n  private initCodeFlowInternal(additionalState = '', params = {}): void {\n    if (!this.validateUrlForHttps(this.loginUrl)) {\n      throw new Error(\n        \"loginUrl  must use HTTPS (with TLS), or config value for property 'requireHttps' must be set to 'false' and allow HTTP (without TLS).\"\n      );\n    }\n\n    let addParams = {};\n    let loginHint = null;\n    if (typeof params === 'string') {\n      loginHint = params;\n    } else if (typeof params === 'object') {\n      addParams = params;\n    }\n\n    this.createLoginUrl(additionalState, loginHint, null, false, addParams)\n      .then(this.config.openUri)\n      .catch((error) => {\n        console.error('Error in initAuthorizationCodeFlow');\n        console.error(error);\n      });\n  }\n\n  protected async createChallangeVerifierPairForPKCE(): Promise<\n    [string, string]\n  > {\n    if (!this.crypto) {\n      throw new Error(\n        'PKCE support for code flow needs a CryptoHander. Did you import the OAuthModule using forRoot() ?'\n      );\n    }\n\n    const verifier = await this.createNonce();\n    const challengeRaw = await this.crypto.calcHash(verifier, 'sha-256');\n    const challenge = base64UrlEncode(challengeRaw);\n\n    return [challenge, verifier];\n  }\n\n  private extractRecognizedCustomParameters(\n    tokenResponse: TokenResponse\n  ): Map<string, string> {\n    const foundParameters: Map<string, string> = new Map<string, string>();\n    if (!this.config.customTokenParameters) {\n      return foundParameters;\n    }\n    this.config.customTokenParameters.forEach((recognizedParameter: string) => {\n      if (tokenResponse[recognizedParameter]) {\n        foundParameters.set(\n          recognizedParameter,\n          JSON.stringify(tokenResponse[recognizedParameter])\n        );\n      }\n    });\n    return foundParameters;\n  }\n\n  /**\n   * Revokes the auth token to secure the vulnarability\n   * of the token issued allowing the authorization server to clean\n   * up any security credentials associated with the authorization\n   */\n  public revokeTokenAndLogout(\n    customParameters: boolean | object = {},\n    ignoreCorsIssues = false\n  ): Promise<any> {\n    const revokeEndpoint = this.revocationEndpoint;\n    const accessToken = this.getAccessToken();\n    const refreshToken = this.getRefreshToken();\n\n    if (!accessToken) {\n      return Promise.resolve();\n    }\n\n    let params = new HttpParams({ encoder: new WebHttpUrlEncodingCodec() });\n\n    let headers = new HttpHeaders().set(\n      'Content-Type',\n      'application/x-www-form-urlencoded'\n    );\n\n    if (this.useHttpBasicAuth) {\n      const header = btoa(`${this.clientId}:${this.dummyClientSecret}`);\n      headers = headers.set('Authorization', 'Basic ' + header);\n    }\n\n    if (!this.useHttpBasicAuth) {\n      params = params.set('client_id', this.clientId);\n    }\n\n    if (!this.useHttpBasicAuth && this.dummyClientSecret) {\n      params = params.set('client_secret', this.dummyClientSecret);\n    }\n\n    if (this.customQueryParams) {\n      for (const key of Object.getOwnPropertyNames(this.customQueryParams)) {\n        params = params.set(key, this.customQueryParams[key]);\n      }\n    }\n\n    return new Promise((resolve, reject) => {\n      let revokeAccessToken: Observable<void>;\n      let revokeRefreshToken: Observable<void>;\n\n      if (accessToken) {\n        const revokationParams = params\n          .set('token', accessToken)\n          .set('token_type_hint', 'access_token');\n        revokeAccessToken = this.http.post<void>(\n          revokeEndpoint,\n          revokationParams,\n          { headers }\n        );\n      } else {\n        revokeAccessToken = of(null);\n      }\n\n      if (refreshToken) {\n        const revokationParams = params\n          .set('token', refreshToken)\n          .set('token_type_hint', 'refresh_token');\n        revokeRefreshToken = this.http.post<void>(\n          revokeEndpoint,\n          revokationParams,\n          { headers }\n        );\n      } else {\n        revokeRefreshToken = of(null);\n      }\n\n      if (ignoreCorsIssues) {\n        revokeAccessToken = revokeAccessToken.pipe(\n          catchError((err: HttpErrorResponse) => {\n            if (err.status === 0) {\n              return of<void>(null);\n            }\n            return throwError(err);\n          })\n        );\n\n        revokeRefreshToken = revokeRefreshToken.pipe(\n          catchError((err: HttpErrorResponse) => {\n            if (err.status === 0) {\n              return of<void>(null);\n            }\n            return throwError(err);\n          })\n        );\n      }\n\n      combineLatest([revokeAccessToken, revokeRefreshToken]).subscribe(\n        (res) => {\n          this.logOut(customParameters);\n          resolve(res);\n          this.logger.info('Token successfully revoked');\n        },\n        (err) => {\n          this.logger.error('Error revoking token', err);\n          this.eventsSubject.next(\n            new OAuthErrorEvent('token_revoke_error', err)\n          );\n          reject(err);\n        }\n      );\n    });\n  }\n\n  /**\n   * Clear location.hash if it's present\n   */\n  private clearLocationHash() {\n    // Checking for empty hash is necessary for Firefox\n    // as setting an empty hash to an empty string adds # to the URL\n    if (location.hash != '') {\n      location.hash = '';\n    }\n  }\n}\n"]}