keycloak-angular 8.2.0 → 9.1.0

package/README.md

@@ -20,6 +20,7 @@
 - [Example project](#example-project)
 - [AuthGuard](#authguard)
 - [HttpClient Interceptor](#httpclient-interceptor)
+- [Keycloak-js Events](#keycloak-js-events)
 - [Contributors](#contributors)
 - [License](#license)
 
@@ -50,14 +51,14 @@ Note that `keycloak-js` is a peer dependency of Keycloak Angular. This change al
 
 ### Versions
 
-| Angular     | keycloak-angular | keycloak-js               | Support             |
-| :---------: | :--------------: | :-----------------------: | :-----------------: |
-| 11.x - 12.x | 8.2.x            | 10 - 13                   | Bugs / New Features |
-| 10.x        | 8.x.x            | 10 - 11                   | Bugs                |
-|  9.x        | 7.3.x            | 3.4.3 - 10 (excluding v7) | Bugs                |
+|   Angular   | keycloak-angular | keycloak-js |       Support       |
+| :---------: | :--------------: | :---------: | :-----------------: |
+| 11.x - 13.x |      9.x.x       |   10 - 16   | Bugs / New Features |
 
 We try to support the same Angular versions that are [supported](https://angular.io/guide/releases#support-policy-and-schedule) by the Angular team. That said, it's always best to keep up to date with the latest version of Angular for optimal support.
 
+_Note_: In keycloak-angular **v.9**, it is needed to add `allowSyntheticDefaultImports: true` in the tsconfig.json file in your project. There is an [issue in the keycloak project](https://github.com/keycloak/keycloak/issues/9045) to update the typescript definitions file and solve the problem.
+
 #### Choosing the right keycloak-js version
 
 The Keycloak client documentation recommends to use the same version of your Keycloak installation.
@@ -83,13 +84,13 @@ function initializeKeycloak(keycloak: KeycloakService) {
       config: {
         url: 'http://localhost:8080/auth',
         realm: 'your-realm',
-        clientId: 'your-client-id',
+        clientId: 'your-client-id'
       },
       initOptions: {
         onLoad: 'check-sso',
         silentCheckSsoRedirectUri:
-          window.location.origin + '/assets/silent-check-sso.html',
-      },
+          window.location.origin + '/assets/silent-check-sso.html'
+      }
     });
 }
 
@@ -101,10 +102,10 @@ function initializeKeycloak(keycloak: KeycloakService) {
       provide: APP_INITIALIZER,
       useFactory: initializeKeycloak,
       multi: true,
-      deps: [KeycloakService],
-    },
+      deps: [KeycloakService]
+    }
   ],
-  bootstrap: [AppComponent],
+  bootstrap: [AppComponent]
 })
 export class AppModule {}
 ```
@@ -142,12 +143,12 @@ import { Injectable } from '@angular/core';
 import {
   ActivatedRouteSnapshot,
   Router,
-  RouterStateSnapshot,
+  RouterStateSnapshot
 } from '@angular/router';
 import { KeycloakAuthGuard, KeycloakService } from 'keycloak-angular';
 
 @Injectable({
-  providedIn: 'root',
+  providedIn: 'root'
 })
 export class AuthGuard extends KeycloakAuthGuard {
   constructor(
@@ -164,7 +165,7 @@ export class AuthGuard extends KeycloakAuthGuard {
     // Force the user to log in if currently unauthenticated.
     if (!this.authenticated) {
       await this.keycloak.login({
-        redirectUri: window.location.origin + state.url,
+        redirectUri: window.location.origin + state.url
       });
     }
 
@@ -193,9 +194,25 @@ await keycloak.init({
   config: {
     url: 'http://localhost:8080/auth',
     realm: 'your-realm',
-    clientId: 'your-client-id',
+    clientId: 'your-client-id'
   },
-  bearerExcludedUrls: ['/assets', '/clients/public'],
+  bearerExcludedUrls: ['/assets', '/clients/public']
+});
+```
+
+## Keycloak-js Events
+
+The callback events from [keycloak-js](https://www.keycloak.org/docs/latest/securing_apps/index.html#javascript-adapter-reference) are available through a RxJS subject which is defined by `keycloakEvents$`.
+
+For example you make keycloak-angular auto refreshing your access token when expired:
+
+```ts
+keycloakService.keycloakEvents$.subscribe({
+  next: (e) => {
+    if (e.type == KeycloakEventType.OnTokenExpired) {
+      keycloakService.updateToken(20);
+    }
+  }
 });
 ```
 
@@ -230,4 +247,4 @@ document.
 [contributors-badge]: https://img.shields.io/badge/all_contributors-5-orange.svg?style=flat-square
 [discord-badge]: https://img.shields.io/discord/790617227853692958.svg?color=7389D8&labelColor=6A7EC2&logo=discord&logoColor=ffffff&style=flat-square
 [discord]: https://discord.gg/mmzEhYXXDG
-<!-- prettier-ignore-end -->
+<!-- prettier-ignore-end -->

package/esm2020/lib/core/core.module.mjs

@@ -0,0 +1,33 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { HTTP_INTERCEPTORS } from '@angular/common/http';
+import { KeycloakService } from './services/keycloak.service';
+import { KeycloakBearerInterceptor } from './interceptors/keycloak-bearer.interceptor';
+import * as i0 from "@angular/core";
+export class CoreModule {
+}
+CoreModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: CoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: CoreModule, imports: [CommonModule] });
+CoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: CoreModule, providers: [
+        KeycloakService,
+        {
+            provide: HTTP_INTERCEPTORS,
+            useClass: KeycloakBearerInterceptor,
+            multi: true
+        }
+    ], imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: CoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    providers: [
+                        KeycloakService,
+                        {
+                            provide: HTTP_INTERCEPTORS,
+                            useClass: KeycloakBearerInterceptor,
+                            multi: true
+                        }
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/interceptors/keycloak-bearer.interceptor.mjs

@@ -0,0 +1,41 @@
+import { Injectable } from '@angular/core';
+import { from } from 'rxjs';
+import { mergeMap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/keycloak.service";
+export class KeycloakBearerInterceptor {
+    constructor(keycloak) {
+        this.keycloak = keycloak;
+    }
+    isUrlExcluded({ method, url }, { urlPattern, httpMethods }) {
+        const httpTest = httpMethods.length === 0 ||
+            httpMethods.join().indexOf(method.toUpperCase()) > -1;
+        const urlTest = urlPattern.test(url);
+        return httpTest && urlTest;
+    }
+    intercept(req, next) {
+        const { enableBearerInterceptor, excludedUrls } = this.keycloak;
+        if (!enableBearerInterceptor) {
+            return next.handle(req);
+        }
+        const shallPass = excludedUrls.findIndex((item) => this.isUrlExcluded(req, item)) > -1;
+        if (shallPass) {
+            return next.handle(req);
+        }
+        return from(this.keycloak.isLoggedIn()).pipe(mergeMap((loggedIn) => loggedIn
+            ? this.handleRequestWithTokenHeader(req, next)
+            : next.handle(req)));
+    }
+    handleRequestWithTokenHeader(req, next) {
+        return this.keycloak.addTokenToHeader(req.headers).pipe(mergeMap((headersWithBearer) => {
+            const kcReq = req.clone({ headers: headersWithBearer });
+            return next.handle(kcReq);
+        }));
+    }
+}
+KeycloakBearerInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: KeycloakBearerInterceptor, deps: [{ token: i1.KeycloakService }], target: i0.ɵɵFactoryTarget.Injectable });
+KeycloakBearerInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: KeycloakBearerInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: KeycloakBearerInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.KeycloakService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/services/keycloak-auth-guard.mjs

@@ -0,0 +1,20 @@
+export class KeycloakAuthGuard {
+    constructor(router, keycloakAngular) {
+        this.router = router;
+        this.keycloakAngular = keycloakAngular;
+    }
+    canActivate(route, state) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                this.authenticated = await this.keycloakAngular.isLoggedIn();
+                this.roles = await this.keycloakAngular.getUserRoles(true);
+                const result = await this.isAccessAllowed(route, state);
+                resolve(result);
+            }
+            catch (error) {
+                reject('An error happened during access validation. Details:' + error);
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2V5Y2xvYWstYXV0aC1ndWFyZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2tleWNsb2FrLWFuZ3VsYXIvc3JjL2xpYi9jb3JlL3NlcnZpY2VzL2tleWNsb2FrLWF1dGgtZ3VhcmQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBd0JBLE1BQU0sT0FBZ0IsaUJBQWlCO0lBVXJDLFlBQ1ksTUFBYyxFQUNkLGVBQWdDO1FBRGhDLFdBQU0sR0FBTixNQUFNLENBQVE7UUFDZCxvQkFBZSxHQUFmLGVBQWUsQ0FBaUI7SUFDekMsQ0FBQztJQVNKLFdBQVcsQ0FDVCxLQUE2QixFQUM3QixLQUEwQjtRQUUxQixPQUFPLElBQUksT0FBTyxDQUFDLEtBQUssRUFBRSxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQUU7WUFDM0MsSUFBSTtnQkFDRixJQUFJLENBQUMsYUFBYSxHQUFHLE1BQU0sSUFBSSxDQUFDLGVBQWUsQ0FBQyxVQUFVLEVBQUUsQ0FBQztnQkFDN0QsSUFBSSxDQUFDLEtBQUssR0FBRyxNQUFNLElBQUksQ0FBQyxlQUFlLENBQUMsWUFBWSxDQUFDLElBQUksQ0FBQyxDQUFDO2dCQUUzRCxNQUFNLE1BQU0sR0FBRyxNQUFNLElBQUksQ0FBQyxlQUFlLENBQUMsS0FBSyxFQUFFLEtBQUssQ0FBQyxDQUFDO2dCQUN4RCxPQUFPLENBQUMsTUFBTSxDQUFDLENBQUM7YUFDakI7WUFBQyxPQUFPLEtBQUssRUFBRTtnQkFDZCxNQUFNLENBQUMsc0RBQXNELEdBQUcsS0FBSyxDQUFDLENBQUM7YUFDeEU7UUFDSCxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7Q0FlRiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBNYXVyaWNpbyBHZW1lbGxpIFZpZ29sbyBhbmQgY29udHJpYnV0b3JzLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGEgTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9naXRodWIuY29tL21hdXJpY2lvdmlnb2xvL2tleWNsb2FrLWFuZ3VsYXIvTElDRU5TRVxuICovXG5cbmltcG9ydCB7XG4gIENhbkFjdGl2YXRlLFxuICBSb3V0ZXIsXG4gIEFjdGl2YXRlZFJvdXRlU25hcHNob3QsXG4gIFJvdXRlclN0YXRlU25hcHNob3QsXG4gIFVybFRyZWVcbn0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJztcblxuaW1wb3J0IHsgS2V5Y2xvYWtTZXJ2aWNlIH0gZnJvbSAnLi9rZXljbG9hay5zZXJ2aWNlJztcblxuLyoqXG4gKiBBIHNpbXBsZSBndWFyZCBpbXBsZW1lbnRhdGlvbiBvdXQgb2YgdGhlIGJveC4gVGhpcyBjbGFzcyBzaG91bGQgYmUgaW5oZXJpdGVkIGFuZFxuICogaW1wbGVtZW50ZWQgYnkgdGhlIGFwcGxpY2F0aW9uLiBUaGUgb25seSBtZXRob2QgdGhhdCBzaG91bGQgYmUgaW1wbGVtZW50ZWQgaXMgI2lzQWNjZXNzQWxsb3dlZC5cbiAqIFRoZSByZWFzb24gZm9yIHRoaXMgaXMgdGhhdCB0aGUgYXV0aG9yaXphdGlvbiBmbG93IGlzIHVzdWFsbHkgbm90IHVuaXF1ZSwgc28gaW4gdGhpcyB3YXkgeW91IHdpbGxcbiAqIGhhdmUgbW9yZSBmcmVlZG9tIHRvIGN1c3RvbWl6ZSB5b3VyIGF1dGhvcml6YXRpb24gZmxvdy5cbiAqL1xuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEtleWNsb2FrQXV0aEd1YXJkIGltcGxlbWVudHMgQ2FuQWN0aXZhdGUge1xuICAvKipcbiAgICogSW5kaWNhdGVzIGlmIHRoZSB1c2VyIGlzIGF1dGhlbnRpY2F0ZWQgb3Igbm90LlxuICAgKi9cbiAgcHJvdGVjdGVkIGF1dGhlbnRpY2F0ZWQ6IGJvb2xlYW47XG4gIC8qKlxuICAgKiBSb2xlcyBvZiB0aGUgbG9nZ2VkIHVzZXIuIEl0IGNvbnRhaW5zIHRoZSBjbGllbnRJZCBhbmQgcmVhbG0gdXNlciByb2xlcy5cbiAgICovXG4gIHByb3RlY3RlZCByb2xlczogc3RyaW5nW107XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcHJvdGVjdGVkIHJvdXRlcjogUm91dGVyLFxuICAgIHByb3RlY3RlZCBrZXljbG9ha0FuZ3VsYXI6IEtleWNsb2FrU2VydmljZVxuICApIHt9XG5cbiAgLyoqXG4gICAqIENhbkFjdGl2YXRlIGNoZWNrcyBpZiB0aGUgdXNlciBpcyBsb2dnZWQgaW4gYW5kIGdldCB0aGUgZnVsbCBsaXN0IG9mIHJvbGVzIChSRUFMTSArIENMSUVOVClcbiAgICogb2YgdGhlIGxvZ2dlZCB1c2VyLiBUaGlzIHZhbHVlcyBhcmUgc2V0IHRvIGF1dGhlbnRpY2F0ZWQgYW5kIHJvbGVzIHBhcmFtcy5cbiAgICpcbiAgICogQHBhcmFtIHJvdXRlXG4gICAqIEBwYXJhbSBzdGF0ZVxuICAgKi9cbiAgY2FuQWN0aXZhdGUoXG4gICAgcm91dGU6IEFjdGl2YXRlZFJvdXRlU25hcHNob3QsXG4gICAgc3RhdGU6IFJvdXRlclN0YXRlU25hcHNob3RcbiAgKTogUHJvbWlzZTxib29sZWFuIHwgVXJsVHJlZT4ge1xuICAgIHJldHVybiBuZXcgUHJvbWlzZShhc3luYyAocmVzb2x2ZSwgcmVqZWN0KSA9PiB7XG4gICAgICB0cnkge1xuICAgICAgICB0aGlzLmF1dGhlbnRpY2F0ZWQgPSBhd2FpdCB0aGlzLmtleWNsb2FrQW5ndWxhci5pc0xvZ2dlZEluKCk7XG4gICAgICAgIHRoaXMucm9sZXMgPSBhd2FpdCB0aGlzLmtleWNsb2FrQW5ndWxhci5nZXRVc2VyUm9sZXModHJ1ZSk7XG5cbiAgICAgICAgY29uc3QgcmVzdWx0ID0gYXdhaXQgdGhpcy5pc0FjY2Vzc0FsbG93ZWQocm91dGUsIHN0YXRlKTtcbiAgICAgICAgcmVzb2x2ZShyZXN1bHQpO1xuICAgICAgfSBjYXRjaCAoZXJyb3IpIHtcbiAgICAgICAgcmVqZWN0KCdBbiBlcnJvciBoYXBwZW5lZCBkdXJpbmcgYWNjZXNzIHZhbGlkYXRpb24uIERldGFpbHM6JyArIGVycm9yKTtcbiAgICAgIH1cbiAgICB9KTtcbiAgfVxuXG4gIC8qKlxuICAgKiBDcmVhdGUgeW91ciBvd24gY3VzdG9taXplZCBhdXRob3JpemF0aW9uIGZsb3cgaW4gdGhpcyBtZXRob2QuIEZyb20gaGVyZSB5b3UgYWxyZWFkeSBrbm93blxuICAgKiBpZiB0aGUgdXNlciBpcyBhdXRoZW50aWNhdGVkICh0aGlzLmF1dGhlbnRpY2F0ZWQpIGFuZCB0aGUgdXNlciByb2xlcyAodGhpcy5yb2xlcykuXG4gICAqXG4gICAqIFJldHVybiBhIFVybFRyZWUgaWYgdGhlIHVzZXIgc2hvdWxkIGJlIHJlZGlyZWN0ZWQgdG8gYW5vdGhlciByb3V0ZS5cbiAgICpcbiAgICogQHBhcmFtIHJvdXRlXG4gICAqIEBwYXJhbSBzdGF0ZVxuICAgKi9cbiAgYWJzdHJhY3QgaXNBY2Nlc3NBbGxvd2VkKFxuICAgIHJvdXRlOiBBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90LFxuICAgIHN0YXRlOiBSb3V0ZXJTdGF0ZVNuYXBzaG90XG4gICk6IFByb21pc2U8Ym9vbGVhbiB8IFVybFRyZWU+O1xufVxuIl19

package/esm2020/lib/core/services/keycloak.service.mjs

@@ -0,0 +1,196 @@
+import { Injectable } from '@angular/core';
+import { HttpHeaders } from '@angular/common/http';
+import { Subject, from } from 'rxjs';
+import { map } from 'rxjs/operators';
+import Keycloak from 'keycloak-js';
+import { KeycloakEventType } from '../interfaces/keycloak-event';
+import * as i0 from "@angular/core";
+export class KeycloakService {
+    constructor() {
+        this._keycloakEvents$ = new Subject();
+    }
+    bindsKeycloakEvents() {
+        this._instance.onAuthError = (errorData) => {
+            this._keycloakEvents$.next({
+                args: errorData,
+                type: KeycloakEventType.OnAuthError
+            });
+        };
+        this._instance.onAuthLogout = () => {
+            this._keycloakEvents$.next({ type: KeycloakEventType.OnAuthLogout });
+        };
+        this._instance.onAuthRefreshSuccess = () => {
+            this._keycloakEvents$.next({
+                type: KeycloakEventType.OnAuthRefreshSuccess
+            });
+        };
+        this._instance.onAuthRefreshError = () => {
+            this._keycloakEvents$.next({
+                type: KeycloakEventType.OnAuthRefreshError
+            });
+        };
+        this._instance.onAuthSuccess = () => {
+            this._keycloakEvents$.next({ type: KeycloakEventType.OnAuthSuccess });
+        };
+        this._instance.onTokenExpired = () => {
+            this._keycloakEvents$.next({
+                type: KeycloakEventType.OnTokenExpired
+            });
+        };
+        this._instance.onReady = (authenticated) => {
+            this._keycloakEvents$.next({
+                args: authenticated,
+                type: KeycloakEventType.OnReady
+            });
+        };
+    }
+    loadExcludedUrls(bearerExcludedUrls) {
+        const excludedUrls = [];
+        for (const item of bearerExcludedUrls) {
+            let excludedUrl;
+            if (typeof item === 'string') {
+                excludedUrl = { urlPattern: new RegExp(item, 'i'), httpMethods: [] };
+            }
+            else {
+                excludedUrl = {
+                    urlPattern: new RegExp(item.url, 'i'),
+                    httpMethods: item.httpMethods
+                };
+            }
+            excludedUrls.push(excludedUrl);
+        }
+        return excludedUrls;
+    }
+    initServiceValues({ enableBearerInterceptor = true, loadUserProfileAtStartUp = false, bearerExcludedUrls = [], authorizationHeaderName = 'Authorization', bearerPrefix = 'Bearer', initOptions }) {
+        this._enableBearerInterceptor = enableBearerInterceptor;
+        this._loadUserProfileAtStartUp = loadUserProfileAtStartUp;
+        this._authorizationHeaderName = authorizationHeaderName;
+        this._bearerPrefix = bearerPrefix.trim().concat(' ');
+        this._excludedUrls = this.loadExcludedUrls(bearerExcludedUrls);
+        this._silentRefresh = initOptions ? initOptions.flow === 'implicit' : false;
+    }
+    async init(options = {}) {
+        this.initServiceValues(options);
+        const { config, initOptions } = options;
+        this._instance = Keycloak(config);
+        this.bindsKeycloakEvents();
+        const authenticated = await this._instance.init(initOptions);
+        if (authenticated && this._loadUserProfileAtStartUp) {
+            await this.loadUserProfile();
+        }
+        return authenticated;
+    }
+    async login(options = {}) {
+        await this._instance.login(options);
+        if (this._loadUserProfileAtStartUp) {
+            await this.loadUserProfile();
+        }
+    }
+    async logout(redirectUri) {
+        const options = {
+            redirectUri
+        };
+        await this._instance.logout(options);
+        this._userProfile = undefined;
+    }
+    async register(options = { action: 'register' }) {
+        await this._instance.register(options);
+    }
+    isUserInRole(role, resource) {
+        let hasRole;
+        hasRole = this._instance.hasResourceRole(role, resource);
+        if (!hasRole) {
+            hasRole = this._instance.hasRealmRole(role);
+        }
+        return hasRole;
+    }
+    getUserRoles(allRoles = true) {
+        let roles = [];
+        if (this._instance.resourceAccess) {
+            for (const key in this._instance.resourceAccess) {
+                if (this._instance.resourceAccess.hasOwnProperty(key)) {
+                    const resourceAccess = this._instance.resourceAccess[key];
+                    const clientRoles = resourceAccess['roles'] || [];
+                    roles = roles.concat(clientRoles);
+                }
+            }
+        }
+        if (allRoles && this._instance.realmAccess) {
+            const realmRoles = this._instance.realmAccess['roles'] || [];
+            roles.push(...realmRoles);
+        }
+        return roles;
+    }
+    async isLoggedIn() {
+        try {
+            if (!this._instance.authenticated) {
+                return false;
+            }
+            await this.updateToken(20);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    isTokenExpired(minValidity = 0) {
+        return this._instance.isTokenExpired(minValidity);
+    }
+    async updateToken(minValidity = 5) {
+        if (this._silentRefresh) {
+            if (this.isTokenExpired()) {
+                throw new Error('Failed to refresh the token, or the session is expired');
+            }
+            return true;
+        }
+        if (!this._instance) {
+            throw new Error('Keycloak Angular library is not initialized.');
+        }
+        return this._instance.updateToken(minValidity);
+    }
+    async loadUserProfile(forceReload = false) {
+        if (this._userProfile && !forceReload) {
+            return this._userProfile;
+        }
+        if (!this._instance.authenticated) {
+            throw new Error('The user profile was not loaded as the user is not logged in.');
+        }
+        return (this._userProfile = await this._instance.loadUserProfile());
+    }
+    async getToken() {
+        await this.updateToken(10);
+        return this._instance.token;
+    }
+    getUsername() {
+        if (!this._userProfile) {
+            throw new Error('User not logged in or user profile was not loaded.');
+        }
+        return this._userProfile.username;
+    }
+    clearToken() {
+        this._instance.clearToken();
+    }
+    addTokenToHeader(headers = new HttpHeaders()) {
+        return from(this.getToken()).pipe(map((token) => token
+            ? headers.set(this._authorizationHeaderName, this._bearerPrefix + token)
+            : headers));
+    }
+    getKeycloakInstance() {
+        return this._instance;
+    }
+    get excludedUrls() {
+        return this._excludedUrls;
+    }
+    get enableBearerInterceptor() {
+        return this._enableBearerInterceptor;
+    }
+    get keycloakEvents$() {
+        return this._keycloakEvents$;
+    }
+}
+KeycloakService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: KeycloakService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+KeycloakService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: KeycloakService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: KeycloakService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keycloak.service.js","sourceRoot":"","sources":["../../../../../../projects/keycloak-angular/src/lib/core/services/keycloak.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Mauricio Gemelli Vigolo and contributors.\n *\n * Use of this source code is governed by a MIT-style license that can be\n * found in the LICENSE file at https://github.com/mauriciovigolo/keycloak-angular/LICENSE\n */\n\nimport { Injectable } from '@angular/core';\nimport { HttpHeaders } from '@angular/common/http';\n\nimport { Subject, from } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport Keycloak from 'keycloak-js';\n\nimport {\n  ExcludedUrl,\n  ExcludedUrlRegex,\n  KeycloakOptions\n} from '../interfaces/keycloak-options';\nimport { KeycloakEvent, KeycloakEventType } from '../interfaces/keycloak-event';\n\n/**\n * Service to expose existent methods from the Keycloak JS adapter, adding new\n * functionalities to improve the use of keycloak in Angular v > 4.3 applications.\n *\n * This class should be injected in the application bootstrap, so the same instance will be used\n * along the web application.\n */\n@Injectable()\nexport class KeycloakService {\n  /**\n   * Keycloak-js instance.\n   */\n  private _instance: Keycloak.KeycloakInstance;\n  /**\n   * User profile as KeycloakProfile interface.\n   */\n  private _userProfile: Keycloak.KeycloakProfile;\n  /**\n   * Flag to indicate if the bearer will not be added to the authorization header.\n   */\n  private _enableBearerInterceptor: boolean;\n  /**\n   * When the implicit flow is choosen there must exist a silentRefresh, as there is\n   * no refresh token.\n   */\n  private _silentRefresh: boolean;\n  /**\n   * Indicates that the user profile should be loaded at the keycloak initialization,\n   * just after the login.\n   */\n  private _loadUserProfileAtStartUp: boolean;\n  /**\n   * The bearer prefix that will be appended to the Authorization Header.\n   */\n  private _bearerPrefix: string;\n  /**\n   * Value that will be used as the Authorization Http Header name.\n   */\n  private _authorizationHeaderName: string;\n  /**\n   * The excluded urls patterns that must skip the KeycloakBearerInterceptor.\n   */\n  private _excludedUrls: ExcludedUrlRegex[];\n  /**\n   * Observer for the keycloak events\n   */\n  private _keycloakEvents$: Subject<KeycloakEvent> =\n    new Subject<KeycloakEvent>();\n\n  /**\n   * Binds the keycloak-js events to the keycloakEvents Subject\n   * which is a good way to monitor for changes, if needed.\n   *\n   * The keycloakEvents returns the keycloak-js event type and any\n   * argument if the source function provides any.\n   */\n  private bindsKeycloakEvents(): void {\n    this._instance.onAuthError = (errorData) => {\n      this._keycloakEvents$.next({\n        args: errorData,\n        type: KeycloakEventType.OnAuthError\n      });\n    };\n\n    this._instance.onAuthLogout = () => {\n      this._keycloakEvents$.next({ type: KeycloakEventType.OnAuthLogout });\n    };\n\n    this._instance.onAuthRefreshSuccess = () => {\n      this._keycloakEvents$.next({\n        type: KeycloakEventType.OnAuthRefreshSuccess\n      });\n    };\n\n    this._instance.onAuthRefreshError = () => {\n      this._keycloakEvents$.next({\n        type: KeycloakEventType.OnAuthRefreshError\n      });\n    };\n\n    this._instance.onAuthSuccess = () => {\n      this._keycloakEvents$.next({ type: KeycloakEventType.OnAuthSuccess });\n    };\n\n    this._instance.onTokenExpired = () => {\n      this._keycloakEvents$.next({\n        type: KeycloakEventType.OnTokenExpired\n      });\n    };\n\n    this._instance.onReady = (authenticated) => {\n      this._keycloakEvents$.next({\n        args: authenticated,\n        type: KeycloakEventType.OnReady\n      });\n    };\n  }\n\n  /**\n   * Loads all bearerExcludedUrl content in a uniform type: ExcludedUrl,\n   * so it becomes easier to handle.\n   *\n   * @param bearerExcludedUrls array of strings or ExcludedUrl that includes\n   * the url and HttpMethod.\n   */\n  private loadExcludedUrls(\n    bearerExcludedUrls: (string | ExcludedUrl)[]\n  ): ExcludedUrlRegex[] {\n    const excludedUrls: ExcludedUrlRegex[] = [];\n    for (const item of bearerExcludedUrls) {\n      let excludedUrl: ExcludedUrlRegex;\n      if (typeof item === 'string') {\n        excludedUrl = { urlPattern: new RegExp(item, 'i'), httpMethods: [] };\n      } else {\n        excludedUrl = {\n          urlPattern: new RegExp(item.url, 'i'),\n          httpMethods: item.httpMethods\n        };\n      }\n      excludedUrls.push(excludedUrl);\n    }\n    return excludedUrls;\n  }\n\n  /**\n   * Handles the class values initialization.\n   *\n   * @param options\n   */\n  private initServiceValues({\n    enableBearerInterceptor = true,\n    loadUserProfileAtStartUp = false,\n    bearerExcludedUrls = [],\n    authorizationHeaderName = 'Authorization',\n    bearerPrefix = 'Bearer',\n    initOptions\n  }: KeycloakOptions): void {\n    this._enableBearerInterceptor = enableBearerInterceptor;\n    this._loadUserProfileAtStartUp = loadUserProfileAtStartUp;\n    this._authorizationHeaderName = authorizationHeaderName;\n    this._bearerPrefix = bearerPrefix.trim().concat(' ');\n    this._excludedUrls = this.loadExcludedUrls(bearerExcludedUrls);\n    this._silentRefresh = initOptions ? initOptions.flow === 'implicit' : false;\n  }\n\n  /**\n   * Keycloak initialization. It should be called to initialize the adapter.\n   * Options is a object with 2 main parameters: config and initOptions. The first one\n   * will be used to create the Keycloak instance. The second one are options to initialize the\n   * keycloak instance.\n   *\n   * @param options\n   * Config: may be a string representing the keycloak URI or an object with the\n   * following content:\n   * - url: Keycloak json URL\n   * - realm: realm name\n   * - clientId: client id\n   *\n   * initOptions:\n   * Options to initialize the Keycloak adapter, matches the options as provided by Keycloak itself.\n   *\n   * enableBearerInterceptor:\n   * Flag to indicate if the bearer will added to the authorization header.\n   *\n   * loadUserProfileInStartUp:\n   * Indicates that the user profile should be loaded at the keycloak initialization,\n   * just after the login.\n   *\n   * bearerExcludedUrls:\n   * String Array to exclude the urls that should not have the Authorization Header automatically\n   * added.\n   *\n   * authorizationHeaderName:\n   * This value will be used as the Authorization Http Header name.\n   *\n   * bearerPrefix:\n   * This value will be included in the Authorization Http Header param.\n   *\n   * @returns\n   * A Promise with a boolean indicating if the initialization was successful.\n   */\n  public async init(options: KeycloakOptions = {}) {\n    this.initServiceValues(options);\n    const { config, initOptions } = options;\n\n    this._instance = Keycloak(config);\n    this.bindsKeycloakEvents();\n\n    const authenticated = await this._instance.init(initOptions);\n\n    if (authenticated && this._loadUserProfileAtStartUp) {\n      await this.loadUserProfile();\n    }\n\n    return authenticated;\n  }\n\n  /**\n   * Redirects to login form on (options is an optional object with redirectUri and/or\n   * prompt fields).\n   *\n   * @param options\n   * Object, where:\n   *  - redirectUri: Specifies the uri to redirect to after login.\n   *  - prompt:By default the login screen is displayed if the user is not logged-in to Keycloak.\n   * To only authenticate to the application if the user is already logged-in and not display the\n   * login page if the user is not logged-in, set this option to none. To always require\n   * re-authentication and ignore SSO, set this option to login .\n   *  - maxAge: Used just if user is already authenticated. Specifies maximum time since the\n   * authentication of user happened. If user is already authenticated for longer time than\n   * maxAge, the SSO is ignored and he will need to re-authenticate again.\n   *  - loginHint: Used to pre-fill the username/email field on the login form.\n   *  - action: If value is 'register' then user is redirected to registration page, otherwise to\n   * login page.\n   *  - locale: Specifies the desired locale for the UI.\n   * @returns\n   * A void Promise if the login is successful and after the user profile loading.\n   */\n  public async login(options: Keycloak.KeycloakLoginOptions = {}) {\n    await this._instance.login(options);\n\n    if (this._loadUserProfileAtStartUp) {\n      await this.loadUserProfile();\n    }\n  }\n\n  /**\n   * Redirects to logout.\n   *\n   * @param redirectUri\n   * Specifies the uri to redirect to after logout.\n   * @returns\n   * A void Promise if the logout was successful, cleaning also the userProfile.\n   */\n  public async logout(redirectUri?: string) {\n    const options = {\n      redirectUri\n    };\n\n    await this._instance.logout(options);\n    this._userProfile = undefined;\n  }\n\n  /**\n   * Redirects to registration form. Shortcut for login with option\n   * action = 'register'. Options are same as for the login method but 'action' is set to\n   * 'register'.\n   *\n   * @param options\n   * login options\n   * @returns\n   * A void Promise if the register flow was successful.\n   */\n  public async register(\n    options: Keycloak.KeycloakLoginOptions = { action: 'register' }\n  ) {\n    await this._instance.register(options);\n  }\n\n  /**\n   * Check if the user has access to the specified role. It will look for roles in\n   * realm and clientId, but will not check if the user is logged in for better performance.\n   *\n   * @param role\n   * role name\n   * @param resource\n   * resource name If not specified, `clientId` is used\n   * @returns\n   * A boolean meaning if the user has the specified Role.\n   */\n  isUserInRole(role: string, resource?: string): boolean {\n    let hasRole: boolean;\n    hasRole = this._instance.hasResourceRole(role, resource);\n    if (!hasRole) {\n      hasRole = this._instance.hasRealmRole(role);\n    }\n    return hasRole;\n  }\n\n  /**\n   * Return the roles of the logged user. The allRoles parameter, with default value\n   * true, will return the clientId and realm roles associated with the logged user. If set to false\n   * it will only return the user roles associated with the clientId.\n   *\n   * @param allRoles\n   * Flag to set if all roles should be returned.(Optional: default value is true)\n   * @returns\n   * Array of Roles associated with the logged user.\n   */\n  getUserRoles(allRoles: boolean = true): string[] {\n    let roles: string[] = [];\n    if (this._instance.resourceAccess) {\n      for (const key in this._instance.resourceAccess) {\n        if (this._instance.resourceAccess.hasOwnProperty(key)) {\n          const resourceAccess: any = this._instance.resourceAccess[key];\n          const clientRoles = resourceAccess['roles'] || [];\n          roles = roles.concat(clientRoles);\n        }\n      }\n    }\n    if (allRoles && this._instance.realmAccess) {\n      const realmRoles = this._instance.realmAccess['roles'] || [];\n      roles.push(...realmRoles);\n    }\n    return roles;\n  }\n\n  /**\n   * Check if user is logged in.\n   *\n   * @returns\n   * A boolean that indicates if the user is logged in.\n   */\n  async isLoggedIn(): Promise<boolean> {\n    try {\n      if (!this._instance.authenticated) {\n        return false;\n      }\n      await this.updateToken(20);\n      return true;\n    } catch (error) {\n      return false;\n    }\n  }\n\n  /**\n   * Returns true if the token has less than minValidity seconds left before\n   * it expires.\n   *\n   * @param minValidity\n   * Seconds left. (minValidity) is optional. Default value is 0.\n   * @returns\n   * Boolean indicating if the token is expired.\n   */\n  isTokenExpired(minValidity: number = 0): boolean {\n    return this._instance.isTokenExpired(minValidity);\n  }\n\n  /**\n   * If the token expires within minValidity seconds the token is refreshed. If the\n   * session status iframe is enabled, the session status is also checked.\n   * Returns a promise telling if the token was refreshed or not. If the session is not active\n   * anymore, the promise is rejected.\n   *\n   * @param minValidity\n   * Seconds left. (minValidity is optional, if not specified 5 is used)\n   * @returns\n   * Promise with a boolean indicating if the token was succesfully updated.\n   */\n  public async updateToken(minValidity = 5) {\n    // TODO: this is a workaround until the silent refresh (issue #43)\n    // is not implemented, avoiding the redirect loop.\n    if (this._silentRefresh) {\n      if (this.isTokenExpired()) {\n        throw new Error(\n          'Failed to refresh the token, or the session is expired'\n        );\n      }\n\n      return true;\n    }\n\n    if (!this._instance) {\n      throw new Error('Keycloak Angular library is not initialized.');\n    }\n\n    return this._instance.updateToken(minValidity);\n  }\n\n  /**\n   * Loads the user profile.\n   * Returns promise to set functions to be invoked if the profile was loaded\n   * successfully, or if the profile could not be loaded.\n   *\n   * @param forceReload\n   * If true will force the loadUserProfile even if its already loaded.\n   * @returns\n   * A promise with the KeycloakProfile data loaded.\n   */\n  public async loadUserProfile(forceReload = false) {\n    if (this._userProfile && !forceReload) {\n      return this._userProfile;\n    }\n\n    if (!this._instance.authenticated) {\n      throw new Error(\n        'The user profile was not loaded as the user is not logged in.'\n      );\n    }\n\n    return (this._userProfile = await this._instance.loadUserProfile());\n  }\n\n  /**\n   * Returns the authenticated token, calling updateToken to get a refreshed one if necessary.\n   */\n  public async getToken() {\n    await this.updateToken(10);\n    return this._instance.token;\n  }\n\n  /**\n   * Returns the logged username.\n   *\n   * @returns\n   * The logged username.\n   */\n  public getUsername() {\n    if (!this._userProfile) {\n      throw new Error('User not logged in or user profile was not loaded.');\n    }\n\n    return this._userProfile.username;\n  }\n\n  /**\n   * Clear authentication state, including tokens. This can be useful if application\n   * has detected the session was expired, for example if updating token fails.\n   * Invoking this results in onAuthLogout callback listener being invoked.\n   */\n  clearToken(): void {\n    this._instance.clearToken();\n  }\n\n  /**\n   * Adds a valid token in header. The key & value format is:\n   * Authorization Bearer <token>.\n   * If the headers param is undefined it will create the Angular headers object.\n   *\n   * @param headers\n   * Updated header with Authorization and Keycloak token.\n   * @returns\n   * An observable with with the HTTP Authorization header and the current token.\n   */\n  public addTokenToHeader(headers: HttpHeaders = new HttpHeaders()) {\n    return from(this.getToken()).pipe(\n      map((token) =>\n        token\n          ? headers.set(\n              this._authorizationHeaderName,\n              this._bearerPrefix + token\n            )\n          : headers\n      )\n    );\n  }\n\n  /**\n   * Returns the original Keycloak instance, if you need any customization that\n   * this Angular service does not support yet. Use with caution.\n   *\n   * @returns\n   * The KeycloakInstance from keycloak-js.\n   */\n  getKeycloakInstance(): Keycloak.KeycloakInstance {\n    return this._instance;\n  }\n\n  /**\n   * Returns the excluded URLs that should not be considered by\n   * the http interceptor which automatically adds the authorization header in the Http Request.\n   *\n   * @returns\n   * The excluded urls that must not be intercepted by the KeycloakBearerInterceptor.\n   */\n  get excludedUrls(): ExcludedUrlRegex[] {\n    return this._excludedUrls;\n  }\n\n  /**\n   * Flag to indicate if the bearer will be added to the authorization header.\n   *\n   * @returns\n   * Returns if the bearer interceptor was set to be disabled.\n   */\n  get enableBearerInterceptor(): boolean {\n    return this._enableBearerInterceptor;\n  }\n\n  /**\n   * Keycloak subject to monitor the events triggered by keycloak-js.\n   * The following events as available (as described at keycloak docs -\n   * https://www.keycloak.org/docs/latest/securing_apps/index.html#callback-events):\n   * - OnAuthError\n   * - OnAuthLogout\n   * - OnAuthRefreshError\n   * - OnAuthRefreshSuccess\n   * - OnAuthSuccess\n   * - OnReady\n   * - OnTokenExpire\n   * In each occurrence of any of these, this subject will return the event type,\n   * described at {@link KeycloakEventType} enum and the function args from the keycloak-js\n   * if provided any.\n   *\n   * @returns\n   * A subject with the {@link KeycloakEvent} which describes the event type and attaches the\n   * function args.\n   */\n  get keycloakEvents$(): Subject<KeycloakEvent> {\n    return this._keycloakEvents$;\n  }\n}\n"]}

package/esm2020/lib/keycloak-angular.module.mjs

@@ -0,0 +1,15 @@
+import { NgModule } from '@angular/core';
+import { CoreModule } from './core/core.module';
+import * as i0 from "@angular/core";
+export class KeycloakAngularModule {
+}
+KeycloakAngularModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: KeycloakAngularModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+KeycloakAngularModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: KeycloakAngularModule, imports: [CoreModule] });
+KeycloakAngularModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: KeycloakAngularModule, imports: [[CoreModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: KeycloakAngularModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CoreModule]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2V5Y2xvYWstYW5ndWxhci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9rZXljbG9hay1hbmd1bGFyL3NyYy9saWIva2V5Y2xvYWstYW5ndWxhci5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBUUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV6QyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7O0FBS2hELE1BQU0sT0FBTyxxQkFBcUI7O2tIQUFyQixxQkFBcUI7bUhBQXJCLHFCQUFxQixZQUZ0QixVQUFVO21IQUVULHFCQUFxQixZQUZ2QixDQUFDLFVBQVUsQ0FBQzsyRkFFVixxQkFBcUI7a0JBSGpDLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFLENBQUMsVUFBVSxDQUFDO2lCQUN0QiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBNYXVyaWNpbyBHZW1lbGxpIFZpZ29sbyBhbmQgY29udHJpYnV0b3JzLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGEgTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9naXRodWIuY29tL21hdXJpY2lvdmlnb2xvL2tleWNsb2FrLWFuZ3VsYXIvTElDRU5TRVxuICovXG5cbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IENvcmVNb2R1bGUgfSBmcm9tICcuL2NvcmUvY29yZS5tb2R1bGUnO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbQ29yZU1vZHVsZV1cbn0pXG5leHBvcnQgY2xhc3MgS2V5Y2xvYWtBbmd1bGFyTW9kdWxlIHt9XG4iXX0=

package/esm2020/public_api.mjs

@@ -0,0 +1,7 @@
+export { KeycloakEventType } from './lib/core/interfaces/keycloak-event';
+export { KeycloakAuthGuard } from './lib/core/services/keycloak-auth-guard';
+export { KeycloakService } from './lib/core/services/keycloak.service';
+export { KeycloakBearerInterceptor } from './lib/core/interceptors/keycloak-bearer.interceptor';
+export { CoreModule } from './lib/core/core.module';
+export { KeycloakAngularModule } from './lib/keycloak-angular.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2tleWNsb2FrLWFuZ3VsYXIvc3JjL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBUUEsT0FBTyxFQUVMLGlCQUFpQixFQUNsQixNQUFNLHNDQUFzQyxDQUFDO0FBRTlDLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHlDQUF5QyxDQUFDO0FBQzVFLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUN2RSxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSxxREFBcUQsQ0FBQztBQUNoRyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDcEQsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sK0JBQStCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgTWF1cmljaW8gR2VtZWxsaSBWaWdvbG8gYW5kIGNvbnRyaWJ1dG9ycy5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vZ2l0aHViLmNvbS9tYXVyaWNpb3ZpZ29sby9rZXljbG9hay1hbmd1bGFyL0xJQ0VOU0VcbiAqL1xuXG5leHBvcnQge1xuICBLZXljbG9ha0V2ZW50LFxuICBLZXljbG9ha0V2ZW50VHlwZVxufSBmcm9tICcuL2xpYi9jb3JlL2ludGVyZmFjZXMva2V5Y2xvYWstZXZlbnQnO1xuZXhwb3J0IHsgS2V5Y2xvYWtPcHRpb25zIH0gZnJvbSAnLi9saWIvY29yZS9pbnRlcmZhY2VzL2tleWNsb2FrLW9wdGlvbnMnO1xuZXhwb3J0IHsgS2V5Y2xvYWtBdXRoR3VhcmQgfSBmcm9tICcuL2xpYi9jb3JlL3NlcnZpY2VzL2tleWNsb2FrLWF1dGgtZ3VhcmQnO1xuZXhwb3J0IHsgS2V5Y2xvYWtTZXJ2aWNlIH0gZnJvbSAnLi9saWIvY29yZS9zZXJ2aWNlcy9rZXljbG9hay5zZXJ2aWNlJztcbmV4cG9ydCB7IEtleWNsb2FrQmVhcmVySW50ZXJjZXB0b3IgfSBmcm9tICcuL2xpYi9jb3JlL2ludGVyY2VwdG9ycy9rZXljbG9hay1iZWFyZXIuaW50ZXJjZXB0b3InO1xuZXhwb3J0IHsgQ29yZU1vZHVsZSB9IGZyb20gJy4vbGliL2NvcmUvY29yZS5tb2R1bGUnO1xuZXhwb3J0IHsgS2V5Y2xvYWtBbmd1bGFyTW9kdWxlIH0gZnJvbSAnLi9saWIva2V5Y2xvYWstYW5ndWxhci5tb2R1bGUnO1xuIl19