@azure/msal-angular 3.0.0 → 3.0.2

package/esm2020/msal.guard.mjs

@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { Injectable, Inject } from '@angular/core';
+import { InteractionType, BrowserConfigurationAuthError, BrowserUtils, UrlString, } from '@azure/msal-browser';
+import { of } from 'rxjs';
+import { concatMap, catchError, map } from 'rxjs/operators';
+import { MSAL_GUARD_CONFIG } from './constants';
+import * as i0 from "@angular/core";
+import * as i1 from "./msal.broadcast.service";
+import * as i2 from "./msal.service";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/router";
+export class MsalGuard {
+    constructor(msalGuardConfig, msalBroadcastService, authService, location, router) {
+        this.msalGuardConfig = msalGuardConfig;
+        this.msalBroadcastService = msalBroadcastService;
+        this.authService = authService;
+        this.location = location;
+        this.router = router;
+        // Subscribing so events in MsalGuard will set inProgress$ observable
+        this.msalBroadcastService.inProgress$.subscribe();
+    }
+    /**
+     * Parses url string to UrlTree
+     * @param url
+     */
+    parseUrl(url) {
+        return this.router.parseUrl(url);
+    }
+    /**
+     * Builds the absolute url for the destination page
+     * @param path Relative path of requested page
+     * @returns Full destination url
+     */
+    getDestinationUrl(path) {
+        this.authService.getLogger().verbose('Guard - getting destination url');
+        // Absolute base url for the application (default to origin if base element not present)
+        const baseElements = document.getElementsByTagName('base');
+        const baseUrl = this.location.normalize(baseElements.length ? baseElements[0].href : window.location.origin);
+        // Path of page (including hash, if using hash routing)
+        const pathUrl = this.location.prepareExternalUrl(path);
+        // Hash location strategy
+        if (pathUrl.startsWith('#')) {
+            this.authService
+                .getLogger()
+                .verbose('Guard - destination by hash routing');
+            return `${baseUrl}/${pathUrl}`;
+        }
+        /*
+         * If using path location strategy, pathUrl will include the relative portion of the base path (e.g. /base/page).
+         * Since baseUrl also includes /base, can just concatentate baseUrl + path
+         */
+        return `${baseUrl}${path}`;
+    }
+    /**
+     * Interactively prompt the user to login
+     * @param url Path of the requested page
+     */
+    loginInteractively(state) {
+        const authRequest = typeof this.msalGuardConfig.authRequest === 'function'
+            ? this.msalGuardConfig.authRequest(this.authService, state)
+            : { ...this.msalGuardConfig.authRequest };
+        if (this.msalGuardConfig.interactionType === InteractionType.Popup) {
+            this.authService.getLogger().verbose('Guard - logging in by popup');
+            return this.authService.loginPopup(authRequest).pipe(map((response) => {
+                this.authService
+                    .getLogger()
+                    .verbose('Guard - login by popup successful, can activate, setting active account');
+                this.authService.instance.setActiveAccount(response.account);
+                return true;
+            }));
+        }
+        this.authService.getLogger().verbose('Guard - logging in by redirect');
+        const redirectStartPage = this.getDestinationUrl(state.url);
+        return this.authService
+            .loginRedirect({
+            redirectStartPage,
+            ...authRequest,
+        })
+            .pipe(map(() => false));
+    }
+    /**
+     * Helper which checks for the correct interaction type, prevents page with Guard to be set as redirect, and calls handleRedirectObservable
+     * @param state
+     */
+    activateHelper(state) {
+        if (this.msalGuardConfig.interactionType !== InteractionType.Popup &&
+            this.msalGuardConfig.interactionType !== InteractionType.Redirect) {
+            throw new BrowserConfigurationAuthError('invalid_interaction_type', 'Invalid interaction type provided to MSAL Guard. InteractionType.Popup or InteractionType.Redirect must be provided in the MsalGuardConfiguration');
+        }
+        this.authService.getLogger().verbose('MSAL Guard activated');
+        /*
+         * If a page with MSAL Guard is set as the redirect for acquireTokenSilent,
+         * short-circuit to prevent redirecting or popups.
+         */
+        if (typeof window !== 'undefined') {
+            if (UrlString.hashContainsKnownProperties(window.location.hash) &&
+                BrowserUtils.isInIframe() &&
+                !this.authService.instance.getConfiguration().system
+                    .allowRedirectInIframe) {
+                this.authService
+                    .getLogger()
+                    .warning('Guard - redirectUri set to page with MSAL Guard. It is recommended to not set redirectUri to a page that requires authentication.');
+                return of(false);
+            }
+        }
+        else {
+            this.authService
+                .getLogger()
+                .info('Guard - window is undefined, MSAL does not support server-side token acquisition');
+            return of(true);
+        }
+        /**
+         * If a loginFailedRoute is set in the config, set this as the loginFailedRoute
+         */
+        if (this.msalGuardConfig.loginFailedRoute) {
+            this.loginFailedRoute = this.parseUrl(this.msalGuardConfig.loginFailedRoute);
+        }
+        // Capture current path before it gets changed by handleRedirectObservable
+        const currentPath = this.location.path(true);
+        return this.authService.initialize().pipe(concatMap(() => {
+            return this.authService.handleRedirectObservable();
+        }), concatMap(() => {
+            if (!this.authService.instance.getAllAccounts().length) {
+                if (state) {
+                    this.authService
+                        .getLogger()
+                        .verbose('Guard - no accounts retrieved, log in required to activate');
+                    return this.loginInteractively(state);
+                }
+                this.authService
+                    .getLogger()
+                    .verbose('Guard - no accounts retrieved, no state, cannot load');
+                return of(false);
+            }
+            this.authService
+                .getLogger()
+                .verbose('Guard - at least 1 account exists, can activate or load');
+            // Prevent navigating the app to /#code= or /code=
+            if (state) {
+                /*
+                 * Path routing:
+                 * state.url: /#code=...
+                 * state.root.fragment: code=...
+                 */
+                /*
+                 * Hash routing:
+                 * state.url: /code
+                 * state.root.fragment: null
+                 */
+                const urlContainsCode = this.includesCode(state.url);
+                const fragmentContainsCode = !!state.root &&
+                    !!state.root.fragment &&
+                    this.includesCode(`#${state.root.fragment}`);
+                const hashRouting = this.location.prepareExternalUrl(state.url).indexOf('#') === 0;
+                // Ensure code parameter is in fragment (and not in query parameter), or that hash hash routing is used
+                if (urlContainsCode && (fragmentContainsCode || hashRouting)) {
+                    this.authService
+                        .getLogger()
+                        .info('Guard - Hash contains known code response, stopping navigation.');
+                    // Path routing (navigate to current path without hash)
+                    if (currentPath.indexOf('#') > -1) {
+                        return of(this.parseUrl(this.location.path()));
+                    }
+                    // Hash routing (navigate to root path)
+                    return of(this.parseUrl(''));
+                }
+            }
+            return of(true);
+        }), catchError((error) => {
+            this.authService
+                .getLogger()
+                .error('Guard - error while logging in, unable to activate');
+            this.authService
+                .getLogger()
+                .errorPii(`Guard - error: ${error.message}`);
+            /**
+             * If a loginFailedRoute is set, checks to see if state is passed before returning route
+             */
+            if (this.loginFailedRoute && state) {
+                this.authService
+                    .getLogger()
+                    .verbose('Guard - loginFailedRoute set, redirecting');
+                return of(this.loginFailedRoute);
+            }
+            return of(false);
+        }));
+    }
+    includesCode(path) {
+        return ((path.lastIndexOf('/code') > -1 &&
+            path.lastIndexOf('/code') === path.length - '/code'.length) || // path.endsWith("/code")
+            path.indexOf('#code=') > -1 ||
+            path.indexOf('&code=') > -1);
+    }
+    canActivate(route, state) {
+        this.authService.getLogger().verbose('Guard - canActivate');
+        return this.activateHelper(state);
+    }
+    canActivateChild(route, state) {
+        this.authService.getLogger().verbose('Guard - canActivateChild');
+        return this.activateHelper(state);
+    }
+    canMatch() {
+        this.authService.getLogger().verbose('Guard - canLoad');
+        return this.activateHelper();
+    }
+}
+MsalGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: MsalGuard, deps: [{ token: MSAL_GUARD_CONFIG }, { token: i1.MsalBroadcastService }, { token: i2.MsalService }, { token: i3.Location }, { token: i4.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+MsalGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: MsalGuard });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: MsalGuard, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MSAL_GUARD_CONFIG]
+                }] }, { type: i1.MsalBroadcastService }, { type: i2.MsalService }, { type: i3.Location }, { type: i4.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"msal.guard.js","sourceRoot":"","sources":["../../src/msal.guard.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { Injectable, Inject } from '@angular/core';\nimport { Location } from '@angular/common';\nimport {\n  ActivatedRouteSnapshot,\n  RouterStateSnapshot,\n  UrlTree,\n  Router,\n} from '@angular/router';\nimport {\n  InteractionType,\n  BrowserConfigurationAuthError,\n  BrowserUtils,\n  UrlString,\n  PopupRequest,\n  RedirectRequest,\n  AuthenticationResult,\n} from '@azure/msal-browser';\nimport { Observable, of } from 'rxjs';\nimport { concatMap, catchError, map } from 'rxjs/operators';\nimport { MsalService } from './msal.service';\nimport { MsalGuardConfiguration } from './msal.guard.config';\nimport { MsalBroadcastService } from './msal.broadcast.service';\nimport { MSAL_GUARD_CONFIG } from './constants';\n\n@Injectable()\nexport class MsalGuard {\n  private loginFailedRoute?: UrlTree;\n\n  constructor(\n    @Inject(MSAL_GUARD_CONFIG) private msalGuardConfig: MsalGuardConfiguration,\n    private msalBroadcastService: MsalBroadcastService,\n    private authService: MsalService,\n    private location: Location,\n    private router: Router\n  ) {\n    // Subscribing so events in MsalGuard will set inProgress$ observable\n    this.msalBroadcastService.inProgress$.subscribe();\n  }\n\n  /**\n   * Parses url string to UrlTree\n   * @param url\n   */\n  parseUrl(url: string): UrlTree {\n    return this.router.parseUrl(url);\n  }\n\n  /**\n   * Builds the absolute url for the destination page\n   * @param path Relative path of requested page\n   * @returns Full destination url\n   */\n  getDestinationUrl(path: string): string {\n    this.authService.getLogger().verbose('Guard - getting destination url');\n    // Absolute base url for the application (default to origin if base element not present)\n    const baseElements = document.getElementsByTagName('base');\n    const baseUrl = this.location.normalize(\n      baseElements.length ? baseElements[0].href : window.location.origin\n    );\n\n    // Path of page (including hash, if using hash routing)\n    const pathUrl = this.location.prepareExternalUrl(path);\n\n    // Hash location strategy\n    if (pathUrl.startsWith('#')) {\n      this.authService\n        .getLogger()\n        .verbose('Guard - destination by hash routing');\n      return `${baseUrl}/${pathUrl}`;\n    }\n\n    /*\n     * If using path location strategy, pathUrl will include the relative portion of the base path (e.g. /base/page).\n     * Since baseUrl also includes /base, can just concatentate baseUrl + path\n     */\n    return `${baseUrl}${path}`;\n  }\n\n  /**\n   * Interactively prompt the user to login\n   * @param url Path of the requested page\n   */\n  private loginInteractively(state: RouterStateSnapshot): Observable<boolean> {\n    const authRequest =\n      typeof this.msalGuardConfig.authRequest === 'function'\n        ? this.msalGuardConfig.authRequest(this.authService, state)\n        : { ...this.msalGuardConfig.authRequest };\n    if (this.msalGuardConfig.interactionType === InteractionType.Popup) {\n      this.authService.getLogger().verbose('Guard - logging in by popup');\n      return this.authService.loginPopup(authRequest as PopupRequest).pipe(\n        map((response: AuthenticationResult) => {\n          this.authService\n            .getLogger()\n            .verbose(\n              'Guard - login by popup successful, can activate, setting active account'\n            );\n          this.authService.instance.setActiveAccount(response.account);\n          return true;\n        })\n      );\n    }\n\n    this.authService.getLogger().verbose('Guard - logging in by redirect');\n    const redirectStartPage = this.getDestinationUrl(state.url);\n    return this.authService\n      .loginRedirect({\n        redirectStartPage,\n        ...authRequest,\n      } as RedirectRequest)\n      .pipe(map(() => false));\n  }\n\n  /**\n   * Helper which checks for the correct interaction type, prevents page with Guard to be set as redirect, and calls handleRedirectObservable\n   * @param state\n   */\n  private activateHelper(\n    state?: RouterStateSnapshot\n  ): Observable<boolean | UrlTree> {\n    if (\n      this.msalGuardConfig.interactionType !== InteractionType.Popup &&\n      this.msalGuardConfig.interactionType !== InteractionType.Redirect\n    ) {\n      throw new BrowserConfigurationAuthError(\n        'invalid_interaction_type',\n        'Invalid interaction type provided to MSAL Guard. InteractionType.Popup or InteractionType.Redirect must be provided in the MsalGuardConfiguration'\n      );\n    }\n    this.authService.getLogger().verbose('MSAL Guard activated');\n\n    /*\n     * If a page with MSAL Guard is set as the redirect for acquireTokenSilent,\n     * short-circuit to prevent redirecting or popups.\n     */\n    if (typeof window !== 'undefined') {\n      if (\n        UrlString.hashContainsKnownProperties(window.location.hash) &&\n        BrowserUtils.isInIframe() &&\n        !this.authService.instance.getConfiguration().system\n          .allowRedirectInIframe\n      ) {\n        this.authService\n          .getLogger()\n          .warning(\n            'Guard - redirectUri set to page with MSAL Guard. It is recommended to not set redirectUri to a page that requires authentication.'\n          );\n        return of(false);\n      }\n    } else {\n      this.authService\n        .getLogger()\n        .info(\n          'Guard - window is undefined, MSAL does not support server-side token acquisition'\n        );\n      return of(true);\n    }\n\n    /**\n     * If a loginFailedRoute is set in the config, set this as the loginFailedRoute\n     */\n    if (this.msalGuardConfig.loginFailedRoute) {\n      this.loginFailedRoute = this.parseUrl(\n        this.msalGuardConfig.loginFailedRoute\n      );\n    }\n\n    // Capture current path before it gets changed by handleRedirectObservable\n    const currentPath = this.location.path(true);\n\n    return this.authService.initialize().pipe(\n      concatMap(() => {\n        return this.authService.handleRedirectObservable();\n      }),\n      concatMap(() => {\n        if (!this.authService.instance.getAllAccounts().length) {\n          if (state) {\n            this.authService\n              .getLogger()\n              .verbose(\n                'Guard - no accounts retrieved, log in required to activate'\n              );\n            return this.loginInteractively(state);\n          }\n          this.authService\n            .getLogger()\n            .verbose('Guard - no accounts retrieved, no state, cannot load');\n          return of(false);\n        }\n\n        this.authService\n          .getLogger()\n          .verbose('Guard - at least 1 account exists, can activate or load');\n\n        // Prevent navigating the app to /#code= or /code=\n        if (state) {\n          /*\n           * Path routing:\n           * state.url: /#code=...\n           * state.root.fragment: code=...\n           */\n\n          /*\n           * Hash routing:\n           * state.url: /code\n           * state.root.fragment: null\n           */\n          const urlContainsCode: boolean = this.includesCode(state.url);\n          const fragmentContainsCode: boolean =\n            !!state.root &&\n            !!state.root.fragment &&\n            this.includesCode(`#${state.root.fragment}`);\n          const hashRouting: boolean =\n            this.location.prepareExternalUrl(state.url).indexOf('#') === 0;\n\n          // Ensure code parameter is in fragment (and not in query parameter), or that hash hash routing is used\n          if (urlContainsCode && (fragmentContainsCode || hashRouting)) {\n            this.authService\n              .getLogger()\n              .info(\n                'Guard - Hash contains known code response, stopping navigation.'\n              );\n\n            // Path routing (navigate to current path without hash)\n            if (currentPath.indexOf('#') > -1) {\n              return of(this.parseUrl(this.location.path()));\n            }\n\n            // Hash routing (navigate to root path)\n            return of(this.parseUrl(''));\n          }\n        }\n\n        return of(true);\n      }),\n      catchError((error: Error) => {\n        this.authService\n          .getLogger()\n          .error('Guard - error while logging in, unable to activate');\n        this.authService\n          .getLogger()\n          .errorPii(`Guard - error: ${error.message}`);\n        /**\n         * If a loginFailedRoute is set, checks to see if state is passed before returning route\n         */\n        if (this.loginFailedRoute && state) {\n          this.authService\n            .getLogger()\n            .verbose('Guard - loginFailedRoute set, redirecting');\n          return of(this.loginFailedRoute);\n        }\n        return of(false);\n      })\n    );\n  }\n\n  includesCode(path: string): boolean {\n    return (\n      (path.lastIndexOf('/code') > -1 &&\n        path.lastIndexOf('/code') === path.length - '/code'.length) || // path.endsWith(\"/code\")\n      path.indexOf('#code=') > -1 ||\n      path.indexOf('&code=') > -1\n    );\n  }\n\n  canActivate(\n    route: ActivatedRouteSnapshot,\n    state: RouterStateSnapshot\n  ): Observable<boolean | UrlTree> {\n    this.authService.getLogger().verbose('Guard - canActivate');\n    return this.activateHelper(state);\n  }\n\n  canActivateChild(\n    route: ActivatedRouteSnapshot,\n    state: RouterStateSnapshot\n  ): Observable<boolean | UrlTree> {\n    this.authService.getLogger().verbose('Guard - canActivateChild');\n    return this.activateHelper(state);\n  }\n\n  canMatch(): Observable<boolean | UrlTree> {\n    this.authService.getLogger().verbose('Guard - canLoad');\n    return this.activateHelper();\n  }\n}\n"]}

package/esm2020/msal.interceptor.config.mjs

@@ -0,0 +1,6 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXNhbC5pbnRlcmNlcHRvci5jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbXNhbC5pbnRlcmNlcHRvci5jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAoYykgTWljcm9zb2Z0IENvcnBvcmF0aW9uLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICogTGljZW5zZWQgdW5kZXIgdGhlIE1JVCBMaWNlbnNlLlxuICovXG5cbi8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBpbXBvcnQvbm8tdW5yZXNvbHZlZFxuaW1wb3J0IHsgSHR0cFJlcXVlc3QgfSBmcm9tICdAYW5ndWxhci9jb21tb24vaHR0cCc7XG5pbXBvcnQge1xuICBQb3B1cFJlcXVlc3QsXG4gIFJlZGlyZWN0UmVxdWVzdCxcbiAgSW50ZXJhY3Rpb25UeXBlLFxuICBTaWxlbnRSZXF1ZXN0LFxufSBmcm9tICdAYXp1cmUvbXNhbC1icm93c2VyJztcbmltcG9ydCB7IE1zYWxTZXJ2aWNlIH0gZnJvbSAnLi9tc2FsLnNlcnZpY2UnO1xuXG5leHBvcnQgZGVjbGFyZSB0eXBlIE1zYWxJbnRlcmNlcHRvckF1dGhSZXF1ZXN0ID1cbiAgfCBPbWl0PFBvcHVwUmVxdWVzdCwgJ3Njb3Blcyc+XG4gIHwgT21pdDxSZWRpcmVjdFJlcXVlc3QsICdzY29wZXMnPlxuICB8IE9taXQ8U2lsZW50UmVxdWVzdCwgJ3Njb3Blcyc+O1xuXG5leHBvcnQgdHlwZSBNc2FsSW50ZXJjZXB0b3JDb25maWd1cmF0aW9uID0ge1xuICBpbnRlcmFjdGlvblR5cGU6IEludGVyYWN0aW9uVHlwZS5Qb3B1cCB8IEludGVyYWN0aW9uVHlwZS5SZWRpcmVjdDtcbiAgcHJvdGVjdGVkUmVzb3VyY2VNYXA6IE1hcDxcbiAgICBzdHJpbmcsXG4gICAgQXJyYXk8c3RyaW5nIHwgUHJvdGVjdGVkUmVzb3VyY2VTY29wZXM+IHwgbnVsbFxuICA+O1xuICBhdXRoUmVxdWVzdD86XG4gICAgfCBNc2FsSW50ZXJjZXB0b3JBdXRoUmVxdWVzdFxuICAgIHwgKChcbiAgICAgICAgbXNhbFNlcnZpY2U6IE1zYWxTZXJ2aWNlLFxuICAgICAgICByZXE6IEh0dHBSZXF1ZXN0PHVua25vd24+LFxuICAgICAgICBvcmlnaW5hbEF1dGhSZXF1ZXN0OiBNc2FsSW50ZXJjZXB0b3JBdXRoUmVxdWVzdFxuICAgICAgKSA9PiBNc2FsSW50ZXJjZXB0b3JBdXRoUmVxdWVzdCk7XG59O1xuXG5leHBvcnQgdHlwZSBQcm90ZWN0ZWRSZXNvdXJjZVNjb3BlcyA9IHtcbiAgaHR0cE1ldGhvZDogc3RyaW5nO1xuICBzY29wZXM6IEFycmF5PHN0cmluZz4gfCBudWxsO1xufTtcblxuZXhwb3J0IHR5cGUgTWF0Y2hpbmdSZXNvdXJjZXMgPSB7XG4gIGFic29sdXRlUmVzb3VyY2VzOiBBcnJheTxzdHJpbmc+O1xuICByZWxhdGl2ZVJlc291cmNlczogQXJyYXk8c3RyaW5nPjtcbn07XG4iXX0=

package/esm2020/msal.interceptor.mjs

@@ -0,0 +1,270 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { Injectable, Inject } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import { BrowserConfigurationAuthError, InteractionStatus, InteractionType, StringUtils, UrlString, } from '@azure/msal-browser';
+import { EMPTY, of } from 'rxjs';
+import { switchMap, catchError, take, filter } from 'rxjs/operators';
+import { MSAL_INTERCEPTOR_CONFIG } from './constants';
+import * as i0 from "@angular/core";
+import * as i1 from "./msal.service";
+import * as i2 from "@angular/common";
+import * as i3 from "./msal.broadcast.service";
+export class MsalInterceptor {
+    constructor(msalInterceptorConfig, authService, location, msalBroadcastService, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+    document) {
+        this.msalInterceptorConfig = msalInterceptorConfig;
+        this.authService = authService;
+        this.location = location;
+        this.msalBroadcastService = msalBroadcastService;
+        this._document = document;
+    }
+    intercept(req, // eslint-disable-line @typescript-eslint/no-explicit-any
+    next
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ) {
+        if (this.msalInterceptorConfig.interactionType !== InteractionType.Popup &&
+            this.msalInterceptorConfig.interactionType !== InteractionType.Redirect) {
+            throw new BrowserConfigurationAuthError('invalid_interaction_type', 'Invalid interaction type provided to MSAL Interceptor. InteractionType.Popup, InteractionType.Redirect must be provided in the msalInterceptorConfiguration');
+        }
+        this.authService.getLogger().verbose('MSAL Interceptor activated');
+        const scopes = this.getScopesForEndpoint(req.url, req.method);
+        // If no scopes for endpoint, does not acquire token
+        if (!scopes || scopes.length === 0) {
+            this.authService
+                .getLogger()
+                .verbose('Interceptor - no scopes for endpoint');
+            return next.handle(req);
+        }
+        // Sets account as active account or first account
+        let account;
+        if (!!this.authService.instance.getActiveAccount()) {
+            this.authService
+                .getLogger()
+                .verbose('Interceptor - active account selected');
+            account = this.authService.instance.getActiveAccount();
+        }
+        else {
+            this.authService
+                .getLogger()
+                .verbose('Interceptor - no active account, fallback to first account');
+            account = this.authService.instance.getAllAccounts()[0];
+        }
+        const authRequest = typeof this.msalInterceptorConfig.authRequest === 'function'
+            ? this.msalInterceptorConfig.authRequest(this.authService, req, {
+                account: account,
+            })
+            : { ...this.msalInterceptorConfig.authRequest, account };
+        this.authService
+            .getLogger()
+            .info(`Interceptor - ${scopes.length} scopes found for endpoint`);
+        this.authService
+            .getLogger()
+            .infoPii(`Interceptor - [${scopes}] scopes found for ${req.url}`);
+        return this.acquireToken(authRequest, scopes, account).pipe(switchMap((result) => {
+            this.authService
+                .getLogger()
+                .verbose('Interceptor - setting authorization headers');
+            const headers = req.headers.set('Authorization', `Bearer ${result.accessToken}`);
+            const requestClone = req.clone({ headers });
+            return next.handle(requestClone);
+        }));
+    }
+    /**
+     * Try to acquire token silently. Invoke interaction if acquireTokenSilent rejected with error or resolved with null access token
+     * @param authRequest Request
+     * @param scopes Array of scopes for the request
+     * @param account Account
+     * @returns Authentication result
+     */
+    acquireToken(authRequest, scopes, account) {
+        // Note: For MSA accounts, include openid scope when calling acquireTokenSilent to return idToken
+        return this.authService
+            .acquireTokenSilent({ ...authRequest, scopes, account })
+            .pipe(catchError(() => {
+            this.authService
+                .getLogger()
+                .error('Interceptor - acquireTokenSilent rejected with error. Invoking interaction to resolve.');
+            return this.msalBroadcastService.inProgress$.pipe(take(1), switchMap((status) => {
+                if (status === InteractionStatus.None) {
+                    return this.acquireTokenInteractively(authRequest, scopes);
+                }
+                return this.msalBroadcastService.inProgress$.pipe(filter((status) => status === InteractionStatus.None), take(1), switchMap(() => this.acquireToken(authRequest, scopes, account)));
+            }));
+        }), switchMap((result) => {
+            if (!result.accessToken) {
+                this.authService
+                    .getLogger()
+                    .error('Interceptor - acquireTokenSilent resolved with null access token. Known issue with B2C tenants, invoking interaction to resolve.');
+                return this.msalBroadcastService.inProgress$.pipe(filter((status) => status === InteractionStatus.None), take(1), switchMap(() => this.acquireTokenInteractively(authRequest, scopes)));
+            }
+            return of(result);
+        }));
+    }
+    /**
+     * Invoke interaction for the given set of scopes
+     * @param authRequest Request
+     * @param scopes Array of scopes for the request
+     * @returns Result from the interactive request
+     */
+    acquireTokenInteractively(authRequest, scopes) {
+        if (this.msalInterceptorConfig.interactionType === InteractionType.Popup) {
+            this.authService
+                .getLogger()
+                .verbose('Interceptor - error acquiring token silently, acquiring by popup');
+            return this.authService.acquireTokenPopup({ ...authRequest, scopes });
+        }
+        this.authService
+            .getLogger()
+            .verbose('Interceptor - error acquiring token silently, acquiring by redirect');
+        const redirectStartPage = window.location.href;
+        this.authService.acquireTokenRedirect({
+            ...authRequest,
+            scopes,
+            redirectStartPage,
+        });
+        return EMPTY;
+    }
+    /**
+     * Looks up the scopes for the given endpoint from the protectedResourceMap
+     * @param endpoint Url of the request
+     * @param httpMethod Http method of the request
+     * @returns Array of scopes, or null if not found
+     *
+     */
+    getScopesForEndpoint(endpoint, httpMethod) {
+        this.authService
+            .getLogger()
+            .verbose('Interceptor - getting scopes for endpoint');
+        // Ensures endpoints and protected resources compared are normalized
+        const normalizedEndpoint = this.location.normalize(endpoint);
+        const protectedResourcesArray = Array.from(this.msalInterceptorConfig.protectedResourceMap.keys());
+        const matchingProtectedResources = this.matchResourcesToEndpoint(protectedResourcesArray, normalizedEndpoint);
+        // Check absolute urls of resources first before checking relative to prevent incorrect matching where multiple resources have similar relative urls
+        if (matchingProtectedResources.absoluteResources.length > 0) {
+            return this.matchScopesToEndpoint(this.msalInterceptorConfig.protectedResourceMap, matchingProtectedResources.absoluteResources, httpMethod);
+        }
+        else if (matchingProtectedResources.relativeResources.length > 0) {
+            return this.matchScopesToEndpoint(this.msalInterceptorConfig.protectedResourceMap, matchingProtectedResources.relativeResources, httpMethod);
+        }
+        return null;
+    }
+    /**
+     * Finds resource endpoints that match request endpoint
+     * @param protectedResourcesEndpoints
+     * @param endpoint
+     * @returns
+     */
+    matchResourcesToEndpoint(protectedResourcesEndpoints, endpoint) {
+        const matchingResources = {
+            absoluteResources: [],
+            relativeResources: [],
+        };
+        protectedResourcesEndpoints.forEach((key) => {
+            // Normalizes and adds resource to matchingResources.absoluteResources if key matches endpoint. StringUtils.matchPattern accounts for wildcards
+            const normalizedKey = this.location.normalize(key);
+            if (StringUtils.matchPattern(normalizedKey, endpoint)) {
+                matchingResources.absoluteResources.push(key);
+            }
+            // Get url components for relative urls
+            const absoluteKey = this.getAbsoluteUrl(key);
+            const keyComponents = new UrlString(absoluteKey).getUrlComponents();
+            const absoluteEndpoint = this.getAbsoluteUrl(endpoint);
+            const endpointComponents = new UrlString(absoluteEndpoint).getUrlComponents();
+            // Normalized key should include query strings if applicable
+            const relativeNormalizedKey = keyComponents.QueryString
+                ? `${keyComponents.AbsolutePath}?${keyComponents.QueryString}`
+                : this.location.normalize(keyComponents.AbsolutePath);
+            // Add resource to matchingResources.relativeResources if same origin, relativeKey matches endpoint, and is not empty
+            if (keyComponents.HostNameAndPort === endpointComponents.HostNameAndPort &&
+                StringUtils.matchPattern(relativeNormalizedKey, absoluteEndpoint) &&
+                relativeNormalizedKey !== '' &&
+                relativeNormalizedKey !== '/*') {
+                matchingResources.relativeResources.push(key);
+            }
+        });
+        return matchingResources;
+    }
+    /**
+     * Transforms relative urls to absolute urls
+     * @param url
+     * @returns
+     */
+    getAbsoluteUrl(url) {
+        const link = this._document.createElement('a');
+        link.href = url;
+        return link.href;
+    }
+    /**
+     * Finds scopes from first matching endpoint with HTTP method that matches request
+     * @param protectedResourceMap Protected resource map
+     * @param endpointArray Array of resources that match request endpoint
+     * @param httpMethod Http method of the request
+     * @returns
+     */
+    matchScopesToEndpoint(protectedResourceMap, endpointArray, httpMethod) {
+        const allMatchedScopes = [];
+        // Check each matched endpoint for matching HttpMethod and scopes
+        endpointArray.forEach((matchedEndpoint) => {
+            const scopesForEndpoint = [];
+            const methodAndScopesArray = protectedResourceMap.get(matchedEndpoint);
+            // Return if resource is unprotected
+            if (methodAndScopesArray === null) {
+                allMatchedScopes.push(null);
+                return;
+            }
+            methodAndScopesArray.forEach((entry) => {
+                // Entry is either array of scopes or ProtectedResourceScopes object
+                if (typeof entry === 'string') {
+                    scopesForEndpoint.push(entry);
+                }
+                else {
+                    // Ensure methods being compared are normalized
+                    const normalizedRequestMethod = httpMethod.toLowerCase();
+                    const normalizedResourceMethod = entry.httpMethod.toLowerCase();
+                    // Method in protectedResourceMap matches request http method
+                    if (normalizedResourceMethod === normalizedRequestMethod) {
+                        // Validate if scopes comes null to unprotect the resource in a certain http method
+                        if (entry.scopes === null) {
+                            allMatchedScopes.push(null);
+                        }
+                        else {
+                            entry.scopes.forEach((scope) => {
+                                scopesForEndpoint.push(scope);
+                            });
+                        }
+                    }
+                }
+            });
+            // Only add to all scopes if scopes for endpoint and method is found
+            if (scopesForEndpoint.length > 0) {
+                allMatchedScopes.push(scopesForEndpoint);
+            }
+        });
+        if (allMatchedScopes.length > 0) {
+            if (allMatchedScopes.length > 1) {
+                this.authService
+                    .getLogger()
+                    .warning('Interceptor - More than 1 matching scopes for endpoint found.');
+            }
+            // Returns scopes for first matching endpoint
+            return allMatchedScopes[0];
+        }
+        return null;
+    }
+}
+MsalInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: MsalInterceptor, deps: [{ token: MSAL_INTERCEPTOR_CONFIG }, { token: i1.MsalService }, { token: i2.Location }, { token: i3.MsalBroadcastService }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+MsalInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: MsalInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: MsalInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MSAL_INTERCEPTOR_CONFIG]
+                }] }, { type: i1.MsalService }, { type: i2.Location }, { type: i3.MsalBroadcastService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"msal.interceptor.js","sourceRoot":"","sources":["../../src/msal.interceptor.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAY,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAOrD,OAAO,EAGL,6BAA6B,EAC7B,iBAAiB,EACjB,eAAe,EACf,WAAW,EACX,SAAS,GACV,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAc,KAAK,EAAE,EAAE,EAAE,MAAM,MAAM,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AASrE,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;;;;;AAGtD,MAAM,OAAO,eAAe;IAG1B,YAEU,qBAAmD,EACnD,WAAwB,EACxB,QAAkB,EAClB,oBAA0C;IAClD,iHAAiH;IAC/F,QAAc;QALxB,0BAAqB,GAArB,qBAAqB,CAA8B;QACnD,gBAAW,GAAX,WAAW,CAAa;QACxB,aAAQ,GAAR,QAAQ,CAAU;QAClB,yBAAoB,GAApB,oBAAoB,CAAsB;QAIlD,IAAI,CAAC,SAAS,GAAG,QAAoB,CAAC;IACxC,CAAC;IAED,SAAS,CACP,GAAqB,EAAE,yDAAyD;IAChF,IAAiB;IACjB,8DAA8D;;QAE9D,IACE,IAAI,CAAC,qBAAqB,CAAC,eAAe,KAAK,eAAe,CAAC,KAAK;YACpE,IAAI,CAAC,qBAAqB,CAAC,eAAe,KAAK,eAAe,CAAC,QAAQ,EACvE;YACA,MAAM,IAAI,6BAA6B,CACrC,0BAA0B,EAC1B,6JAA6J,CAC9J,CAAC;SACH;QAED,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,4BAA4B,CAAC,CAAC;QACnE,MAAM,MAAM,GAAG,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;QAE9D,oDAAoD;QACpD,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;YAClC,IAAI,CAAC,WAAW;iBACb,SAAS,EAAE;iBACX,OAAO,CAAC,sCAAsC,CAAC,CAAC;YACnD,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;SACzB;QAED,kDAAkD;QAClD,IAAI,OAAoB,CAAC;QACzB,IAAI,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,gBAAgB,EAAE,EAAE;YAClD,IAAI,CAAC,WAAW;iBACb,SAAS,EAAE;iBACX,OAAO,CAAC,uCAAuC,CAAC,CAAC;YACpD,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,gBAAgB,EAAE,CAAC;SACxD;aAAM;YACL,IAAI,CAAC,WAAW;iBACb,SAAS,EAAE;iBACX,OAAO,CAAC,4DAA4D,CAAC,CAAC;YACzE,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,CAAC;SACzD;QAED,MAAM,WAAW,GACf,OAAO,IAAI,CAAC,qBAAqB,CAAC,WAAW,KAAK,UAAU;YAC1D,CAAC,CAAC,IAAI,CAAC,qBAAqB,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,EAAE,GAAG,EAAE;gBAC5D,OAAO,EAAE,OAAO;aACjB,CAAC;YACJ,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC,qBAAqB,CAAC,WAAW,EAAE,OAAO,EAAE,CAAC;QAE7D,IAAI,CAAC,WAAW;aACb,SAAS,EAAE;aACX,IAAI,CAAC,iBAAiB,MAAM,CAAC,MAAM,4BAA4B,CAAC,CAAC;QACpE,IAAI,CAAC,WAAW;aACb,SAAS,EAAE;aACX,OAAO,CAAC,kBAAkB,MAAM,sBAAsB,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC;QAEpE,OAAO,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,IAAI,CACzD,SAAS,CAAC,CAAC,MAA4B,EAAE,EAAE;YACzC,IAAI,CAAC,WAAW;iBACb,SAAS,EAAE;iBACX,OAAO,CAAC,6CAA6C,CAAC,CAAC;YAC1D,MAAM,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC,GAAG,CAC7B,eAAe,EACf,UAAU,MAAM,CAAC,WAAW,EAAE,CAC/B,CAAC;YAEF,MAAM,YAAY,GAAG,GAAG,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC;YAC5C,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QACnC,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACK,YAAY,CAClB,WAAuC,EACvC,MAAgB,EAChB,OAAoB;QAEpB,iGAAiG;QACjG,OAAO,IAAI,CAAC,WAAW;aACpB,kBAAkB,CAAC,EAAE,GAAG,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;aACvD,IAAI,CACH,UAAU,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,WAAW;iBACb,SAAS,EAAE;iBACX,KAAK,CACJ,wFAAwF,CACzF,CAAC;YACJ,OAAO,IAAI,CAAC,oBAAoB,CAAC,WAAW,CAAC,IAAI,CAC/C,IAAI,CAAC,CAAC,CAAC,EACP,SAAS,CAAC,CAAC,MAAyB,EAAE,EAAE;gBACtC,IAAI,MAAM,KAAK,iBAAiB,CAAC,IAAI,EAAE;oBACrC,OAAO,IAAI,CAAC,yBAAyB,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;iBAC5D;gBAED,OAAO,IAAI,CAAC,oBAAoB,CAAC,WAAW,CAAC,IAAI,CAC/C,MAAM,CACJ,CAAC,MAAyB,EAAE,EAAE,CAC5B,MAAM,KAAK,iBAAiB,CAAC,IAAI,CACpC,EACD,IAAI,CAAC,CAAC,CAAC,EACP,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CACjE,CAAC;YACJ,CAAC,CAAC,CACH,CAAC;QACJ,CAAC,CAAC,EACF,SAAS,CAAC,CAAC,MAA4B,EAAE,EAAE;YACzC,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE;gBACvB,IAAI,CAAC,WAAW;qBACb,SAAS,EAAE;qBACX,KAAK,CACJ,kIAAkI,CACnI,CAAC;gBACJ,OAAO,IAAI,CAAC,oBAAoB,CAAC,WAAW,CAAC,IAAI,CAC/C,MAAM,CACJ,CAAC,MAAyB,EAAE,EAAE,CAAC,MAAM,KAAK,iBAAiB,CAAC,IAAI,CACjE,EACD,IAAI,CAAC,CAAC,CAAC,EACP,SAAS,CAAC,GAAG,EAAE,CACb,IAAI,CAAC,yBAAyB,CAAC,WAAW,EAAE,MAAM,CAAC,CACpD,CACF,CAAC;aACH;YACD,OAAO,EAAE,CAAC,MAAM,CAAC,CAAC;QACpB,CAAC,CAAC,CACH,CAAC;IACN,CAAC;IAED;;;;;OAKG;IACK,yBAAyB,CAC/B,WAAuC,EACvC,MAAgB;QAEhB,IAAI,IAAI,CAAC,qBAAqB,CAAC,eAAe,KAAK,eAAe,CAAC,KAAK,EAAE;YACxE,IAAI,CAAC,WAAW;iBACb,SAAS,EAAE;iBACX,OAAO,CACN,kEAAkE,CACnE,CAAC;YACJ,OAAO,IAAI,CAAC,WAAW,CAAC,iBAAiB,CAAC,EAAE,GAAG,WAAW,EAAE,MAAM,EAAE,CAAC,CAAC;SACvE;QACD,IAAI,CAAC,WAAW;aACb,SAAS,EAAE;aACX,OAAO,CACN,qEAAqE,CACtE,CAAC;QACJ,MAAM,iBAAiB,GAAG,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC;QAC/C,IAAI,CAAC,WAAW,CAAC,oBAAoB,CAAC;YACpC,GAAG,WAAW;YACd,MAAM;YACN,iBAAiB;SAClB,CAAC,CAAC;QACH,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;OAMG;IACK,oBAAoB,CAC1B,QAAgB,EAChB,UAAkB;QAElB,IAAI,CAAC,WAAW;aACb,SAAS,EAAE;aACX,OAAO,CAAC,2CAA2C,CAAC,CAAC;QAExD,oEAAoE;QACpE,MAAM,kBAAkB,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;QAE7D,MAAM,uBAAuB,GAAG,KAAK,CAAC,IAAI,CACxC,IAAI,CAAC,qBAAqB,CAAC,oBAAoB,CAAC,IAAI,EAAE,CACvD,CAAC;QAEF,MAAM,0BAA0B,GAAG,IAAI,CAAC,wBAAwB,CAC9D,uBAAuB,EACvB,kBAAkB,CACnB,CAAC;QAEF,oJAAoJ;QACpJ,IAAI,0BAA0B,CAAC,iBAAiB,CAAC,MAAM,GAAG,CAAC,EAAE;YAC3D,OAAO,IAAI,CAAC,qBAAqB,CAC/B,IAAI,CAAC,qBAAqB,CAAC,oBAAoB,EAC/C,0BAA0B,CAAC,iBAAiB,EAC5C,UAAU,CACX,CAAC;SACH;aAAM,IAAI,0BAA0B,CAAC,iBAAiB,CAAC,MAAM,GAAG,CAAC,EAAE;YAClE,OAAO,IAAI,CAAC,qBAAqB,CAC/B,IAAI,CAAC,qBAAqB,CAAC,oBAAoB,EAC/C,0BAA0B,CAAC,iBAAiB,EAC5C,UAAU,CACX,CAAC;SACH;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACK,wBAAwB,CAC9B,2BAAqC,EACrC,QAAgB;QAEhB,MAAM,iBAAiB,GAAsB;YAC3C,iBAAiB,EAAE,EAAE;YACrB,iBAAiB,EAAE,EAAE;SACtB,CAAC;QAEF,2BAA2B,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;YAC1C,+IAA+I;YAC/I,MAAM,aAAa,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;YACnD,IAAI,WAAW,CAAC,YAAY,CAAC,aAAa,EAAE,QAAQ,CAAC,EAAE;gBACrD,iBAAiB,CAAC,iBAAiB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;aAC/C;YAED,uCAAuC;YACvC,MAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;YAC7C,MAAM,aAAa,GAAG,IAAI,SAAS,CAAC,WAAW,CAAC,CAAC,gBAAgB,EAAE,CAAC;YACpE,MAAM,gBAAgB,GAAG,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;YACvD,MAAM,kBAAkB,GAAG,IAAI,SAAS,CACtC,gBAAgB,CACjB,CAAC,gBAAgB,EAAE,CAAC;YAErB,4DAA4D;YAC5D,MAAM,qBAAqB,GAAG,aAAa,CAAC,WAAW;gBACrD,CAAC,CAAC,GAAG,aAAa,CAAC,YAAY,IAAI,aAAa,CAAC,WAAW,EAAE;gBAC9D,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC;YAExD,qHAAqH;YACrH,IACE,aAAa,CAAC,eAAe,KAAK,kBAAkB,CAAC,eAAe;gBACpE,WAAW,CAAC,YAAY,CAAC,qBAAqB,EAAE,gBAAgB,CAAC;gBACjE,qBAAqB,KAAK,EAAE;gBAC5B,qBAAqB,KAAK,IAAI,EAC9B;gBACA,iBAAiB,CAAC,iBAAiB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;aAC/C;QACH,CAAC,CAAC,CAAC;QAEH,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IAED;;;;OAIG;IACK,cAAc,CAAC,GAAW;QAChC,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;QAC/C,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC;QAChB,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAED;;;;;;OAMG;IACK,qBAAqB,CAC3B,oBAGC,EACD,aAAuB,EACvB,UAAkB;QAElB,MAAM,gBAAgB,GAAG,EAAE,CAAC;QAE5B,iEAAiE;QACjE,aAAa,CAAC,OAAO,CAAC,CAAC,eAAe,EAAE,EAAE;YACxC,MAAM,iBAAiB,GAAG,EAAE,CAAC;YAC7B,MAAM,oBAAoB,GAAG,oBAAoB,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;YAEvE,oCAAoC;YACpC,IAAI,oBAAoB,KAAK,IAAI,EAAE;gBACjC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBAC5B,OAAO;aACR;YAED,oBAAoB,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;gBACrC,oEAAoE;gBACpE,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;oBAC7B,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;iBAC/B;qBAAM;oBACL,+CAA+C;oBAC/C,MAAM,uBAAuB,GAAG,UAAU,CAAC,WAAW,EAAE,CAAC;oBACzD,MAAM,wBAAwB,GAAG,KAAK,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC;oBAChE,6DAA6D;oBAC7D,IAAI,wBAAwB,KAAK,uBAAuB,EAAE;wBACxD,mFAAmF;wBACnF,IAAI,KAAK,CAAC,MAAM,KAAK,IAAI,EAAE;4BACzB,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;yBAC7B;6BAAM;4BACL,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;gCAC7B,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;4BAChC,CAAC,CAAC,CAAC;yBACJ;qBACF;iBACF;YACH,CAAC,CAAC,CAAC;YAEH,oEAAoE;YACpE,IAAI,iBAAiB,CAAC,MAAM,GAAG,CAAC,EAAE;gBAChC,gBAAgB,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;aAC1C;QACH,CAAC,CAAC,CAAC;QAEH,IAAI,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAAE;YAC/B,IAAI,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAAE;gBAC/B,IAAI,CAAC,WAAW;qBACb,SAAS,EAAE;qBACX,OAAO,CACN,+DAA+D,CAChE,CAAC;aACL;YACD,6CAA6C;YAC7C,OAAO,gBAAgB,CAAC,CAAC,CAAC,CAAC;SAC5B;QAED,OAAO,IAAI,CAAC;IACd,CAAC;;4GAjWU,eAAe,kBAIhB,uBAAuB,oGAMvB,QAAQ;gHAVP,eAAe;2FAAf,eAAe;kBAD3B,UAAU;;0BAKN,MAAM;2BAAC,uBAAuB;;0BAM9B,MAAM;2BAAC,QAAQ","sourcesContent":["/*\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { Injectable, Inject } from '@angular/core';\nimport { Location, DOCUMENT } from '@angular/common';\nimport {\n  HttpRequest,\n  HttpHandler,\n  HttpEvent,\n  HttpInterceptor,\n} from '@angular/common/http'; // eslint-disable-line import/no-unresolved\nimport {\n  AccountInfo,\n  AuthenticationResult,\n  BrowserConfigurationAuthError,\n  InteractionStatus,\n  InteractionType,\n  StringUtils,\n  UrlString,\n} from '@azure/msal-browser';\nimport { Observable, EMPTY, of } from 'rxjs';\nimport { switchMap, catchError, take, filter } from 'rxjs/operators';\nimport { MsalService } from './msal.service';\nimport {\n  MsalInterceptorAuthRequest,\n  MsalInterceptorConfiguration,\n  ProtectedResourceScopes,\n  MatchingResources,\n} from './msal.interceptor.config';\nimport { MsalBroadcastService } from './msal.broadcast.service';\nimport { MSAL_INTERCEPTOR_CONFIG } from './constants';\n\n@Injectable()\nexport class MsalInterceptor implements HttpInterceptor {\n  private _document?: Document;\n\n  constructor(\n    @Inject(MSAL_INTERCEPTOR_CONFIG)\n    private msalInterceptorConfig: MsalInterceptorConfiguration,\n    private authService: MsalService,\n    private location: Location,\n    private msalBroadcastService: MsalBroadcastService,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n    @Inject(DOCUMENT) document?: any\n  ) {\n    this._document = document as Document;\n  }\n\n  intercept(\n    req: HttpRequest<any>, // eslint-disable-line @typescript-eslint/no-explicit-any\n    next: HttpHandler\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ): Observable<HttpEvent<any>> {\n    if (\n      this.msalInterceptorConfig.interactionType !== InteractionType.Popup &&\n      this.msalInterceptorConfig.interactionType !== InteractionType.Redirect\n    ) {\n      throw new BrowserConfigurationAuthError(\n        'invalid_interaction_type',\n        'Invalid interaction type provided to MSAL Interceptor. InteractionType.Popup, InteractionType.Redirect must be provided in the msalInterceptorConfiguration'\n      );\n    }\n\n    this.authService.getLogger().verbose('MSAL Interceptor activated');\n    const scopes = this.getScopesForEndpoint(req.url, req.method);\n\n    // If no scopes for endpoint, does not acquire token\n    if (!scopes || scopes.length === 0) {\n      this.authService\n        .getLogger()\n        .verbose('Interceptor - no scopes for endpoint');\n      return next.handle(req);\n    }\n\n    // Sets account as active account or first account\n    let account: AccountInfo;\n    if (!!this.authService.instance.getActiveAccount()) {\n      this.authService\n        .getLogger()\n        .verbose('Interceptor - active account selected');\n      account = this.authService.instance.getActiveAccount();\n    } else {\n      this.authService\n        .getLogger()\n        .verbose('Interceptor - no active account, fallback to first account');\n      account = this.authService.instance.getAllAccounts()[0];\n    }\n\n    const authRequest =\n      typeof this.msalInterceptorConfig.authRequest === 'function'\n        ? this.msalInterceptorConfig.authRequest(this.authService, req, {\n            account: account,\n          })\n        : { ...this.msalInterceptorConfig.authRequest, account };\n\n    this.authService\n      .getLogger()\n      .info(`Interceptor - ${scopes.length} scopes found for endpoint`);\n    this.authService\n      .getLogger()\n      .infoPii(`Interceptor - [${scopes}] scopes found for ${req.url}`);\n\n    return this.acquireToken(authRequest, scopes, account).pipe(\n      switchMap((result: AuthenticationResult) => {\n        this.authService\n          .getLogger()\n          .verbose('Interceptor - setting authorization headers');\n        const headers = req.headers.set(\n          'Authorization',\n          `Bearer ${result.accessToken}`\n        );\n\n        const requestClone = req.clone({ headers });\n        return next.handle(requestClone);\n      })\n    );\n  }\n\n  /**\n   * Try to acquire token silently. Invoke interaction if acquireTokenSilent rejected with error or resolved with null access token\n   * @param authRequest Request\n   * @param scopes Array of scopes for the request\n   * @param account Account\n   * @returns Authentication result\n   */\n  private acquireToken(\n    authRequest: MsalInterceptorAuthRequest,\n    scopes: string[],\n    account: AccountInfo\n  ): Observable<AuthenticationResult> {\n    // Note: For MSA accounts, include openid scope when calling acquireTokenSilent to return idToken\n    return this.authService\n      .acquireTokenSilent({ ...authRequest, scopes, account })\n      .pipe(\n        catchError(() => {\n          this.authService\n            .getLogger()\n            .error(\n              'Interceptor - acquireTokenSilent rejected with error. Invoking interaction to resolve.'\n            );\n          return this.msalBroadcastService.inProgress$.pipe(\n            take(1),\n            switchMap((status: InteractionStatus) => {\n              if (status === InteractionStatus.None) {\n                return this.acquireTokenInteractively(authRequest, scopes);\n              }\n\n              return this.msalBroadcastService.inProgress$.pipe(\n                filter(\n                  (status: InteractionStatus) =>\n                    status === InteractionStatus.None\n                ),\n                take(1),\n                switchMap(() => this.acquireToken(authRequest, scopes, account))\n              );\n            })\n          );\n        }),\n        switchMap((result: AuthenticationResult) => {\n          if (!result.accessToken) {\n            this.authService\n              .getLogger()\n              .error(\n                'Interceptor - acquireTokenSilent resolved with null access token. Known issue with B2C tenants, invoking interaction to resolve.'\n              );\n            return this.msalBroadcastService.inProgress$.pipe(\n              filter(\n                (status: InteractionStatus) => status === InteractionStatus.None\n              ),\n              take(1),\n              switchMap(() =>\n                this.acquireTokenInteractively(authRequest, scopes)\n              )\n            );\n          }\n          return of(result);\n        })\n      );\n  }\n\n  /**\n   * Invoke interaction for the given set of scopes\n   * @param authRequest Request\n   * @param scopes Array of scopes for the request\n   * @returns Result from the interactive request\n   */\n  private acquireTokenInteractively(\n    authRequest: MsalInterceptorAuthRequest,\n    scopes: string[]\n  ): Observable<AuthenticationResult> {\n    if (this.msalInterceptorConfig.interactionType === InteractionType.Popup) {\n      this.authService\n        .getLogger()\n        .verbose(\n          'Interceptor - error acquiring token silently, acquiring by popup'\n        );\n      return this.authService.acquireTokenPopup({ ...authRequest, scopes });\n    }\n    this.authService\n      .getLogger()\n      .verbose(\n        'Interceptor - error acquiring token silently, acquiring by redirect'\n      );\n    const redirectStartPage = window.location.href;\n    this.authService.acquireTokenRedirect({\n      ...authRequest,\n      scopes,\n      redirectStartPage,\n    });\n    return EMPTY;\n  }\n\n  /**\n   * Looks up the scopes for the given endpoint from the protectedResourceMap\n   * @param endpoint Url of the request\n   * @param httpMethod Http method of the request\n   * @returns Array of scopes, or null if not found\n   *\n   */\n  private getScopesForEndpoint(\n    endpoint: string,\n    httpMethod: string\n  ): Array<string> | null {\n    this.authService\n      .getLogger()\n      .verbose('Interceptor - getting scopes for endpoint');\n\n    // Ensures endpoints and protected resources compared are normalized\n    const normalizedEndpoint = this.location.normalize(endpoint);\n\n    const protectedResourcesArray = Array.from(\n      this.msalInterceptorConfig.protectedResourceMap.keys()\n    );\n\n    const matchingProtectedResources = this.matchResourcesToEndpoint(\n      protectedResourcesArray,\n      normalizedEndpoint\n    );\n\n    // Check absolute urls of resources first before checking relative to prevent incorrect matching where multiple resources have similar relative urls\n    if (matchingProtectedResources.absoluteResources.length > 0) {\n      return this.matchScopesToEndpoint(\n        this.msalInterceptorConfig.protectedResourceMap,\n        matchingProtectedResources.absoluteResources,\n        httpMethod\n      );\n    } else if (matchingProtectedResources.relativeResources.length > 0) {\n      return this.matchScopesToEndpoint(\n        this.msalInterceptorConfig.protectedResourceMap,\n        matchingProtectedResources.relativeResources,\n        httpMethod\n      );\n    }\n\n    return null;\n  }\n\n  /**\n   * Finds resource endpoints that match request endpoint\n   * @param protectedResourcesEndpoints\n   * @param endpoint\n   * @returns\n   */\n  private matchResourcesToEndpoint(\n    protectedResourcesEndpoints: string[],\n    endpoint: string\n  ): MatchingResources {\n    const matchingResources: MatchingResources = {\n      absoluteResources: [],\n      relativeResources: [],\n    };\n\n    protectedResourcesEndpoints.forEach((key) => {\n      // Normalizes and adds resource to matchingResources.absoluteResources if key matches endpoint. StringUtils.matchPattern accounts for wildcards\n      const normalizedKey = this.location.normalize(key);\n      if (StringUtils.matchPattern(normalizedKey, endpoint)) {\n        matchingResources.absoluteResources.push(key);\n      }\n\n      // Get url components for relative urls\n      const absoluteKey = this.getAbsoluteUrl(key);\n      const keyComponents = new UrlString(absoluteKey).getUrlComponents();\n      const absoluteEndpoint = this.getAbsoluteUrl(endpoint);\n      const endpointComponents = new UrlString(\n        absoluteEndpoint\n      ).getUrlComponents();\n\n      // Normalized key should include query strings if applicable\n      const relativeNormalizedKey = keyComponents.QueryString\n        ? `${keyComponents.AbsolutePath}?${keyComponents.QueryString}`\n        : this.location.normalize(keyComponents.AbsolutePath);\n\n      // Add resource to matchingResources.relativeResources if same origin, relativeKey matches endpoint, and is not empty\n      if (\n        keyComponents.HostNameAndPort === endpointComponents.HostNameAndPort &&\n        StringUtils.matchPattern(relativeNormalizedKey, absoluteEndpoint) &&\n        relativeNormalizedKey !== '' &&\n        relativeNormalizedKey !== '/*'\n      ) {\n        matchingResources.relativeResources.push(key);\n      }\n    });\n\n    return matchingResources;\n  }\n\n  /**\n   * Transforms relative urls to absolute urls\n   * @param url\n   * @returns\n   */\n  private getAbsoluteUrl(url: string): string {\n    const link = this._document.createElement('a');\n    link.href = url;\n    return link.href;\n  }\n\n  /**\n   * Finds scopes from first matching endpoint with HTTP method that matches request\n   * @param protectedResourceMap Protected resource map\n   * @param endpointArray Array of resources that match request endpoint\n   * @param httpMethod Http method of the request\n   * @returns\n   */\n  private matchScopesToEndpoint(\n    protectedResourceMap: Map<\n      string,\n      Array<string | ProtectedResourceScopes> | null\n    >,\n    endpointArray: string[],\n    httpMethod: string\n  ): Array<string> | null {\n    const allMatchedScopes = [];\n\n    // Check each matched endpoint for matching HttpMethod and scopes\n    endpointArray.forEach((matchedEndpoint) => {\n      const scopesForEndpoint = [];\n      const methodAndScopesArray = protectedResourceMap.get(matchedEndpoint);\n\n      // Return if resource is unprotected\n      if (methodAndScopesArray === null) {\n        allMatchedScopes.push(null);\n        return;\n      }\n\n      methodAndScopesArray.forEach((entry) => {\n        // Entry is either array of scopes or ProtectedResourceScopes object\n        if (typeof entry === 'string') {\n          scopesForEndpoint.push(entry);\n        } else {\n          // Ensure methods being compared are normalized\n          const normalizedRequestMethod = httpMethod.toLowerCase();\n          const normalizedResourceMethod = entry.httpMethod.toLowerCase();\n          // Method in protectedResourceMap matches request http method\n          if (normalizedResourceMethod === normalizedRequestMethod) {\n            // Validate if scopes comes null to unprotect the resource in a certain http method\n            if (entry.scopes === null) {\n              allMatchedScopes.push(null);\n            } else {\n              entry.scopes.forEach((scope) => {\n                scopesForEndpoint.push(scope);\n              });\n            }\n          }\n        }\n      });\n\n      // Only add to all scopes if scopes for endpoint and method is found\n      if (scopesForEndpoint.length > 0) {\n        allMatchedScopes.push(scopesForEndpoint);\n      }\n    });\n\n    if (allMatchedScopes.length > 0) {\n      if (allMatchedScopes.length > 1) {\n        this.authService\n          .getLogger()\n          .warning(\n            'Interceptor - More than 1 matching scopes for endpoint found.'\n          );\n      }\n      // Returns scopes for first matching endpoint\n      return allMatchedScopes[0];\n    }\n\n    return null;\n  }\n}\n"]}