@azure/msal-angular 2.5.7 → 3.0.0-alpha.0

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.7", 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.7", ngImport: i0, type: MsalInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", 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":"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","sourcesContent":["/*\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\r\n\r\nimport { Injectable, Inject } from '@angular/core';\r\nimport { Location, DOCUMENT } from '@angular/common';\r\nimport {\r\n  HttpRequest,\r\n  HttpHandler,\r\n  HttpEvent,\r\n  HttpInterceptor,\r\n} from '@angular/common/http'; // eslint-disable-line import/no-unresolved\r\nimport {\r\n  AccountInfo,\r\n  AuthenticationResult,\r\n  BrowserConfigurationAuthError,\r\n  InteractionStatus,\r\n  InteractionType,\r\n  StringUtils,\r\n  UrlString,\r\n} from '@azure/msal-browser';\r\nimport { Observable, EMPTY, of } from 'rxjs';\r\nimport { switchMap, catchError, take, filter } from 'rxjs/operators';\r\nimport { MsalService } from './msal.service';\r\nimport {\r\n  MsalInterceptorAuthRequest,\r\n  MsalInterceptorConfiguration,\r\n  ProtectedResourceScopes,\r\n  MatchingResources,\r\n} from './msal.interceptor.config';\r\nimport { MsalBroadcastService } from './msal.broadcast.service';\r\nimport { MSAL_INTERCEPTOR_CONFIG } from './constants';\r\n\r\n@Injectable()\r\nexport class MsalInterceptor implements HttpInterceptor {\r\n  private _document?: Document;\r\n\r\n  constructor(\r\n    @Inject(MSAL_INTERCEPTOR_CONFIG)\r\n    private msalInterceptorConfig: MsalInterceptorConfiguration,\r\n    private authService: MsalService,\r\n    private location: Location,\r\n    private msalBroadcastService: MsalBroadcastService,\r\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\r\n    @Inject(DOCUMENT) document?: any\r\n  ) {\r\n    this._document = document as Document;\r\n  }\r\n\r\n  intercept(\r\n    req: HttpRequest<any>, // eslint-disable-line @typescript-eslint/no-explicit-any\r\n    next: HttpHandler\r\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n  ): Observable<HttpEvent<any>> {\r\n    if (\r\n      this.msalInterceptorConfig.interactionType !== InteractionType.Popup &&\r\n      this.msalInterceptorConfig.interactionType !== InteractionType.Redirect\r\n    ) {\r\n      throw new BrowserConfigurationAuthError(\r\n        'invalid_interaction_type',\r\n        'Invalid interaction type provided to MSAL Interceptor. InteractionType.Popup, InteractionType.Redirect must be provided in the msalInterceptorConfiguration'\r\n      );\r\n    }\r\n\r\n    this.authService.getLogger().verbose('MSAL Interceptor activated');\r\n    const scopes = this.getScopesForEndpoint(req.url, req.method);\r\n\r\n    // If no scopes for endpoint, does not acquire token\r\n    if (!scopes || scopes.length === 0) {\r\n      this.authService\r\n        .getLogger()\r\n        .verbose('Interceptor - no scopes for endpoint');\r\n      return next.handle(req);\r\n    }\r\n\r\n    // Sets account as active account or first account\r\n    let account: AccountInfo;\r\n    if (!!this.authService.instance.getActiveAccount()) {\r\n      this.authService\r\n        .getLogger()\r\n        .verbose('Interceptor - active account selected');\r\n      account = this.authService.instance.getActiveAccount();\r\n    } else {\r\n      this.authService\r\n        .getLogger()\r\n        .verbose('Interceptor - no active account, fallback to first account');\r\n      account = this.authService.instance.getAllAccounts()[0];\r\n    }\r\n\r\n    const authRequest =\r\n      typeof this.msalInterceptorConfig.authRequest === 'function'\r\n        ? this.msalInterceptorConfig.authRequest(this.authService, req, {\r\n            account: account,\r\n          })\r\n        : { ...this.msalInterceptorConfig.authRequest, account };\r\n\r\n    this.authService\r\n      .getLogger()\r\n      .info(`Interceptor - ${scopes.length} scopes found for endpoint`);\r\n    this.authService\r\n      .getLogger()\r\n      .infoPii(`Interceptor - [${scopes}] scopes found for ${req.url}`);\r\n\r\n    return this.acquireToken(authRequest, scopes, account).pipe(\r\n      switchMap((result: AuthenticationResult) => {\r\n        this.authService\r\n          .getLogger()\r\n          .verbose('Interceptor - setting authorization headers');\r\n        const headers = req.headers.set(\r\n          'Authorization',\r\n          `Bearer ${result.accessToken}`\r\n        );\r\n\r\n        const requestClone = req.clone({ headers });\r\n        return next.handle(requestClone);\r\n      })\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Try to acquire token silently. Invoke interaction if acquireTokenSilent rejected with error or resolved with null access token\r\n   * @param authRequest Request\r\n   * @param scopes Array of scopes for the request\r\n   * @param account Account\r\n   * @returns Authentication result\r\n   */\r\n  private acquireToken(\r\n    authRequest: MsalInterceptorAuthRequest,\r\n    scopes: string[],\r\n    account: AccountInfo\r\n  ): Observable<AuthenticationResult> {\r\n    // Note: For MSA accounts, include openid scope when calling acquireTokenSilent to return idToken\r\n    return this.authService\r\n      .acquireTokenSilent({ ...authRequest, scopes, account })\r\n      .pipe(\r\n        catchError(() => {\r\n          this.authService\r\n            .getLogger()\r\n            .error(\r\n              'Interceptor - acquireTokenSilent rejected with error. Invoking interaction to resolve.'\r\n            );\r\n          return this.msalBroadcastService.inProgress$.pipe(\r\n            take(1),\r\n            switchMap((status: InteractionStatus) => {\r\n              if (status === InteractionStatus.None) {\r\n                return this.acquireTokenInteractively(authRequest, scopes);\r\n              }\r\n\r\n              return this.msalBroadcastService.inProgress$.pipe(\r\n                filter(\r\n                  (status: InteractionStatus) =>\r\n                    status === InteractionStatus.None\r\n                ),\r\n                take(1),\r\n                switchMap(() => this.acquireToken(authRequest, scopes, account))\r\n              );\r\n            })\r\n          );\r\n        }),\r\n        switchMap((result: AuthenticationResult) => {\r\n          if (!result.accessToken) {\r\n            this.authService\r\n              .getLogger()\r\n              .error(\r\n                'Interceptor - acquireTokenSilent resolved with null access token. Known issue with B2C tenants, invoking interaction to resolve.'\r\n              );\r\n            return this.msalBroadcastService.inProgress$.pipe(\r\n              filter(\r\n                (status: InteractionStatus) => status === InteractionStatus.None\r\n              ),\r\n              take(1),\r\n              switchMap(() =>\r\n                this.acquireTokenInteractively(authRequest, scopes)\r\n              )\r\n            );\r\n          }\r\n          return of(result);\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Invoke interaction for the given set of scopes\r\n   * @param authRequest Request\r\n   * @param scopes Array of scopes for the request\r\n   * @returns Result from the interactive request\r\n   */\r\n  private acquireTokenInteractively(\r\n    authRequest: MsalInterceptorAuthRequest,\r\n    scopes: string[]\r\n  ): Observable<AuthenticationResult> {\r\n    if (this.msalInterceptorConfig.interactionType === InteractionType.Popup) {\r\n      this.authService\r\n        .getLogger()\r\n        .verbose(\r\n          'Interceptor - error acquiring token silently, acquiring by popup'\r\n        );\r\n      return this.authService.acquireTokenPopup({ ...authRequest, scopes });\r\n    }\r\n    this.authService\r\n      .getLogger()\r\n      .verbose(\r\n        'Interceptor - error acquiring token silently, acquiring by redirect'\r\n      );\r\n    const redirectStartPage = window.location.href;\r\n    this.authService.acquireTokenRedirect({\r\n      ...authRequest,\r\n      scopes,\r\n      redirectStartPage,\r\n    });\r\n    return EMPTY;\r\n  }\r\n\r\n  /**\r\n   * Looks up the scopes for the given endpoint from the protectedResourceMap\r\n   * @param endpoint Url of the request\r\n   * @param httpMethod Http method of the request\r\n   * @returns Array of scopes, or null if not found\r\n   *\r\n   */\r\n  private getScopesForEndpoint(\r\n    endpoint: string,\r\n    httpMethod: string\r\n  ): Array<string> | null {\r\n    this.authService\r\n      .getLogger()\r\n      .verbose('Interceptor - getting scopes for endpoint');\r\n\r\n    // Ensures endpoints and protected resources compared are normalized\r\n    const normalizedEndpoint = this.location.normalize(endpoint);\r\n\r\n    const protectedResourcesArray = Array.from(\r\n      this.msalInterceptorConfig.protectedResourceMap.keys()\r\n    );\r\n\r\n    const matchingProtectedResources = this.matchResourcesToEndpoint(\r\n      protectedResourcesArray,\r\n      normalizedEndpoint\r\n    );\r\n\r\n    // Check absolute urls of resources first before checking relative to prevent incorrect matching where multiple resources have similar relative urls\r\n    if (matchingProtectedResources.absoluteResources.length > 0) {\r\n      return this.matchScopesToEndpoint(\r\n        this.msalInterceptorConfig.protectedResourceMap,\r\n        matchingProtectedResources.absoluteResources,\r\n        httpMethod\r\n      );\r\n    } else if (matchingProtectedResources.relativeResources.length > 0) {\r\n      return this.matchScopesToEndpoint(\r\n        this.msalInterceptorConfig.protectedResourceMap,\r\n        matchingProtectedResources.relativeResources,\r\n        httpMethod\r\n      );\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Finds resource endpoints that match request endpoint\r\n   * @param protectedResourcesEndpoints\r\n   * @param endpoint\r\n   * @returns\r\n   */\r\n  private matchResourcesToEndpoint(\r\n    protectedResourcesEndpoints: string[],\r\n    endpoint: string\r\n  ): MatchingResources {\r\n    const matchingResources: MatchingResources = {\r\n      absoluteResources: [],\r\n      relativeResources: [],\r\n    };\r\n\r\n    protectedResourcesEndpoints.forEach((key) => {\r\n      // Normalizes and adds resource to matchingResources.absoluteResources if key matches endpoint. StringUtils.matchPattern accounts for wildcards\r\n      const normalizedKey = this.location.normalize(key);\r\n      if (StringUtils.matchPattern(normalizedKey, endpoint)) {\r\n        matchingResources.absoluteResources.push(key);\r\n      }\r\n\r\n      // Get url components for relative urls\r\n      const absoluteKey = this.getAbsoluteUrl(key);\r\n      const keyComponents = new UrlString(absoluteKey).getUrlComponents();\r\n      const absoluteEndpoint = this.getAbsoluteUrl(endpoint);\r\n      const endpointComponents = new UrlString(\r\n        absoluteEndpoint\r\n      ).getUrlComponents();\r\n\r\n      // Normalized key should include query strings if applicable\r\n      const relativeNormalizedKey = keyComponents.QueryString\r\n        ? `${keyComponents.AbsolutePath}?${keyComponents.QueryString}`\r\n        : this.location.normalize(keyComponents.AbsolutePath);\r\n\r\n      // Add resource to matchingResources.relativeResources if same origin, relativeKey matches endpoint, and is not empty\r\n      if (\r\n        keyComponents.HostNameAndPort === endpointComponents.HostNameAndPort &&\r\n        StringUtils.matchPattern(relativeNormalizedKey, absoluteEndpoint) &&\r\n        relativeNormalizedKey !== '' &&\r\n        relativeNormalizedKey !== '/*'\r\n      ) {\r\n        matchingResources.relativeResources.push(key);\r\n      }\r\n    });\r\n\r\n    return matchingResources;\r\n  }\r\n\r\n  /**\r\n   * Transforms relative urls to absolute urls\r\n   * @param url\r\n   * @returns\r\n   */\r\n  private getAbsoluteUrl(url: string): string {\r\n    const link = this._document.createElement('a');\r\n    link.href = url;\r\n    return link.href;\r\n  }\r\n\r\n  /**\r\n   * Finds scopes from first matching endpoint with HTTP method that matches request\r\n   * @param protectedResourceMap Protected resource map\r\n   * @param endpointArray Array of resources that match request endpoint\r\n   * @param httpMethod Http method of the request\r\n   * @returns\r\n   */\r\n  private matchScopesToEndpoint(\r\n    protectedResourceMap: Map<\r\n      string,\r\n      Array<string | ProtectedResourceScopes> | null\r\n    >,\r\n    endpointArray: string[],\r\n    httpMethod: string\r\n  ): Array<string> | null {\r\n    const allMatchedScopes = [];\r\n\r\n    // Check each matched endpoint for matching HttpMethod and scopes\r\n    endpointArray.forEach((matchedEndpoint) => {\r\n      const scopesForEndpoint = [];\r\n      const methodAndScopesArray = protectedResourceMap.get(matchedEndpoint);\r\n\r\n      // Return if resource is unprotected\r\n      if (methodAndScopesArray === null) {\r\n        allMatchedScopes.push(null);\r\n        return;\r\n      }\r\n\r\n      methodAndScopesArray.forEach((entry) => {\r\n        // Entry is either array of scopes or ProtectedResourceScopes object\r\n        if (typeof entry === 'string') {\r\n          scopesForEndpoint.push(entry);\r\n        } else {\r\n          // Ensure methods being compared are normalized\r\n          const normalizedRequestMethod = httpMethod.toLowerCase();\r\n          const normalizedResourceMethod = entry.httpMethod.toLowerCase();\r\n          // Method in protectedResourceMap matches request http method\r\n          if (normalizedResourceMethod === normalizedRequestMethod) {\r\n            // Validate if scopes comes null to unprotect the resource in a certain http method\r\n            if (entry.scopes === null) {\r\n              allMatchedScopes.push(null);\r\n            } else {\r\n              entry.scopes.forEach((scope) => {\r\n                scopesForEndpoint.push(scope);\r\n              });\r\n            }\r\n          }\r\n        }\r\n      });\r\n\r\n      // Only add to all scopes if scopes for endpoint and method is found\r\n      if (scopesForEndpoint.length > 0) {\r\n        allMatchedScopes.push(scopesForEndpoint);\r\n      }\r\n    });\r\n\r\n    if (allMatchedScopes.length > 0) {\r\n      if (allMatchedScopes.length > 1) {\r\n        this.authService\r\n          .getLogger()\r\n          .warning(\r\n            'Interceptor - More than 1 matching scopes for endpoint found.'\r\n          );\r\n      }\r\n      // Returns scopes for first matching endpoint\r\n      return allMatchedScopes[0];\r\n    }\r\n\r\n    return null;\r\n  }\r\n}\r\n"]}

package/esm2020/msal.module.mjs

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { MsalBroadcastService } from './msal.broadcast.service';
+import { MsalGuard } from './msal.guard';
+import { MsalRedirectComponent } from './msal.redirect.component';
+import { MsalService } from './msal.service';
+import { MSAL_INSTANCE, MSAL_GUARD_CONFIG, MSAL_INTERCEPTOR_CONFIG, } from './constants';
+import * as i0 from "@angular/core";
+export class MsalModule {
+    static forRoot(msalInstance, guardConfig, interceptorConfig) {
+        return {
+            ngModule: MsalModule,
+            providers: [
+                {
+                    provide: MSAL_INSTANCE,
+                    useValue: msalInstance,
+                },
+                {
+                    provide: MSAL_GUARD_CONFIG,
+                    useValue: guardConfig,
+                },
+                {
+                    provide: MSAL_INTERCEPTOR_CONFIG,
+                    useValue: interceptorConfig,
+                },
+                MsalService,
+            ],
+        };
+    }
+}
+MsalModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: MsalModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+MsalModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.7", ngImport: i0, type: MsalModule, declarations: [MsalRedirectComponent], imports: [CommonModule] });
+MsalModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: MsalModule, providers: [MsalGuard, MsalBroadcastService], imports: [CommonModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: MsalModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [MsalRedirectComponent],
+                    imports: [CommonModule],
+                    providers: [MsalGuard, MsalBroadcastService],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/msal.navigation.client.mjs

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { Injectable } from '@angular/core';
+import { NavigationClient, UrlString, } from '@azure/msal-browser';
+import * as i0 from "@angular/core";
+import * as i1 from "./msal.service";
+import * as i2 from "@angular/router";
+import * as i3 from "@angular/common";
+/**
+ * Custom navigation used for Angular client-side navigation.
+ * See performance doc for details:
+ * https://github.com/AzureAD/microsoft-authentication-library-for-js/tree/dev/lib/msal-angular/docs/v2-docs/performance.md
+ */
+export class MsalCustomNavigationClient extends NavigationClient {
+    constructor(authService, router, location) {
+        super();
+        this.authService = authService;
+        this.router = router;
+        this.location = location;
+    }
+    async navigateInternal(url, options) {
+        this.authService.getLogger().trace('MsalCustomNavigationClient called');
+        this.authService
+            .getLogger()
+            .verbose('MsalCustomNavigationClient - navigating');
+        this.authService
+            .getLogger()
+            .verbosePii(`MsalCustomNavigationClient - navigating to url: ${url}`);
+        // Prevent hash clearing from causing an issue with Client-side navigation after redirect is handled
+        if (options.noHistory) {
+            return super.navigateInternal(url, options);
+        }
+        else {
+            // Normalizing newUrl if no query string
+            const urlComponents = new UrlString(url).getUrlComponents();
+            const newUrl = urlComponents.QueryString
+                ? `${urlComponents.AbsolutePath}?${urlComponents.QueryString}`
+                : this.location.normalize(urlComponents.AbsolutePath);
+            this.router.navigateByUrl(newUrl, { replaceUrl: options.noHistory });
+        }
+        return Promise.resolve(options.noHistory);
+    }
+}
+MsalCustomNavigationClient.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: MsalCustomNavigationClient, deps: [{ token: i1.MsalService }, { token: i2.Router }, { token: i3.Location }], target: i0.ɵɵFactoryTarget.Injectable });
+MsalCustomNavigationClient.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: MsalCustomNavigationClient });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: MsalCustomNavigationClient, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.MsalService }, { type: i2.Router }, { type: i3.Location }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/msal.redirect.component.mjs

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * This is a dedicated redirect component to be added to Angular apps to
+ * handle redirects when using @azure/msal-angular.
+ * Import this component to use redirects in your app.
+ */
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./msal.service";
+export class MsalRedirectComponent {
+    constructor(authService) {
+        this.authService = authService;
+    }
+    ngOnInit() {
+        this.authService.getLogger().verbose('MsalRedirectComponent activated');
+        this.authService.handleRedirectObservable().subscribe();
+    }
+}
+MsalRedirectComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: MsalRedirectComponent, deps: [{ token: i1.MsalService }], target: i0.ɵɵFactoryTarget.Component });
+MsalRedirectComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.7", type: MsalRedirectComponent, selector: "app-redirect", ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: MsalRedirectComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-redirect',
+                    template: '',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MsalService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXNhbC5yZWRpcmVjdC5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbXNhbC5yZWRpcmVjdC5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBRUg7Ozs7R0FJRztBQUVILE9BQU8sRUFBRSxTQUFTLEVBQVUsTUFBTSxlQUFlLENBQUM7OztBQU9sRCxNQUFNLE9BQU8scUJBQXFCO0lBQ2hDLFlBQW9CLFdBQXdCO1FBQXhCLGdCQUFXLEdBQVgsV0FBVyxDQUFhO0lBQUcsQ0FBQztJQUVoRCxRQUFRO1FBQ04sSUFBSSxDQUFDLFdBQVcsQ0FBQyxTQUFTLEVBQUUsQ0FBQyxPQUFPLENBQUMsaUNBQWlDLENBQUMsQ0FBQztRQUN4RSxJQUFJLENBQUMsV0FBVyxDQUFDLHdCQUF3QixFQUFFLENBQUMsU0FBUyxFQUFFLENBQUM7SUFDMUQsQ0FBQzs7a0hBTlUscUJBQXFCO3NHQUFyQixxQkFBcUIsb0RBRnRCLEVBQUU7MkZBRUQscUJBQXFCO2tCQUpqQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxjQUFjO29CQUN4QixRQUFRLEVBQUUsRUFBRTtpQkFDYiIsInNvdXJjZXNDb250ZW50IjpbIi8qXHJcbiAqIENvcHlyaWdodCAoYykgTWljcm9zb2Z0IENvcnBvcmF0aW9uLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxyXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgTUlUIExpY2Vuc2UuXHJcbiAqL1xyXG5cclxuLyoqXHJcbiAqIFRoaXMgaXMgYSBkZWRpY2F0ZWQgcmVkaXJlY3QgY29tcG9uZW50IHRvIGJlIGFkZGVkIHRvIEFuZ3VsYXIgYXBwcyB0b1xyXG4gKiBoYW5kbGUgcmVkaXJlY3RzIHdoZW4gdXNpbmcgQGF6dXJlL21zYWwtYW5ndWxhci5cclxuICogSW1wb3J0IHRoaXMgY29tcG9uZW50IHRvIHVzZSByZWRpcmVjdHMgaW4geW91ciBhcHAuXHJcbiAqL1xyXG5cclxuaW1wb3J0IHsgQ29tcG9uZW50LCBPbkluaXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgTXNhbFNlcnZpY2UgfSBmcm9tICcuL21zYWwuc2VydmljZSc7XHJcblxyXG5AQ29tcG9uZW50KHtcclxuICBzZWxlY3RvcjogJ2FwcC1yZWRpcmVjdCcsXHJcbiAgdGVtcGxhdGU6ICcnLFxyXG59KVxyXG5leHBvcnQgY2xhc3MgTXNhbFJlZGlyZWN0Q29tcG9uZW50IGltcGxlbWVudHMgT25Jbml0IHtcclxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIGF1dGhTZXJ2aWNlOiBNc2FsU2VydmljZSkge31cclxuXHJcbiAgbmdPbkluaXQoKTogdm9pZCB7XHJcbiAgICB0aGlzLmF1dGhTZXJ2aWNlLmdldExvZ2dlcigpLnZlcmJvc2UoJ01zYWxSZWRpcmVjdENvbXBvbmVudCBhY3RpdmF0ZWQnKTtcclxuICAgIHRoaXMuYXV0aFNlcnZpY2UuaGFuZGxlUmVkaXJlY3RPYnNlcnZhYmxlKCkuc3Vic2NyaWJlKCk7XHJcbiAgfVxyXG59XHJcbiJdfQ==

package/esm2020/msal.service.mjs

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { Inject, Injectable } from '@angular/core';
+import { WrapperSKU, } from '@azure/msal-browser';
+import { from } from 'rxjs';
+import { name, version } from './packageMetadata';
+import { MSAL_INSTANCE } from './constants';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class MsalService {
+    constructor(instance, location) {
+        this.instance = instance;
+        this.location = location;
+        const hash = this.location.path(true).split('#').pop();
+        if (hash) {
+            this.redirectHash = `#${hash}`;
+        }
+        this.instance.initializeWrapperLibrary(WrapperSKU.Angular, version);
+    }
+    initialize() {
+        return from(this.instance.initialize());
+    }
+    acquireTokenPopup(request) {
+        return from(this.instance.acquireTokenPopup(request));
+    }
+    acquireTokenRedirect(request) {
+        return from(this.instance.acquireTokenRedirect(request));
+    }
+    acquireTokenSilent(silentRequest) {
+        return from(this.instance.acquireTokenSilent(silentRequest));
+    }
+    handleRedirectObservable(hash) {
+        return from(this.instance
+            .initialize()
+            .then(() => this.instance.handleRedirectPromise(hash || this.redirectHash)));
+    }
+    loginPopup(request) {
+        return from(this.instance.loginPopup(request));
+    }
+    loginRedirect(request) {
+        return from(this.instance.loginRedirect(request));
+    }
+    logout(logoutRequest) {
+        return from(this.instance.logout(logoutRequest));
+    }
+    logoutRedirect(logoutRequest) {
+        return from(this.instance.logoutRedirect(logoutRequest));
+    }
+    logoutPopup(logoutRequest) {
+        return from(this.instance.logoutPopup(logoutRequest));
+    }
+    ssoSilent(request) {
+        return from(this.instance.ssoSilent(request));
+    }
+    /**
+     * Gets logger for msal-angular.
+     * If no logger set, returns logger instance created with same options as msal-browser
+     */
+    getLogger() {
+        if (!this.logger) {
+            this.logger = this.instance.getLogger().clone(name, version);
+        }
+        return this.logger;
+    }
+    // Create a logger instance for msal-angular with the same options as msal-browser
+    setLogger(logger) {
+        this.logger = logger.clone(name, version);
+        this.instance.setLogger(logger);
+    }
+}
+MsalService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: MsalService, deps: [{ token: MSAL_INSTANCE }, { token: i1.Location }], target: i0.ɵɵFactoryTarget.Injectable });
+MsalService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: MsalService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: MsalService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MSAL_INSTANCE]
+                }] }, { type: i1.Location }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXNhbC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL21zYWwuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCxPQUFPLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUVuRCxPQUFPLEVBVUwsVUFBVSxHQUNYLE1BQU0scUJBQXFCLENBQUM7QUFDN0IsT0FBTyxFQUFjLElBQUksRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUV4QyxPQUFPLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ2xELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxhQUFhLENBQUM7OztBQUc1QyxNQUFNLE9BQU8sV0FBVztJQUl0QixZQUNnQyxRQUFrQyxFQUN4RCxRQUFrQjtRQURJLGFBQVEsR0FBUixRQUFRLENBQTBCO1FBQ3hELGFBQVEsR0FBUixRQUFRLENBQVU7UUFFMUIsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEdBQUcsRUFBRSxDQUFDO1FBQ3ZELElBQUksSUFBSSxFQUFFO1lBQ1IsSUFBSSxDQUFDLFlBQVksR0FBRyxJQUFJLElBQUksRUFBRSxDQUFDO1NBQ2hDO1FBQ0QsSUFBSSxDQUFDLFFBQVEsQ0FBQyx3QkFBd0IsQ0FBQyxVQUFVLENBQUMsT0FBTyxFQUFFLE9BQU8sQ0FBQyxDQUFDO0lBQ3RFLENBQUM7SUFFRCxVQUFVO1FBQ1IsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxVQUFVLEVBQUUsQ0FBQyxDQUFDO0lBQzFDLENBQUM7SUFDRCxpQkFBaUIsQ0FBQyxPQUFxQjtRQUNyQyxPQUFPLElBQUksQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLGlCQUFpQixDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUM7SUFDeEQsQ0FBQztJQUNELG9CQUFvQixDQUFDLE9BQXdCO1FBQzNDLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsb0JBQW9CLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQztJQUMzRCxDQUFDO0lBQ0Qsa0JBQWtCLENBQ2hCLGFBQTRCO1FBRTVCLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsa0JBQWtCLENBQUMsYUFBYSxDQUFDLENBQUMsQ0FBQztJQUMvRCxDQUFDO0lBQ0Qsd0JBQXdCLENBQUMsSUFBYTtRQUNwQyxPQUFPLElBQUksQ0FDVCxJQUFJLENBQUMsUUFBUTthQUNWLFVBQVUsRUFBRTthQUNaLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FDVCxJQUFJLENBQUMsUUFBUSxDQUFDLHFCQUFxQixDQUFDLElBQUksSUFBSSxJQUFJLENBQUMsWUFBWSxDQUFDLENBQy9ELENBQ0osQ0FBQztJQUNKLENBQUM7SUFDRCxVQUFVLENBQUMsT0FBc0I7UUFDL0IsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxVQUFVLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQztJQUNqRCxDQUFDO0lBQ0QsYUFBYSxDQUFDLE9BQXlCO1FBQ3JDLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsYUFBYSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUM7SUFDcEQsQ0FBQztJQUNELE1BQU0sQ0FBQyxhQUFpQztRQUN0QyxPQUFPLElBQUksQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxhQUFhLENBQUMsQ0FBQyxDQUFDO0lBQ25ELENBQUM7SUFDRCxjQUFjLENBQUMsYUFBaUM7UUFDOUMsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxjQUFjLENBQUMsYUFBYSxDQUFDLENBQUMsQ0FBQztJQUMzRCxDQUFDO0lBQ0QsV0FBVyxDQUFDLGFBQXNDO1FBQ2hELE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsV0FBVyxDQUFDLGFBQWEsQ0FBQyxDQUFDLENBQUM7SUFDeEQsQ0FBQztJQUNELFNBQVMsQ0FBQyxPQUF5QjtRQUNqQyxPQUFPLElBQUksQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDO0lBQ2hELENBQUM7SUFDRDs7O09BR0c7SUFDSCxTQUFTO1FBQ1AsSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUU7WUFDaEIsSUFBSSxDQUFDLE1BQU0sR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFDLFNBQVMsRUFBRSxDQUFDLEtBQUssQ0FBQyxJQUFJLEVBQUUsT0FBTyxDQUFDLENBQUM7U0FDOUQ7UUFDRCxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUM7SUFDckIsQ0FBQztJQUNELGtGQUFrRjtJQUNsRixTQUFTLENBQUMsTUFBYztRQUN0QixJQUFJLENBQUMsTUFBTSxHQUFHLE1BQU0sQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLE9BQU8sQ0FBQyxDQUFDO1FBQzFDLElBQUksQ0FBQyxRQUFRLENBQUMsU0FBUyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ2xDLENBQUM7O3dHQXRFVSxXQUFXLGtCQUtaLGFBQWE7NEdBTFosV0FBVzsyRkFBWCxXQUFXO2tCQUR2QixVQUFVOzswQkFNTixNQUFNOzJCQUFDLGFBQWEiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxyXG4gKiBDb3B5cmlnaHQgKGMpIE1pY3Jvc29mdCBDb3Jwb3JhdGlvbi4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cclxuICogTGljZW5zZWQgdW5kZXIgdGhlIE1JVCBMaWNlbnNlLlxyXG4gKi9cclxuXHJcbmltcG9ydCB7IEluamVjdCwgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBMb2NhdGlvbiB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XHJcbmltcG9ydCB7XHJcbiAgSVB1YmxpY0NsaWVudEFwcGxpY2F0aW9uLFxyXG4gIEVuZFNlc3Npb25SZXF1ZXN0LFxyXG4gIEVuZFNlc3Npb25Qb3B1cFJlcXVlc3QsXHJcbiAgQXV0aGVudGljYXRpb25SZXN1bHQsXHJcbiAgUmVkaXJlY3RSZXF1ZXN0LFxyXG4gIFNpbGVudFJlcXVlc3QsXHJcbiAgUG9wdXBSZXF1ZXN0LFxyXG4gIFNzb1NpbGVudFJlcXVlc3QsXHJcbiAgTG9nZ2VyLFxyXG4gIFdyYXBwZXJTS1UsXHJcbn0gZnJvbSAnQGF6dXJlL21zYWwtYnJvd3Nlcic7XHJcbmltcG9ydCB7IE9ic2VydmFibGUsIGZyb20gfSBmcm9tICdyeGpzJztcclxuaW1wb3J0IHsgSU1zYWxTZXJ2aWNlIH0gZnJvbSAnLi9JTXNhbFNlcnZpY2UnO1xyXG5pbXBvcnQgeyBuYW1lLCB2ZXJzaW9uIH0gZnJvbSAnLi9wYWNrYWdlTWV0YWRhdGEnO1xyXG5pbXBvcnQgeyBNU0FMX0lOU1RBTkNFIH0gZnJvbSAnLi9jb25zdGFudHMnO1xyXG5cclxuQEluamVjdGFibGUoKVxyXG5leHBvcnQgY2xhc3MgTXNhbFNlcnZpY2UgaW1wbGVtZW50cyBJTXNhbFNlcnZpY2Uge1xyXG4gIHByaXZhdGUgcmVkaXJlY3RIYXNoOiBzdHJpbmc7XHJcbiAgcHJpdmF0ZSBsb2dnZXI6IExvZ2dlcjtcclxuXHJcbiAgY29uc3RydWN0b3IoXHJcbiAgICBASW5qZWN0KE1TQUxfSU5TVEFOQ0UpIHB1YmxpYyBpbnN0YW5jZTogSVB1YmxpY0NsaWVudEFwcGxpY2F0aW9uLFxyXG4gICAgcHJpdmF0ZSBsb2NhdGlvbjogTG9jYXRpb25cclxuICApIHtcclxuICAgIGNvbnN0IGhhc2ggPSB0aGlzLmxvY2F0aW9uLnBhdGgodHJ1ZSkuc3BsaXQoJyMnKS5wb3AoKTtcclxuICAgIGlmIChoYXNoKSB7XHJcbiAgICAgIHRoaXMucmVkaXJlY3RIYXNoID0gYCMke2hhc2h9YDtcclxuICAgIH1cclxuICAgIHRoaXMuaW5zdGFuY2UuaW5pdGlhbGl6ZVdyYXBwZXJMaWJyYXJ5KFdyYXBwZXJTS1UuQW5ndWxhciwgdmVyc2lvbik7XHJcbiAgfVxyXG5cclxuICBpbml0aWFsaXplKCk6IE9ic2VydmFibGU8dm9pZD4ge1xyXG4gICAgcmV0dXJuIGZyb20odGhpcy5pbnN0YW5jZS5pbml0aWFsaXplKCkpO1xyXG4gIH1cclxuICBhY3F1aXJlVG9rZW5Qb3B1cChyZXF1ZXN0OiBQb3B1cFJlcXVlc3QpOiBPYnNlcnZhYmxlPEF1dGhlbnRpY2F0aW9uUmVzdWx0PiB7XHJcbiAgICByZXR1cm4gZnJvbSh0aGlzLmluc3RhbmNlLmFjcXVpcmVUb2tlblBvcHVwKHJlcXVlc3QpKTtcclxuICB9XHJcbiAgYWNxdWlyZVRva2VuUmVkaXJlY3QocmVxdWVzdDogUmVkaXJlY3RSZXF1ZXN0KTogT2JzZXJ2YWJsZTx2b2lkPiB7XHJcbiAgICByZXR1cm4gZnJvbSh0aGlzLmluc3RhbmNlLmFjcXVpcmVUb2tlblJlZGlyZWN0KHJlcXVlc3QpKTtcclxuICB9XHJcbiAgYWNxdWlyZVRva2VuU2lsZW50KFxyXG4gICAgc2lsZW50UmVxdWVzdDogU2lsZW50UmVxdWVzdFxyXG4gICk6IE9ic2VydmFibGU8QXV0aGVudGljYXRpb25SZXN1bHQ+IHtcclxuICAgIHJldHVybiBmcm9tKHRoaXMuaW5zdGFuY2UuYWNxdWlyZVRva2VuU2lsZW50KHNpbGVudFJlcXVlc3QpKTtcclxuICB9XHJcbiAgaGFuZGxlUmVkaXJlY3RPYnNlcnZhYmxlKGhhc2g/OiBzdHJpbmcpOiBPYnNlcnZhYmxlPEF1dGhlbnRpY2F0aW9uUmVzdWx0PiB7XHJcbiAgICByZXR1cm4gZnJvbShcclxuICAgICAgdGhpcy5pbnN0YW5jZVxyXG4gICAgICAgIC5pbml0aWFsaXplKClcclxuICAgICAgICAudGhlbigoKSA9PlxyXG4gICAgICAgICAgdGhpcy5pbnN0YW5jZS5oYW5kbGVSZWRpcmVjdFByb21pc2UoaGFzaCB8fCB0aGlzLnJlZGlyZWN0SGFzaClcclxuICAgICAgICApXHJcbiAgICApO1xyXG4gIH1cclxuICBsb2dpblBvcHVwKHJlcXVlc3Q/OiBQb3B1cFJlcXVlc3QpOiBPYnNlcnZhYmxlPEF1dGhlbnRpY2F0aW9uUmVzdWx0PiB7XHJcbiAgICByZXR1cm4gZnJvbSh0aGlzLmluc3RhbmNlLmxvZ2luUG9wdXAocmVxdWVzdCkpO1xyXG4gIH1cclxuICBsb2dpblJlZGlyZWN0KHJlcXVlc3Q/OiBSZWRpcmVjdFJlcXVlc3QpOiBPYnNlcnZhYmxlPHZvaWQ+IHtcclxuICAgIHJldHVybiBmcm9tKHRoaXMuaW5zdGFuY2UubG9naW5SZWRpcmVjdChyZXF1ZXN0KSk7XHJcbiAgfVxyXG4gIGxvZ291dChsb2dvdXRSZXF1ZXN0PzogRW5kU2Vzc2lvblJlcXVlc3QpOiBPYnNlcnZhYmxlPHZvaWQ+IHtcclxuICAgIHJldHVybiBmcm9tKHRoaXMuaW5zdGFuY2UubG9nb3V0KGxvZ291dFJlcXVlc3QpKTtcclxuICB9XHJcbiAgbG9nb3V0UmVkaXJlY3QobG9nb3V0UmVxdWVzdD86IEVuZFNlc3Npb25SZXF1ZXN0KTogT2JzZXJ2YWJsZTx2b2lkPiB7XHJcbiAgICByZXR1cm4gZnJvbSh0aGlzLmluc3RhbmNlLmxvZ291dFJlZGlyZWN0KGxvZ291dFJlcXVlc3QpKTtcclxuICB9XHJcbiAgbG9nb3V0UG9wdXAobG9nb3V0UmVxdWVzdD86IEVuZFNlc3Npb25Qb3B1cFJlcXVlc3QpOiBPYnNlcnZhYmxlPHZvaWQ+IHtcclxuICAgIHJldHVybiBmcm9tKHRoaXMuaW5zdGFuY2UubG9nb3V0UG9wdXAobG9nb3V0UmVxdWVzdCkpO1xyXG4gIH1cclxuICBzc29TaWxlbnQocmVxdWVzdDogU3NvU2lsZW50UmVxdWVzdCk6IE9ic2VydmFibGU8QXV0aGVudGljYXRpb25SZXN1bHQ+IHtcclxuICAgIHJldHVybiBmcm9tKHRoaXMuaW5zdGFuY2Uuc3NvU2lsZW50KHJlcXVlc3QpKTtcclxuICB9XHJcbiAgLyoqXHJcbiAgICogR2V0cyBsb2dnZXIgZm9yIG1zYWwtYW5ndWxhci5cclxuICAgKiBJZiBubyBsb2dnZXIgc2V0LCByZXR1cm5zIGxvZ2dlciBpbnN0YW5jZSBjcmVhdGVkIHdpdGggc2FtZSBvcHRpb25zIGFzIG1zYWwtYnJvd3NlclxyXG4gICAqL1xyXG4gIGdldExvZ2dlcigpOiBMb2dnZXIge1xyXG4gICAgaWYgKCF0aGlzLmxvZ2dlcikge1xyXG4gICAgICB0aGlzLmxvZ2dlciA9IHRoaXMuaW5zdGFuY2UuZ2V0TG9nZ2VyKCkuY2xvbmUobmFtZSwgdmVyc2lvbik7XHJcbiAgICB9XHJcbiAgICByZXR1cm4gdGhpcy5sb2dnZXI7XHJcbiAgfVxyXG4gIC8vIENyZWF0ZSBhIGxvZ2dlciBpbnN0YW5jZSBmb3IgbXNhbC1hbmd1bGFyIHdpdGggdGhlIHNhbWUgb3B0aW9ucyBhcyBtc2FsLWJyb3dzZXJcclxuICBzZXRMb2dnZXIobG9nZ2VyOiBMb2dnZXIpOiB2b2lkIHtcclxuICAgIHRoaXMubG9nZ2VyID0gbG9nZ2VyLmNsb25lKG5hbWUsIHZlcnNpb24pO1xyXG4gICAgdGhpcy5pbnN0YW5jZS5zZXRMb2dnZXIobG9nZ2VyKTtcclxuICB9XHJcbn1cclxuIl19

package/{esm2015/packageMetadata.js → esm2020/packageMetadata.mjs}

@@ -1,4 +1,4 @@
 /* eslint-disable header/header */
 export const name = "@azure/msal-angular";
-export const version = "2.5.7";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFja2FnZU1ldGFkYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3BhY2thZ2VNZXRhZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxrQ0FBa0M7QUFDbEMsTUFBTSxDQUFDLE1BQU0sSUFBSSxHQUFHLHFCQUFxQixDQUFDO0FBQzFDLE1BQU0sQ0FBQyxNQUFNLE9BQU8sR0FBRyxPQUFPLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiBlc2xpbnQtZGlzYWJsZSBoZWFkZXIvaGVhZGVyICovXHJcbmV4cG9ydCBjb25zdCBuYW1lID0gXCJAYXp1cmUvbXNhbC1hbmd1bGFyXCI7XHJcbmV4cG9ydCBjb25zdCB2ZXJzaW9uID0gXCIyLjUuN1wiO1xyXG4iXX0=
+export const version = "3.0.0-alpha.0";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFja2FnZU1ldGFkYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3BhY2thZ2VNZXRhZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxrQ0FBa0M7QUFDbEMsTUFBTSxDQUFDLE1BQU0sSUFBSSxHQUFHLHFCQUFxQixDQUFDO0FBQzFDLE1BQU0sQ0FBQyxNQUFNLE9BQU8sR0FBRyxlQUFlLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiBlc2xpbnQtZGlzYWJsZSBoZWFkZXIvaGVhZGVyICovXHJcbmV4cG9ydCBjb25zdCBuYW1lID0gXCJAYXp1cmUvbXNhbC1hbmd1bGFyXCI7XHJcbmV4cG9ydCBjb25zdCB2ZXJzaW9uID0gXCIzLjAuMC1hbHBoYS4wXCI7XHJcbiJdfQ==

package/esm2020/public-api.mjs

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * @packageDocumentation
+ * @module @azure/msal-angular
+ */
+export { MsalService } from './msal.service';
+export { MsalGuard } from './msal.guard';
+export { MsalInterceptor } from './msal.interceptor';
+export { MSAL_INSTANCE, MSAL_GUARD_CONFIG, MSAL_INTERCEPTOR_CONFIG, MSAL_BROADCAST_CONFIG, } from './constants';
+export { MsalBroadcastService } from './msal.broadcast.service';
+export { MsalModule } from './msal.module';
+export { MsalRedirectComponent } from './msal.redirect.component';
+export { MsalCustomNavigationClient } from './msal.navigation.client';
+export { version } from './packageMetadata';
+//# sourceMappingURL=data:application/json;base64,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