@smartbit4all/ng-client 1.0.0

package/esm2020/lib/session/dev-tool/smart-dev-tool.interceptor.mjs

@@ -0,0 +1,52 @@
+import { HttpEventType, } from "@angular/common/http";
+import { Injectable } from "@angular/core";
+import { catchError, map, throwError } from "rxjs";
+import * as i0 from "@angular/core";
+import * as i1 from "./smart-dev-tool.service";
+export class SmartDevToolInterceptor {
+    constructor(service) {
+        this.service = service;
+    }
+    intercept(request, next) {
+        if (!this.service.isActive) {
+            return next.handle(request);
+        }
+        let requestDate = new Date();
+        return next.handle(request).pipe(map((event) => {
+            if (event.type === HttpEventType.Response) {
+                let responseDate = new Date();
+                this.service.writeResponse(request, event, requestDate, responseDate);
+            }
+            return event;
+        }));
+    }
+}
+SmartDevToolInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolInterceptor, deps: [{ token: i1.SmartDevToolService }], target: i0.ɵɵFactoryTarget.Injectable });
+SmartDevToolInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.SmartDevToolService }]; } });
+export class SmartDevToolErrorInterceptor {
+    constructor(service) {
+        this.service = service;
+    }
+    intercept(request, next) {
+        if (!this.service.isActive) {
+            return next.handle(request);
+        }
+        let requestDate = new Date();
+        return next.handle(request).pipe(catchError((error) => {
+            if (error.status !== 200) {
+                let responseDate = new Date();
+                this.service.writeResponse(request, error, requestDate, responseDate);
+            }
+            return throwError(error);
+        }));
+    }
+}
+SmartDevToolErrorInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolErrorInterceptor, deps: [{ token: i1.SmartDevToolService }], target: i0.ɵɵFactoryTarget.Injectable });
+SmartDevToolErrorInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolErrorInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolErrorInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.SmartDevToolService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/session/dev-tool/smart-dev-tool.service.mjs

@@ -0,0 +1,161 @@
+import { DatePipe } from "@angular/common";
+import { Injectable, Pipe } from "@angular/core";
+import { Subject } from "rxjs";
+import * as i0 from "@angular/core";
+import * as i1 from "../cookie-service/smart-cookie.service";
+export class SmartDevToolService {
+    constructor(cookieService) {
+        this.cookieService = cookieService;
+        this.smartDevToolName = "smartDevTool";
+        this.isSmartDevToolActiveName = "smartDevToolActive";
+        this.isActive = false;
+        this.smartDevToolHoursName = "smartDevToolHours";
+        this.smartDevToolMaxName = "smartDevToolMaxCalls";
+        this.hoursToSave = 1;
+        this.maxNumOfSavedCalls = 50;
+        this.descriptorChanged = new Subject();
+        this.newErrorsCount = 0;
+        this.newErrorsCountChanged = new Subject();
+        this.setUpLocalStorage();
+        let apiCallsFromLocalStorage = localStorage.getItem(this.smartDevToolName);
+        if (apiCallsFromLocalStorage) {
+            this.descriptor = JSON.parse(apiCallsFromLocalStorage);
+        }
+        else {
+            this.descriptor = { apiCalls: [] };
+            this.save();
+        }
+        window.addEventListener("storage", (event) => {
+            if (event.storageArea === localStorage) {
+                this.isActive = localStorage.getItem(this.isSmartDevToolActiveName) === "true";
+                let hoursToSaveString = localStorage.getItem(this.smartDevToolHoursName);
+                if (hoursToSaveString) {
+                    this.hoursToSave = Number.parseInt(hoursToSaveString);
+                }
+                let maxNumOfSavedCalls = localStorage.getItem(this.smartDevToolMaxName);
+                if (maxNumOfSavedCalls) {
+                    this.maxNumOfSavedCalls = Number.parseInt(maxNumOfSavedCalls);
+                }
+            }
+        });
+    }
+    setUpLocalStorage() {
+        let keysOfLocalStorage = Object.keys(localStorage);
+        if (!keysOfLocalStorage.includes(this.isSmartDevToolActiveName)) {
+            localStorage.setItem(this.isSmartDevToolActiveName, "true");
+        }
+    }
+    writeResponse(request, response, requestDate, responseDate) {
+        this.sanitizeByLength();
+        this.sanitizeByTime();
+        let requestHeader = this.createObject(request.headers.keys(), request.headers, false);
+        let responseHeader = this.createObject(response.headers.keys(), response.headers, false);
+        let _localStorage = this.createObject(Object.keys(localStorage).filter((key) => key !== this.smartDevToolName), localStorage, true);
+        let _sessionStorage = this.createObject(Object.keys(sessionStorage), sessionStorage, true);
+        let _cookies = this.cookieService.getAll();
+        this.descriptor.apiCalls = [
+            {
+                url: response.url,
+                requestBody: request.body,
+                requestHeader,
+                requestDate,
+                requestMethod: request.method,
+                responseBody: response.body ?? null,
+                responseHeader,
+                responseStatus: response.status,
+                responseStatusText: response.statusText,
+                responseDate,
+                localStorage: _localStorage,
+                sessionStorage: _sessionStorage,
+                cookies: _cookies,
+            },
+            ...this.descriptor.apiCalls,
+        ];
+        if (response.status !== 200) {
+            this.newErrorsCount++;
+            this.newErrorsCountChanged.next();
+        }
+        this.save();
+    }
+    clearErrors() {
+        this.newErrorsCount = 0;
+        this.newErrorsCountChanged.next();
+    }
+    createObject(keys, mapWithValues, useGetItem) {
+        let newObject = {};
+        keys.forEach((key) => {
+            if (useGetItem) {
+                newObject[key] = mapWithValues.getItem(key);
+            }
+            else {
+                newObject[key] = mapWithValues.get(key);
+            }
+        });
+        return newObject;
+    }
+    sanitizeByTime() {
+        let now = new Date();
+        this.descriptor.apiCalls = this.descriptor.apiCalls.filter((apiCall) => {
+            let hoursBetween;
+            if (typeof apiCall.requestDate === "string") {
+                hoursBetween = Math.floor(Math.abs(now.getMilliseconds() - new Date(apiCall.requestDate).getMilliseconds()) / 36e5);
+            }
+            else {
+                hoursBetween = Math.floor(Math.abs(now.getMilliseconds() - apiCall.requestDate.getMilliseconds()) /
+                    36e5);
+            }
+            return hoursBetween < this.hoursToSave;
+        });
+    }
+    sanitizeByLength() {
+        if (this.descriptor?.apiCalls &&
+            this.descriptor.apiCalls.length > this.maxNumOfSavedCalls) {
+            let length = this.descriptor.apiCalls.length;
+            this.descriptor.apiCalls.splice(this.maxNumOfSavedCalls - 1, length - this.maxNumOfSavedCalls);
+        }
+    }
+    save() {
+        try {
+            localStorage.setItem(this.smartDevToolName, JSON.stringify(this.descriptor));
+            this.descriptorChanged.next();
+        }
+        catch (error) {
+            // localStorage.setItem() throws a "QuotaExceededError" DOMException exception if the new value
+            // couldn't be set. (Setting could fail if, e.g., the user has disabled storage for the site,
+            // or if the quota has been exceeded.)
+            this.sanitizeByLength();
+            this.save();
+        }
+    }
+    clear() {
+        this.descriptor = {
+            apiCalls: [],
+        };
+        this.save();
+    }
+    getPureString() {
+        return localStorage.getItem(this.smartDevToolName);
+    }
+}
+SmartDevToolService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolService, deps: [{ token: i1.SmartCookieService }], target: i0.ɵɵFactoryTarget.Injectable });
+SmartDevToolService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SmartCookieService }]; } });
+export class SmartDevToolDatePipe extends DatePipe {
+    transform(value, format = "yyyy.MM.dd. H:mm:ss") {
+        return super.transform(value, format);
+    }
+}
+SmartDevToolDatePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolDatePipe, deps: null, target: i0.ɵɵFactoryTarget.Pipe });
+SmartDevToolDatePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolDatePipe, name: "smartDevToolDatePipe" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolDatePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: "smartDevToolDatePipe",
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smart-dev-tool.service.js","sourceRoot":"","sources":["../../../../../../projects/smart-ng-client/src/lib/session/dev-tool/smart-dev-tool.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { DatePipe } from \"@angular/common\";\nimport { HttpErrorResponse, HttpRequest, HttpResponse } from \"@angular/common/http\";\nimport { Injectable, Pipe, PipeTransform } from \"@angular/core\";\nimport { Subject } from \"rxjs\";\nimport { SmartCookieService } from \"../cookie-service/smart-cookie.service\";\n\n@Injectable({\n    providedIn: \"root\",\n})\nexport class SmartDevToolService {\n    descriptor?: SmartDevToolDescriptor;\n\n    smartDevToolName: string = \"smartDevTool\";\n    isSmartDevToolActiveName: string = \"smartDevToolActive\";\n    isActive: boolean = false;\n    smartDevToolHoursName: string = \"smartDevToolHours\";\n    smartDevToolMaxName: string = \"smartDevToolMaxCalls\";\n    hoursToSave: number = 1;\n    maxNumOfSavedCalls: number = 50;\n\n    descriptorChanged: Subject<void> = new Subject();\n\n    newErrorsCount: number = 0;\n    newErrorsCountChanged: Subject<void> = new Subject();\n\n    constructor(private cookieService: SmartCookieService) {\n        this.setUpLocalStorage();\n\n        let apiCallsFromLocalStorage = localStorage.getItem(this.smartDevToolName);\n        if (apiCallsFromLocalStorage) {\n            this.descriptor = JSON.parse(apiCallsFromLocalStorage);\n        } else {\n            this.descriptor = { apiCalls: [] };\n            this.save();\n        }\n\n        window.addEventListener(\"storage\", (event) => {\n            if (event.storageArea === localStorage) {\n                this.isActive = localStorage.getItem(this.isSmartDevToolActiveName) === \"true\";\n                let hoursToSaveString = localStorage.getItem(this.smartDevToolHoursName);\n                if (hoursToSaveString) {\n                    this.hoursToSave = Number.parseInt(hoursToSaveString);\n                }\n                let maxNumOfSavedCalls = localStorage.getItem(this.smartDevToolMaxName);\n                if (maxNumOfSavedCalls) {\n                    this.maxNumOfSavedCalls = Number.parseInt(maxNumOfSavedCalls);\n                }\n            }\n        });\n    }\n\n    private setUpLocalStorage(): void {\n        let keysOfLocalStorage = Object.keys(localStorage);\n        if (!keysOfLocalStorage.includes(this.isSmartDevToolActiveName)) {\n            localStorage.setItem(this.isSmartDevToolActiveName, \"true\");\n        }\n    }\n\n    writeResponse(\n        request: HttpRequest<any>,\n        response: HttpResponse<any> | HttpErrorResponse,\n        requestDate: Date,\n        responseDate: Date\n    ): void {\n        this.sanitizeByLength();\n        this.sanitizeByTime();\n\n        let requestHeader: any = this.createObject(request.headers.keys(), request.headers, false);\n        let responseHeader: any = this.createObject(\n            response.headers.keys(),\n            response.headers,\n            false\n        );\n\n        let _localStorage: any = this.createObject(\n            Object.keys(localStorage).filter((key: string) => key !== this.smartDevToolName),\n            localStorage,\n            true\n        );\n        let _sessionStorage: any = this.createObject(\n            Object.keys(sessionStorage),\n            sessionStorage,\n            true\n        );\n        let _cookies: any = this.cookieService.getAll();\n\n        this.descriptor!.apiCalls = [\n            {\n                url: response.url,\n                requestBody: request.body,\n                requestHeader,\n                requestDate,\n                requestMethod: request.method,\n                responseBody: (response as HttpResponse<any>).body ?? null,\n                responseHeader,\n                responseStatus: response.status,\n                responseStatusText: response.statusText,\n                responseDate,\n                localStorage: _localStorage,\n                sessionStorage: _sessionStorage,\n                cookies: _cookies,\n            },\n            ...this.descriptor!.apiCalls,\n        ];\n\n        if (response.status !== 200) {\n            this.newErrorsCount++;\n            this.newErrorsCountChanged.next();\n        }\n\n        this.save();\n    }\n\n    clearErrors(): void {\n        this.newErrorsCount = 0;\n        this.newErrorsCountChanged.next();\n    }\n\n    createObject(keys: string[], mapWithValues: any, useGetItem: boolean): any {\n        let newObject: any = {};\n        keys.forEach((key: string) => {\n            if (useGetItem) {\n                newObject[key] = mapWithValues.getItem(key);\n            } else {\n                newObject[key] = mapWithValues.get(key);\n            }\n        });\n        return newObject;\n    }\n\n    sanitizeByTime(): void {\n        let now: Date = new Date();\n        this.descriptor!.apiCalls = this.descriptor!.apiCalls.filter(\n            (apiCall: SmartDevToolApiCallDescriptor) => {\n                let hoursBetween: number;\n                if (typeof apiCall.requestDate === \"string\") {\n                    hoursBetween = Math.floor(\n                        Math.abs(\n                            now.getMilliseconds() - new Date(apiCall.requestDate).getMilliseconds()\n                        ) / 36e5\n                    );\n                } else {\n                    hoursBetween = Math.floor(\n                        Math.abs(now.getMilliseconds() - apiCall.requestDate.getMilliseconds()) /\n                            36e5\n                    );\n                }\n\n                return hoursBetween < this.hoursToSave;\n            }\n        );\n    }\n\n    sanitizeByLength(): void {\n        if (\n            this.descriptor?.apiCalls &&\n            this.descriptor.apiCalls.length > this.maxNumOfSavedCalls\n        ) {\n            let length = this.descriptor.apiCalls.length;\n            this.descriptor.apiCalls.splice(\n                this.maxNumOfSavedCalls - 1,\n                length - this.maxNumOfSavedCalls\n            );\n        }\n    }\n\n    save(): void {\n        try {\n            localStorage.setItem(this.smartDevToolName, JSON.stringify(this.descriptor));\n            this.descriptorChanged.next();\n        } catch (error: any) {\n            // localStorage.setItem() throws a \"QuotaExceededError\" DOMException exception if the new value\n            // couldn't be set. (Setting could fail if, e.g., the user has disabled storage for the site,\n            // or if the quota has been exceeded.)\n            this.sanitizeByLength();\n            this.save();\n        }\n    }\n\n    clear(): void {\n        this.descriptor = {\n            apiCalls: [],\n        };\n        this.save();\n    }\n\n    getPureString(): string {\n        return localStorage.getItem(this.smartDevToolName)!;\n    }\n}\n\nexport interface SmartDevToolDescriptor {\n    apiCalls: SmartDevToolApiCallDescriptor[];\n}\n\nexport interface SmartDevToolApiCallDescriptor {\n    url: string | null;\n    responseBody: any;\n    responseHeader: any;\n    responseStatus: number;\n    responseStatusText: string;\n    responseDate: Date;\n    requestHeader: any;\n    requestBody: any;\n    requestDate: Date;\n    requestMethod: string;\n    localStorage: any;\n    sessionStorage: any;\n    cookies: any;\n}\n\n@Pipe({\n    name: \"smartDevToolDatePipe\",\n})\nexport class SmartDevToolDatePipe extends DatePipe implements PipeTransform {\n    override transform(value: any, format: string = \"yyyy.MM.dd. H:mm:ss\"): any {\n        return super.transform(value, format);\n    }\n}\n"]}

package/esm2020/lib/session/projects.mjs

@@ -0,0 +1,12 @@
+/*
+ * Public API Surface of smart-session
+ */
+export * from "./smart-session.service";
+export * from "./api/index";
+export * from "./smart-session.module";
+export * from "./dev-tool/smart-dev-tool-floating-button/smart-dev-tool-floating-button.component";
+export * from "./dev-tool/smart-dev-tool.service";
+export * from "./smart-session-handler.service";
+export * from "./smart-timer/smart-session-timer.component";
+export * from "./smart-timer/smart-session-timer.service";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvamVjdHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zbWFydC1uZy1jbGllbnQvc3JjL2xpYi9zZXNzaW9uL3Byb2plY3RzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsb0ZBQW9GLENBQUM7QUFDbkcsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsNkNBQTZDLENBQUM7QUFDNUQsY0FBYywyQ0FBMkMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2Ygc21hcnQtc2Vzc2lvblxuICovXG5cbmV4cG9ydCAqIGZyb20gXCIuL3NtYXJ0LXNlc3Npb24uc2VydmljZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vYXBpL2luZGV4XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zbWFydC1zZXNzaW9uLm1vZHVsZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGV2LXRvb2wvc21hcnQtZGV2LXRvb2wtZmxvYXRpbmctYnV0dG9uL3NtYXJ0LWRldi10b29sLWZsb2F0aW5nLWJ1dHRvbi5jb21wb25lbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2Rldi10b29sL3NtYXJ0LWRldi10b29sLnNlcnZpY2VcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3NtYXJ0LXNlc3Npb24taGFuZGxlci5zZXJ2aWNlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zbWFydC10aW1lci9zbWFydC1zZXNzaW9uLXRpbWVyLmNvbXBvbmVudFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vc21hcnQtdGltZXIvc21hcnQtc2Vzc2lvbi10aW1lci5zZXJ2aWNlXCI7XG4iXX0=

package/esm2020/lib/session/smart-error-catching.interceptor.mjs

@@ -0,0 +1,71 @@
+import { Injectable } from "@angular/core";
+import { from, throwError } from "rxjs";
+import { catchError, switchMap } from "rxjs/operators";
+import { SessionErrorBehaviour, } from "./projects";
+import * as i0 from "@angular/core";
+import * as i1 from "./projects";
+export class SmartErrorCatchingInterceptor {
+    constructor(session) {
+        this.session = session;
+        this.sessionErrorCodes = [
+            {
+                code: "session.expired",
+                behaviour: SessionErrorBehaviour.REFRESH,
+            },
+            {
+                code: "session.refreshtoken.invalid",
+                behaviour: SessionErrorBehaviour.RESTART,
+            },
+            {
+                code: "session.badrequest.missingtoken",
+                behaviour: SessionErrorBehaviour.RESTART,
+            },
+            {
+                code: "session.security.nocontext",
+                behaviour: SessionErrorBehaviour.RESTART,
+            },
+            {
+                code: "session.invalidsessionuri",
+                behaviour: SessionErrorBehaviour.RESTART,
+            },
+            {
+                code: "session.notinitialized",
+                behaviour: SessionErrorBehaviour.RESTART,
+            },
+            {
+                code: "session.viewcontext.missing",
+                behaviour: SessionErrorBehaviour.RESTART,
+            },
+        ];
+    }
+    intercept(request, next) {
+        return next.handle(request).pipe(catchError((error) => {
+            if (error.status === 400 && error.error.code) {
+                let sessionError = this.sessionErrorCodes.find((sessionError) => sessionError.code === error.error.code);
+                if (sessionError) {
+                    return this.resolveError(sessionError).pipe(switchMap(() => {
+                        this.session.headerParams.map((headerParam) => {
+                            request = request.clone({
+                                headers: request.headers.set(headerParam.headerName, headerParam.value),
+                            });
+                        });
+                        return next.handle(request);
+                    }));
+                }
+            }
+            return throwError(error);
+        }));
+    }
+    resolveError(sessionError) {
+        if (sessionError.behaviour === SessionErrorBehaviour.RESTART) {
+            return from(this.session.handleSessionError(sessionError));
+        }
+        return from(this.session.refreshSession());
+    }
+}
+SmartErrorCatchingInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartErrorCatchingInterceptor, deps: [{ token: i1.SmartSessionService }], target: i0.ɵɵFactoryTarget.Injectable });
+SmartErrorCatchingInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartErrorCatchingInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartErrorCatchingInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.SmartSessionService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnQtZXJyb3ItY2F0Y2hpbmcuaW50ZXJjZXB0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zbWFydC1uZy1jbGllbnQvc3JjL2xpYi9zZXNzaW9uL3NtYXJ0LWVycm9yLWNhdGNoaW5nLmludGVyY2VwdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU9BLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFFLElBQUksRUFBYyxVQUFVLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFDcEQsT0FBTyxFQUFFLFVBQVUsRUFBRSxTQUFTLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUN2RCxPQUFPLEVBSUgscUJBQXFCLEdBRXhCLE1BQU0sWUFBWSxDQUFDOzs7QUFHcEIsTUFBTSxPQUFPLDZCQUE2QjtJQWdDdEMsWUFBb0IsT0FBNEI7UUFBNUIsWUFBTyxHQUFQLE9BQU8sQ0FBcUI7UUEvQmhELHNCQUFpQixHQUFtQjtZQUNoQztnQkFDSSxJQUFJLEVBQUUsaUJBQWlCO2dCQUN2QixTQUFTLEVBQUUscUJBQXFCLENBQUMsT0FBTzthQUMzQztZQUNEO2dCQUNJLElBQUksRUFBRSw4QkFBOEI7Z0JBQ3BDLFNBQVMsRUFBRSxxQkFBcUIsQ0FBQyxPQUFPO2FBQzNDO1lBQ0Q7Z0JBQ0ksSUFBSSxFQUFFLGlDQUFpQztnQkFDdkMsU0FBUyxFQUFFLHFCQUFxQixDQUFDLE9BQU87YUFDM0M7WUFDRDtnQkFDSSxJQUFJLEVBQUUsNEJBQTRCO2dCQUNsQyxTQUFTLEVBQUUscUJBQXFCLENBQUMsT0FBTzthQUMzQztZQUNEO2dCQUNJLElBQUksRUFBRSwyQkFBMkI7Z0JBQ2pDLFNBQVMsRUFBRSxxQkFBcUIsQ0FBQyxPQUFPO2FBQzNDO1lBQ0Q7Z0JBQ0ksSUFBSSxFQUFFLHdCQUF3QjtnQkFDOUIsU0FBUyxFQUFFLHFCQUFxQixDQUFDLE9BQU87YUFDM0M7WUFDRDtnQkFDSSxJQUFJLEVBQUUsNkJBQTZCO2dCQUNuQyxTQUFTLEVBQUUscUJBQXFCLENBQUMsT0FBTzthQUMzQztTQUNKLENBQUM7SUFFaUQsQ0FBQztJQUVwRCxTQUFTLENBQUMsT0FBNkIsRUFBRSxJQUFpQjtRQUN0RCxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUMsSUFBSSxDQUM1QixVQUFVLENBQUMsQ0FBQyxLQUF3QixFQUFFLEVBQUU7WUFDcEMsSUFBSSxLQUFLLENBQUMsTUFBTSxLQUFLLEdBQUcsSUFBSyxLQUFLLENBQUMsS0FBa0IsQ0FBQyxJQUFJLEVBQUU7Z0JBQ3hELElBQUksWUFBWSxHQUFHLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxJQUFJLENBQzFDLENBQUMsWUFBMEIsRUFBRSxFQUFFLENBQzNCLFlBQVksQ0FBQyxJQUFJLEtBQU0sS0FBSyxDQUFDLEtBQWtCLENBQUMsSUFBSSxDQUMzRCxDQUFDO2dCQUNGLElBQUksWUFBWSxFQUFFO29CQUNkLE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQyxZQUFZLENBQUMsQ0FBQyxJQUFJLENBQ3ZDLFNBQVMsQ0FBQyxHQUFHLEVBQUU7d0JBQ1gsSUFBSSxDQUFDLE9BQU8sQ0FBQyxZQUFZLENBQUMsR0FBRyxDQUFDLENBQUMsV0FBd0IsRUFBRSxFQUFFOzRCQUN2RCxPQUFPLEdBQUcsT0FBTyxDQUFDLEtBQUssQ0FBQztnQ0FDcEIsT0FBTyxFQUFFLE9BQU8sQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUN4QixXQUFXLENBQUMsVUFBVSxFQUN0QixXQUFXLENBQUMsS0FBSyxDQUNwQjs2QkFDSixDQUFDLENBQUM7d0JBQ1AsQ0FBQyxDQUFDLENBQUM7d0JBQ0gsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDO29CQUNoQyxDQUFDLENBQUMsQ0FDTCxDQUFDO2lCQUNMO2FBQ0o7WUFFRCxPQUFPLFVBQVUsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUM3QixDQUFDLENBQUMsQ0FDTCxDQUFDO0lBQ04sQ0FBQztJQUVELFlBQVksQ0FBQyxZQUEwQjtRQUNuQyxJQUFJLFlBQVksQ0FBQyxTQUFTLEtBQUsscUJBQXFCLENBQUMsT0FBTyxFQUFFO1lBQzFELE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsa0JBQWtCLENBQUMsWUFBWSxDQUFDLENBQUMsQ0FBQztTQUM5RDtRQUNELE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsY0FBYyxFQUFFLENBQUMsQ0FBQztJQUMvQyxDQUFDOzsySEFyRVEsNkJBQTZCOytIQUE3Qiw2QkFBNkI7NEZBQTdCLDZCQUE2QjtrQkFEekMsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gICAgSHR0cEVycm9yUmVzcG9uc2UsXG4gICAgSHR0cEV2ZW50LFxuICAgIEh0dHBIYW5kbGVyLFxuICAgIEh0dHBJbnRlcmNlcHRvcixcbiAgICBIdHRwUmVxdWVzdCxcbn0gZnJvbSBcIkBhbmd1bGFyL2NvbW1vbi9odHRwXCI7XG5pbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcbmltcG9ydCB7IGZyb20sIE9ic2VydmFibGUsIHRocm93RXJyb3IgfSBmcm9tIFwicnhqc1wiO1xuaW1wb3J0IHsgY2F0Y2hFcnJvciwgc3dpdGNoTWFwIH0gZnJvbSBcInJ4anMvb3BlcmF0b3JzXCI7XG5pbXBvcnQge1xuICAgIEFwaUVycm9yLFxuICAgIEhlYWRlclBhcmFtLFxuICAgIFNlc3Npb25FcnJvcixcbiAgICBTZXNzaW9uRXJyb3JCZWhhdmlvdXIsXG4gICAgU21hcnRTZXNzaW9uU2VydmljZSxcbn0gZnJvbSBcIi4vcHJvamVjdHNcIjtcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIFNtYXJ0RXJyb3JDYXRjaGluZ0ludGVyY2VwdG9yIGltcGxlbWVudHMgSHR0cEludGVyY2VwdG9yIHtcbiAgICBzZXNzaW9uRXJyb3JDb2RlczogU2Vzc2lvbkVycm9yW10gPSBbXG4gICAgICAgIHtcbiAgICAgICAgICAgIGNvZGU6IFwic2Vzc2lvbi5leHBpcmVkXCIsXG4gICAgICAgICAgICBiZWhhdmlvdXI6IFNlc3Npb25FcnJvckJlaGF2aW91ci5SRUZSRVNILFxuICAgICAgICB9LFxuICAgICAgICB7XG4gICAgICAgICAgICBjb2RlOiBcInNlc3Npb24ucmVmcmVzaHRva2VuLmludmFsaWRcIixcbiAgICAgICAgICAgIGJlaGF2aW91cjogU2Vzc2lvbkVycm9yQmVoYXZpb3VyLlJFU1RBUlQsXG4gICAgICAgIH0sXG4gICAgICAgIHtcbiAgICAgICAgICAgIGNvZGU6IFwic2Vzc2lvbi5iYWRyZXF1ZXN0Lm1pc3Npbmd0b2tlblwiLFxuICAgICAgICAgICAgYmVoYXZpb3VyOiBTZXNzaW9uRXJyb3JCZWhhdmlvdXIuUkVTVEFSVCxcbiAgICAgICAgfSxcbiAgICAgICAge1xuICAgICAgICAgICAgY29kZTogXCJzZXNzaW9uLnNlY3VyaXR5Lm5vY29udGV4dFwiLFxuICAgICAgICAgICAgYmVoYXZpb3VyOiBTZXNzaW9uRXJyb3JCZWhhdmlvdXIuUkVTVEFSVCxcbiAgICAgICAgfSxcbiAgICAgICAge1xuICAgICAgICAgICAgY29kZTogXCJzZXNzaW9uLmludmFsaWRzZXNzaW9udXJpXCIsXG4gICAgICAgICAgICBiZWhhdmlvdXI6IFNlc3Npb25FcnJvckJlaGF2aW91ci5SRVNUQVJULFxuICAgICAgICB9LFxuICAgICAgICB7XG4gICAgICAgICAgICBjb2RlOiBcInNlc3Npb24ubm90aW5pdGlhbGl6ZWRcIixcbiAgICAgICAgICAgIGJlaGF2aW91cjogU2Vzc2lvbkVycm9yQmVoYXZpb3VyLlJFU1RBUlQsXG4gICAgICAgIH0sXG4gICAgICAgIHtcbiAgICAgICAgICAgIGNvZGU6IFwic2Vzc2lvbi52aWV3Y29udGV4dC5taXNzaW5nXCIsXG4gICAgICAgICAgICBiZWhhdmlvdXI6IFNlc3Npb25FcnJvckJlaGF2aW91ci5SRVNUQVJULFxuICAgICAgICB9LFxuICAgIF07XG5cbiAgICBjb25zdHJ1Y3Rvcihwcml2YXRlIHNlc3Npb246IFNtYXJ0U2Vzc2lvblNlcnZpY2UpIHt9XG5cbiAgICBpbnRlcmNlcHQocmVxdWVzdDogSHR0cFJlcXVlc3Q8dW5rbm93bj4sIG5leHQ6IEh0dHBIYW5kbGVyKTogT2JzZXJ2YWJsZTxIdHRwRXZlbnQ8dW5rbm93bj4+IHtcbiAgICAgICAgcmV0dXJuIG5leHQuaGFuZGxlKHJlcXVlc3QpLnBpcGUoXG4gICAgICAgICAgICBjYXRjaEVycm9yKChlcnJvcjogSHR0cEVycm9yUmVzcG9uc2UpID0+IHtcbiAgICAgICAgICAgICAgICBpZiAoZXJyb3Iuc3RhdHVzID09PSA0MDAgJiYgKGVycm9yLmVycm9yIGFzIEFwaUVycm9yKS5jb2RlKSB7XG4gICAgICAgICAgICAgICAgICAgIGxldCBzZXNzaW9uRXJyb3IgPSB0aGlzLnNlc3Npb25FcnJvckNvZGVzLmZpbmQoXG4gICAgICAgICAgICAgICAgICAgICAgICAoc2Vzc2lvbkVycm9yOiBTZXNzaW9uRXJyb3IpID0+XG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgc2Vzc2lvbkVycm9yLmNvZGUgPT09IChlcnJvci5lcnJvciBhcyBBcGlFcnJvcikuY29kZVxuICAgICAgICAgICAgICAgICAgICApO1xuICAgICAgICAgICAgICAgICAgICBpZiAoc2Vzc2lvbkVycm9yKSB7XG4gICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gdGhpcy5yZXNvbHZlRXJyb3Ioc2Vzc2lvbkVycm9yKS5waXBlKFxuICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN3aXRjaE1hcCgoKSA9PiB7XG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRoaXMuc2Vzc2lvbi5oZWFkZXJQYXJhbXMubWFwKChoZWFkZXJQYXJhbTogSGVhZGVyUGFyYW0pID0+IHtcbiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJlcXVlc3QgPSByZXF1ZXN0LmNsb25lKHtcbiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBoZWFkZXJzOiByZXF1ZXN0LmhlYWRlcnMuc2V0KFxuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBoZWFkZXJQYXJhbS5oZWFkZXJOYW1lLFxuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBoZWFkZXJQYXJhbS52YWx1ZVxuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICksXG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9KTtcbiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfSk7XG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBuZXh0LmhhbmRsZShyZXF1ZXN0KTtcbiAgICAgICAgICAgICAgICAgICAgICAgICAgICB9KVxuICAgICAgICAgICAgICAgICAgICAgICAgKTtcbiAgICAgICAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgICAgIH1cblxuICAgICAgICAgICAgICAgIHJldHVybiB0aHJvd0Vycm9yKGVycm9yKTtcbiAgICAgICAgICAgIH0pXG4gICAgICAgICk7XG4gICAgfVxuXG4gICAgcmVzb2x2ZUVycm9yKHNlc3Npb25FcnJvcjogU2Vzc2lvbkVycm9yKTogT2JzZXJ2YWJsZTxhbnk+IHtcbiAgICAgICAgaWYgKHNlc3Npb25FcnJvci5iZWhhdmlvdXIgPT09IFNlc3Npb25FcnJvckJlaGF2aW91ci5SRVNUQVJUKSB7XG4gICAgICAgICAgICByZXR1cm4gZnJvbSh0aGlzLnNlc3Npb24uaGFuZGxlU2Vzc2lvbkVycm9yKHNlc3Npb25FcnJvcikpO1xuICAgICAgICB9XG4gICAgICAgIHJldHVybiBmcm9tKHRoaXMuc2Vzc2lvbi5yZWZyZXNoU2Vzc2lvbigpKTtcbiAgICB9XG59XG4iXX0=

package/esm2020/lib/session/smart-header-maintainer.interceptor.mjs

@@ -0,0 +1,36 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+import * as i1 from "./smart-session.service";
+export class SmartHeaderMaintainerInterceptor {
+    constructor(session) {
+        this.session = session;
+    }
+    intercept(request, next) {
+        const hasHeaders = this.session.headerParams && this.session.headerParams.length;
+        let headers = {};
+        if (hasHeaders) {
+            this.session.headerParams.map((headerParam) => {
+                headers[headerParam.headerName] = headerParam.value;
+            });
+        }
+        let url = request.urlWithParams.replace("http://localhost", this.session.getBasePath());
+        // TODO fix me
+        if (request.urlWithParams.includes("/kerb/sso")) {
+            request = request.clone({
+                url: url,
+            });
+            return next.handle(request);
+        }
+        request = request.clone({
+            url: url,
+            setHeaders: headers,
+        });
+        return next.handle(request);
+    }
+}
+SmartHeaderMaintainerInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartHeaderMaintainerInterceptor, deps: [{ token: i1.SmartSessionService }], target: i0.ɵɵFactoryTarget.Injectable });
+SmartHeaderMaintainerInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartHeaderMaintainerInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartHeaderMaintainerInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.SmartSessionService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/session/smart-session-handler.service.mjs

@@ -0,0 +1,6 @@
+export var SessionErrorBehaviour;
+(function (SessionErrorBehaviour) {
+    SessionErrorBehaviour[SessionErrorBehaviour["REFRESH"] = 0] = "REFRESH";
+    SessionErrorBehaviour[SessionErrorBehaviour["RESTART"] = 1] = "RESTART";
+})(SessionErrorBehaviour || (SessionErrorBehaviour = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnQtc2Vzc2lvbi1oYW5kbGVyLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zbWFydC1uZy1jbGllbnQvc3JjL2xpYi9zZXNzaW9uL3NtYXJ0LXNlc3Npb24taGFuZGxlci5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVNBLE1BQU0sQ0FBTixJQUFZLHFCQUdYO0FBSEQsV0FBWSxxQkFBcUI7SUFDN0IsdUVBQU8sQ0FBQTtJQUNQLHVFQUFPLENBQUE7QUFDWCxDQUFDLEVBSFcscUJBQXFCLEtBQXJCLHFCQUFxQixRQUdoQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgU21hcnRTZXNzaW9uSGFuZGxlclNlcnZpY2Uge1xuICAgIGhhbmRsZVNlc3Npb25FcnJvcihzZXNzaW9uRXJyb3I6IFNlc3Npb25FcnJvcik6IFByb21pc2U8dm9pZD47XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgU2Vzc2lvbkVycm9yIHtcbiAgICBjb2RlOiBzdHJpbmc7XG4gICAgYmVoYXZpb3VyOiBTZXNzaW9uRXJyb3JCZWhhdmlvdXI7XG59XG5cbmV4cG9ydCBlbnVtIFNlc3Npb25FcnJvckJlaGF2aW91ciB7XG4gICAgUkVGUkVTSCxcbiAgICBSRVNUQVJULFxufVxuIl19

package/esm2020/lib/session/smart-session.module.mjs

@@ -0,0 +1,74 @@
+import { HTTP_INTERCEPTORS } from "@angular/common/http";
+import { CUSTOM_ELEMENTS_SCHEMA, NgModule } from "@angular/core";
+import { MatButtonModule } from "@angular/material/button";
+import { MatCommonModule } from "@angular/material/core";
+import { MatExpansionModule } from "@angular/material/expansion";
+import { BrowserModule } from "@angular/platform-browser";
+import { SmartdialogModule } from "@smartbit4all/dialog";
+import { SmartIconModule } from "@smartbit4all/icon";
+import { SmartCookieService } from "./cookie-service/smart-cookie.service";
+import { SmartDevToolDialogComponent } from "./dev-tool/smart-dev-tool-dialog/smart-dev-tool-dialog.component";
+import { SmartDevToolFloatingButtonComponent } from "./dev-tool/smart-dev-tool-floating-button/smart-dev-tool-floating-button.component";
+import { SmartDevToolInterceptor, SmartDevToolErrorInterceptor, } from "./dev-tool/smart-dev-tool.interceptor";
+import { SmartDevToolDatePipe } from "./dev-tool/smart-dev-tool.service";
+import { SmartErrorCatchingInterceptor } from "./smart-error-catching.interceptor";
+import { SmartHeaderMaintainerInterceptor } from "./smart-header-maintainer.interceptor";
+import { SmartSessionService } from "./smart-session.service";
+import { SmartSessionTimerComponent } from "./smart-timer/smart-session-timer.component";
+import * as i0 from "@angular/core";
+export class SmartSessionModule {
+}
+SmartSessionModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartSessionModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SmartSessionModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartSessionModule, declarations: [SmartDevToolDialogComponent,
+        SmartDevToolFloatingButtonComponent,
+        SmartDevToolDatePipe,
+        SmartSessionTimerComponent], imports: [BrowserModule, MatCommonModule, MatExpansionModule, MatButtonModule, SmartIconModule], exports: [SmartDevToolFloatingButtonComponent, SmartSessionTimerComponent] });
+SmartSessionModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartSessionModule, providers: [
+        SmartCookieService,
+        SmartSessionService,
+        SmartdialogModule,
+        {
+            provide: HTTP_INTERCEPTORS,
+            useClass: SmartErrorCatchingInterceptor,
+            multi: true,
+        },
+        {
+            provide: HTTP_INTERCEPTORS,
+            useClass: SmartHeaderMaintainerInterceptor,
+            multi: true,
+        },
+        { provide: HTTP_INTERCEPTORS, useClass: SmartDevToolInterceptor, multi: true },
+        { provide: HTTP_INTERCEPTORS, useClass: SmartDevToolErrorInterceptor, multi: true },
+    ], imports: [[BrowserModule, MatCommonModule, MatExpansionModule, MatButtonModule, SmartIconModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartSessionModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        SmartDevToolDialogComponent,
+                        SmartDevToolFloatingButtonComponent,
+                        SmartDevToolDatePipe,
+                        SmartSessionTimerComponent,
+                    ],
+                    imports: [BrowserModule, MatCommonModule, MatExpansionModule, MatButtonModule, SmartIconModule],
+                    exports: [SmartDevToolFloatingButtonComponent, SmartSessionTimerComponent],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    providers: [
+                        SmartCookieService,
+                        SmartSessionService,
+                        SmartdialogModule,
+                        {
+                            provide: HTTP_INTERCEPTORS,
+                            useClass: SmartErrorCatchingInterceptor,
+                            multi: true,
+                        },
+                        {
+                            provide: HTTP_INTERCEPTORS,
+                            useClass: SmartHeaderMaintainerInterceptor,
+                            multi: true,
+                        },
+                        { provide: HTTP_INTERCEPTORS, useClass: SmartDevToolInterceptor, multi: true },
+                        { provide: HTTP_INTERCEPTORS, useClass: SmartDevToolErrorInterceptor, multi: true },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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