@igo2/core 1.15.4 → 16.0.0-rc.0

package/{fesm2020 → fesm2022}/igo2-core.mjs

@@ -1,1363 +1,1439 @@
 import * as i0 from '@angular/core';
 import { Injectable, NgModule, InjectionToken, APP_INITIALIZER, Injector, Inject, Optional, SkipSelf, EventEmitter } from '@angular/core';
 import { CommonModule } from '@angular/common';
-import { HTTP_INTERCEPTORS, HttpClient, HttpErrorResponse, HttpClientModule, HttpResponse } from '@angular/common/http';
+import * as i1 from '@angular/common/http';
+import { HTTP_INTERCEPTORS, HttpClient, HttpBackend, HttpErrorResponse, HttpClientModule, HttpResponse } from '@angular/common/http';
+import * as i2 from '@angular/platform-browser';
+import { HammerGestureConfig, HAMMER_GESTURE_CONFIG, HammerModule } from '@angular/platform-browser';
+import * as i1$3 from '@angular/material/icon';
 import { finalize, catchError, debounceTime, first, tap, startWith } from 'rxjs/operators';
 import { BehaviorSubject, throwError, forkJoin, map, combineLatest, Observable, fromEvent } from 'rxjs';
 import { uuid, ObjectUtils } from '@igo2/utils';
-import * as i1 from '@ngx-translate/core';
+import * as i1$1 from '@ngx-translate/core';
 import { TranslateLoader, TranslateModule, MissingTranslationHandler } from '@ngx-translate/core';
-import * as i1$1 from 'ngx-toastr';
+import * as i1$2 from 'ngx-toastr';
 import { ToastrModule, ToastrService } from 'ngx-toastr';
 import * as i8 from 'ngx-indexed-db';
 import { NgxIndexedDBModule } from 'ngx-indexed-db';
-import * as i1$2 from '@angular/material/icon';
-import * as i2 from '@angular/platform-browser';
-import { HammerGestureConfig, HAMMER_GESTURE_CONFIG, HammerModule } from '@angular/platform-browser';
-import * as i1$3 from '@angular/router';
-import * as i1$4 from '@angular/cdk/layout';
+import * as i1$4 from '@angular/router';
+import * as i1$5 from '@angular/cdk/layout';
 import { Breakpoints } from '@angular/cdk/layout';
 
-class ActivityService {
-    constructor() {
-        this.counter$ = new BehaviorSubject(0);
-        this.ids = [];
-    }
-    register() {
-        const id = uuid();
-        this.ids.push(id);
-        this.counter$.next(this.ids.length);
-        return id;
-    }
-    unregister(id) {
-        const index = this.ids.indexOf(id);
-        if (index === -1) {
-            return;
-        }
-        this.ids.splice(index, 1);
-        this.counter$.next(this.ids.length);
-    }
-}
-ActivityService.ɵfac = function ActivityService_Factory(t) { return new (t || ActivityService)(); };
-ActivityService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ActivityService, factory: ActivityService.ɵfac, providedIn: 'root' });
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ActivityService, [{
-        type: Injectable,
-        args: [{
-                providedIn: 'root'
-            }]
+class ActivityService {
+    counter$ = new BehaviorSubject(0);
+    ids = [];
+    constructor() { }
+    register() {
+        const id = uuid();
+        this.ids.push(id);
+        this.counter$.next(this.ids.length);
+        return id;
+    }
+    unregister(id) {
+        const index = this.ids.indexOf(id);
+        if (index === -1) {
+            return;
+        }
+        this.ids.splice(index, 1);
+        this.counter$.next(this.ids.length);
+    }
+    static ɵfac = function ActivityService_Factory(t) { return new (t || ActivityService)(); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ActivityService, factory: ActivityService.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ActivityService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
     }], function () { return []; }, null); })();
 
-class ActivityInterceptor {
-    constructor(activityService) {
-        this.activityService = activityService;
-    }
-    intercept(req, next) {
-        const activity = req.headers.get('activityInterceptor');
-        if (activity) {
-            const actReq = req.clone({
-                headers: req.headers.delete('activityInterceptor')
-            });
-            if (activity === 'false') {
-                return next.handle(actReq);
-            }
-        }
-        const id = this.activityService.register();
-        return next.handle(req).pipe(finalize(() => {
-            this.activityService.unregister(id);
-        }));
-    }
-}
-ActivityInterceptor.ɵfac = function ActivityInterceptor_Factory(t) { return new (t || ActivityInterceptor)(i0.ɵɵinject(ActivityService)); };
-ActivityInterceptor.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ActivityInterceptor, factory: ActivityInterceptor.ɵfac });
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ActivityInterceptor, [{
-        type: Injectable
+class ActivityInterceptor {
+    activityService;
+    constructor(activityService) {
+        this.activityService = activityService;
+    }
+    intercept(req, next) {
+        const activity = req.headers.get('activityInterceptor');
+        if (activity) {
+            const actReq = req.clone({
+                headers: req.headers.delete('activityInterceptor')
+            });
+            if (activity === 'false') {
+                return next.handle(actReq);
+            }
+        }
+        const id = this.activityService.register();
+        return next.handle(req).pipe(finalize(() => {
+            this.activityService.unregister(id);
+        }));
+    }
+    static ɵfac = function ActivityInterceptor_Factory(t) { return new (t || ActivityInterceptor)(i0.ɵɵinject(ActivityService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ActivityInterceptor, factory: ActivityInterceptor.ɵfac });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ActivityInterceptor, [{
+        type: Injectable
     }], function () { return [{ type: ActivityService }]; }, null); })();
 
-class IgoActivityModule {
-    static forRoot() {
-        return {
-            ngModule: IgoActivityModule,
-            providers: [
-                {
-                    provide: HTTP_INTERCEPTORS,
-                    useClass: ActivityInterceptor,
-                    multi: true
-                }
-            ]
-        };
-    }
-}
-IgoActivityModule.ɵfac = function IgoActivityModule_Factory(t) { return new (t || IgoActivityModule)(); };
-IgoActivityModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoActivityModule });
-IgoActivityModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({});
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoActivityModule, [{
-        type: NgModule,
-        args: [{
-                imports: [],
-                declarations: [],
-                exports: []
-            }]
+class IgoActivityModule {
+    static forRoot() {
+        return {
+            ngModule: IgoActivityModule,
+            providers: [
+                {
+                    provide: HTTP_INTERCEPTORS,
+                    useClass: ActivityInterceptor,
+                    multi: true
+                }
+            ]
+        };
+    }
+    static ɵfac = function IgoActivityModule_Factory(t) { return new (t || IgoActivityModule)(); };
+    static ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoActivityModule });
+    static ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({});
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoActivityModule, [{
+        type: NgModule,
+        args: [{
+                imports: [],
+                declarations: [],
+                exports: []
+            }]
     }], null, null); })();
 
-const version = {
-    lib: '1.15.4',
-    releaseDate: 1688557109892
+const version = {
+    lib: '16.0.0-rc.0',
+    releaseDate: 1695139270215
 };
 
-class ConfigService {
-    constructor(injector) {
-        this.injector = injector;
-        this.config = {};
-    }
-    /**
-     * Use to get the data found in config file
-     */
-    getConfig(key) {
-        return ObjectUtils.resolve(this.config, key);
-    }
-    /**
-     * This method loads "[path]" to get all config's variables
-     */
-    load(options) {
-        const baseConfig = options.default || {};
-        if (!options.path) {
-            this.config = baseConfig;
-            return true;
-        }
-        const http = this.injector.get(HttpClient);
-        return new Promise((resolve, _reject) => {
-            http
-                .get(options.path)
-                .pipe(catchError((error) => {
-                console.log(`Configuration file ${options.path} could not be read`);
-                resolve(true);
-                return throwError(error.error || 'Server error');
-            }))
-                .subscribe((configResponse) => {
-                this.config = ObjectUtils.mergeDeep(ObjectUtils.mergeDeep({ version }, baseConfig), configResponse);
-                resolve(true);
-            });
-        });
-    }
-}
-ConfigService.ɵfac = function ConfigService_Factory(t) { return new (t || ConfigService)(i0.ɵɵinject(i0.Injector)); };
-ConfigService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ConfigService, factory: ConfigService.ɵfac, providedIn: 'root' });
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ConfigService, [{
-        type: Injectable,
-        args: [{
-                providedIn: 'root'
-            }]
-    }], function () { return [{ type: i0.Injector }]; }, null); })();
+class ConfigService {
+    config = {};
+    httpClient;
+    constructor(handler) {
+        this.httpClient = new HttpClient(handler);
+    }
+    /**
+     * Use to get the data found in config file
+     */
+    getConfig(key) {
+        return ObjectUtils.resolve(this.config, key);
+    }
+    /**
+     * This method loads "[path]" to get all config's variables
+     */
+    load(options) {
+        const baseConfig = options.default || {};
+        if (!options.path) {
+            this.config = baseConfig;
+            return true;
+        }
+        return new Promise((resolve, _reject) => {
+            this.httpClient
+                .get(options.path)
+                .pipe(catchError((error) => {
+                console.log(`Configuration file ${options.path} could not be read`);
+                resolve(true);
+                return throwError(error.error || 'Server error');
+            }))
+                .subscribe((configResponse) => {
+                this.config = ObjectUtils.mergeDeep(ObjectUtils.mergeDeep({ version }, baseConfig), configResponse);
+                resolve(true);
+            });
+        });
+    }
+    static ɵfac = function ConfigService_Factory(t) { return new (t || ConfigService)(i0.ɵɵinject(i1.HttpBackend)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ConfigService, factory: ConfigService.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ConfigService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.HttpBackend }]; }, null); })();
 
-let CONFIG_OPTIONS = new InjectionToken('configOptions');
-function provideConfigOptions(options) {
-    return {
-        provide: CONFIG_OPTIONS,
-        useValue: options
-    };
-}
-function configFactory(configService, options) {
-    return () => configService.load(options);
-}
-function provideConfigLoader() {
-    return {
-        provide: APP_INITIALIZER,
-        useFactory: configFactory,
-        multi: true,
-        deps: [ConfigService, CONFIG_OPTIONS]
-    };
+let CONFIG_OPTIONS = new InjectionToken('configOptions');
+function provideConfigOptions(options) {
+    return {
+        provide: CONFIG_OPTIONS,
+        useValue: options
+    };
+}
+function configFactory(configService, options) {
+    return () => configService.load(options);
+}
+function provideConfigLoader() {
+    return {
+        provide: APP_INITIALIZER,
+        useFactory: configFactory,
+        multi: true,
+        deps: [ConfigService, CONFIG_OPTIONS]
+    };
 }
 
-class IgoConfigModule {
-    static forRoot() {
-        return {
-            ngModule: IgoConfigModule,
-            providers: [provideConfigOptions({}), provideConfigLoader()]
-        };
-    }
-}
-IgoConfigModule.ɵfac = function IgoConfigModule_Factory(t) { return new (t || IgoConfigModule)(); };
-IgoConfigModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoConfigModule });
-IgoConfigModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({});
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoConfigModule, [{
-        type: NgModule,
-        args: [{
-                imports: [],
-                declarations: [],
-                exports: []
-            }]
+class IgoConfigModule {
+    static forRoot() {
+        return {
+            ngModule: IgoConfigModule,
+            providers: [provideConfigOptions({}), provideConfigLoader()]
+        };
+    }
+    static ɵfac = function IgoConfigModule_Factory(t) { return new (t || IgoConfigModule)(); };
+    static ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoConfigModule });
+    static ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({});
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoConfigModule, [{
+        type: NgModule,
+        args: [{
+                imports: [],
+                declarations: [],
+                exports: []
+            }]
     }], null, null); })();
 
-class LanguageLoader {
-    constructor(http, prefix, suffix = '.json', config) {
-        this.http = http;
-        this.prefix = prefix;
-        this.suffix = suffix;
-        this.config = config;
-    }
-    getTranslation(lang) {
-        const igoLocale$ = this.http.get(`locale/libs_locale/${lang}.json`);
-        if (this.config && !this.prefix) {
-            const prefix = this.config.getConfig('language.prefix');
-            this.prefix = !prefix || Array.isArray(prefix) ? prefix : [prefix];
-        }
-        if (!this.prefix || this.prefix.length === 0) {
-            return igoLocale$;
-        }
-        const appLocale$ = this.prefix.map((prefix) => this.http.get(`${prefix}${lang}${this.suffix}`));
-        const locale$ = forkJoin([igoLocale$, ...appLocale$]);
-        return locale$.pipe(map((translations) => {
-            return translations.reduce((acc, current) => ObjectUtils.mergeDeep(acc, current), {});
-        }));
-    }
+class LanguageLoader {
+    prefix;
+    suffix;
+    config;
+    httpClient;
+    constructor(handler, prefix, suffix = '.json', config) {
+        this.prefix = prefix;
+        this.suffix = suffix;
+        this.config = config;
+        this.httpClient = new HttpClient(handler);
+    }
+    getTranslation(lang) {
+        const igoLocale$ = this.httpClient.get(`locale/libs_locale/${lang}.json`);
+        if (this.config && !this.prefix) {
+            const prefix = this.config.getConfig('language.prefix');
+            this.prefix = !prefix || Array.isArray(prefix) ? prefix : [prefix];
+        }
+        if (!this.prefix || this.prefix.length === 0) {
+            return igoLocale$;
+        }
+        const appLocale$ = this.prefix.map((prefix) => this.httpClient.get(`${prefix}${lang}${this.suffix}`));
+        const locale$ = forkJoin([igoLocale$, ...appLocale$]);
+        return locale$.pipe(map((translations) => {
+            return translations.reduce((acc, current) => ObjectUtils.mergeDeep(acc, current), {});
+        }));
+    }
 }
 
-function defaultLanguageLoader(http, config) {
-    return new LanguageLoader(http, undefined, undefined, config);
-}
-function provideLanguageLoader(loader) {
-    return {
-        provide: TranslateLoader,
-        useFactory: loader || defaultLanguageLoader,
-        deps: [HttpClient]
-    };
-}
-function provideDefaultLanguageLoader(loader) {
-    return {
-        provide: TranslateLoader,
-        useFactory: loader || defaultLanguageLoader,
-        deps: [HttpClient, ConfigService]
-    };
+function defaultLanguageLoader(http, config) {
+    return new LanguageLoader(http, undefined, undefined, config);
+}
+function provideLanguageLoader(loader) {
+    return {
+        provide: TranslateLoader,
+        useFactory: loader || defaultLanguageLoader,
+        deps: [HttpBackend]
+    };
+}
+function provideDefaultLanguageLoader(loader) {
+    return {
+        provide: TranslateLoader,
+        useFactory: loader || defaultLanguageLoader,
+        deps: [HttpBackend, ConfigService]
+    };
 }
 
-class IgoMissingTranslationHandler {
-    handle(params) {
-        if (!params.translateService.langs.length) {
-            const error = 'Translations are not yet loaded. \
-         Check that the LanguageService is injected.';
-            throw new Error(error);
-        }
-        if (params.key.substr(0, 4) === 'igo.') {
-            throw new Error(`The Key "${params.key}" is missing in locale file.`);
-        }
-        else {
-            return params.key;
-        }
-    }
+class IgoMissingTranslationHandler {
+    handle(params) {
+        if (!params.translateService.langs.length) {
+            const error = 'Translations are not yet loaded. \
+         Check that the LanguageService is injected.';
+            throw new Error(error);
+        }
+        if (params.key.substr(0, 4) === 'igo.') {
+            throw new Error(`The Key "${params.key}" is missing in locale file.`);
+        }
+        else {
+            return params.key;
+        }
+    }
 }
 
-class IgoLanguageModule {
-    static forRoot() {
-        return {
-            ngModule: IgoLanguageModule,
-            providers: [provideDefaultLanguageLoader()]
-        };
-    }
-}
-IgoLanguageModule.ɵfac = function IgoLanguageModule_Factory(t) { return new (t || IgoLanguageModule)(); };
-IgoLanguageModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoLanguageModule });
-IgoLanguageModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [TranslateModule.forRoot({
-            missingTranslationHandler: {
-                provide: MissingTranslationHandler,
-                useClass: IgoMissingTranslationHandler
-            }
-        }), TranslateModule] });
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoLanguageModule, [{
-        type: NgModule,
-        args: [{
-                imports: [
-                    TranslateModule.forRoot({
-                        missingTranslationHandler: {
-                            provide: MissingTranslationHandler,
-                            useClass: IgoMissingTranslationHandler
-                        }
-                    })
-                ],
-                declarations: [],
-                exports: [TranslateModule]
-            }]
-    }], null, null); })();
-(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(IgoLanguageModule, { imports: [i1.TranslateModule], exports: [TranslateModule] }); })();
+class IgoLanguageModule {
+    static forRoot() {
+        return {
+            ngModule: IgoLanguageModule,
+            providers: [provideDefaultLanguageLoader()]
+        };
+    }
+    static ɵfac = function IgoLanguageModule_Factory(t) { return new (t || IgoLanguageModule)(); };
+    static ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoLanguageModule });
+    static ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [TranslateModule.forRoot({
+                missingTranslationHandler: {
+                    provide: MissingTranslationHandler,
+                    useClass: IgoMissingTranslationHandler
+                }
+            }), TranslateModule] });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoLanguageModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    TranslateModule.forRoot({
+                        missingTranslationHandler: {
+                            provide: MissingTranslationHandler,
+                            useClass: IgoMissingTranslationHandler
+                        }
+                    })
+                ],
+                declarations: [],
+                exports: [TranslateModule]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(IgoLanguageModule, { imports: [i1$1.TranslateModule], exports: [TranslateModule] }); })();
 
-class IgoMessageModule {
-    static forRoot() {
-        return {
-            ngModule: IgoMessageModule,
-            providers: []
-        };
-    }
-}
-IgoMessageModule.ɵfac = function IgoMessageModule_Factory(t) { return new (t || IgoMessageModule)(); };
-IgoMessageModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoMessageModule });
-IgoMessageModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [CommonModule,
-        ToastrModule.forRoot({
-            positionClass: 'toast-bottom-right',
-            timeOut: 10000,
-            extendedTimeOut: 10000,
-            messageClass: 'toast-message mat-typography',
-            closeButton: true,
-            progressBar: true,
-            enableHtml: true,
-            tapToDismiss: true,
-            maxOpened: 4,
-            preventDuplicates: true,
-            resetTimeoutOnDuplicate: true,
-            countDuplicates: false,
-            includeTitleDuplicates: true
-        })] });
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoMessageModule, [{
-        type: NgModule,
-        args: [{
-                imports: [CommonModule,
-                    ToastrModule.forRoot({
-                        positionClass: 'toast-bottom-right',
-                        timeOut: 10000,
-                        extendedTimeOut: 10000,
-                        messageClass: 'toast-message mat-typography',
-                        closeButton: true,
-                        progressBar: true,
-                        enableHtml: true,
-                        tapToDismiss: true,
-                        maxOpened: 4,
-                        preventDuplicates: true,
-                        resetTimeoutOnDuplicate: true,
-                        countDuplicates: false,
-                        includeTitleDuplicates: true
-                    })],
-                declarations: [],
-                exports: []
-            }]
-    }], null, null); })();
-(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(IgoMessageModule, { imports: [CommonModule, i1$1.ToastrModule] }); })();
+class IgoMessageModule {
+    static forRoot() {
+        return {
+            ngModule: IgoMessageModule,
+            providers: []
+        };
+    }
+    static ɵfac = function IgoMessageModule_Factory(t) { return new (t || IgoMessageModule)(); };
+    static ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoMessageModule });
+    static ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [CommonModule,
+            ToastrModule.forRoot({
+                positionClass: 'toast-bottom-right',
+                timeOut: 10000,
+                extendedTimeOut: 10000,
+                titleClass: 'mat-subtitle-2',
+                messageClass: 'toast-message',
+                closeButton: true,
+                progressBar: true,
+                enableHtml: true,
+                tapToDismiss: true,
+                maxOpened: 4,
+                preventDuplicates: true,
+                resetTimeoutOnDuplicate: true,
+                countDuplicates: false,
+                includeTitleDuplicates: true
+            })] });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoMessageModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    CommonModule,
+                    ToastrModule.forRoot({
+                        positionClass: 'toast-bottom-right',
+                        timeOut: 10000,
+                        extendedTimeOut: 10000,
+                        titleClass: 'mat-subtitle-2',
+                        messageClass: 'toast-message',
+                        closeButton: true,
+                        progressBar: true,
+                        enableHtml: true,
+                        tapToDismiss: true,
+                        maxOpened: 4,
+                        preventDuplicates: true,
+                        resetTimeoutOnDuplicate: true,
+                        countDuplicates: false,
+                        includeTitleDuplicates: true
+                    })
+                ],
+                declarations: [],
+                exports: []
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(IgoMessageModule, { imports: [CommonModule, i1$2.ToastrModule] }); })();
 
-var MessageType;
-(function (MessageType) {
-    MessageType["ERROR"] = "error";
-    MessageType["ALERT"] = "warning";
-    MessageType["WARNING"] = "warning";
-    MessageType["INFO"] = "info";
-    MessageType["SUCCESS"] = "success";
-    MessageType["SHOW"] = "show";
+var MessageType;
+(function (MessageType) {
+    MessageType["ERROR"] = "error";
+    MessageType["ALERT"] = "warning";
+    MessageType["WARNING"] = "warning";
+    MessageType["INFO"] = "info";
+    MessageType["SUCCESS"] = "success";
+    MessageType["SHOW"] = "show";
 })(MessageType || (MessageType = {}));
 
-class LanguageService {
-    constructor(translate) {
-        this.translate = translate;
-        this.language = this.translate.getBrowserLang();
-        this.language$ = new BehaviorSubject(undefined);
-        const lang = this.getLanguage();
-        this.translate.setDefaultLang(lang);
-        this.language$.next(lang);
-    }
-    getLanguage() {
-        return this.language.match(/en|fr/) ? this.language : 'en';
-    }
-    setLanguage(language) {
-        this.language = language.match(/en|fr/) ? language : 'en';
-        combineLatest([this.translate.use(this.language), this.translate.reloadLang(this.language)]).subscribe(() => {
-            this.language$.next(this.language);
-        });
-    }
-}
-LanguageService.ɵfac = function LanguageService_Factory(t) { return new (t || LanguageService)(i0.ɵɵinject(i1.TranslateService)); };
-LanguageService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: LanguageService, factory: LanguageService.ɵfac, providedIn: 'root' });
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LanguageService, [{
-        type: Injectable,
-        args: [{
-                providedIn: 'root'
-            }]
-    }], function () { return [{ type: i1.TranslateService }]; }, null); })();
+class LanguageService {
+    translate;
+    language;
+    language$ = new BehaviorSubject(undefined);
+    constructor(translate) {
+        this.translate = translate;
+        this.language = this.translate.getBrowserLang();
+        const lang = this.getLanguage();
+        this.translate.setDefaultLang(lang);
+        this.language$.next(lang);
+    }
+    getLanguage() {
+        return this.language.match(/en|fr/) ? this.language : 'en';
+    }
+    setLanguage(language) {
+        this.language = language.match(/en|fr/) ? language : 'en';
+        combineLatest([
+            this.translate.use(this.language),
+            this.translate.reloadLang(this.language)
+        ]).subscribe(() => {
+            this.language$.next(this.language);
+        });
+    }
+    static ɵfac = function LanguageService_Factory(t) { return new (t || LanguageService)(i0.ɵɵinject(i1$1.TranslateService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: LanguageService, factory: LanguageService.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LanguageService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1$1.TranslateService }]; }, null); })();
 
-class MessageService {
-    constructor(injector, configService, languageService) {
-        this.injector = injector;
-        this.configService = configService;
-        this.languageService = languageService;
-        this.messages$ = new BehaviorSubject([]);
-        this.activeMessageTranslations = [];
-        this.options = this.configService.getConfig('message') || {};
-        this.languageService.language$.pipe(debounceTime(500)).subscribe(r => {
-            if (this.toastr.toasts.length === 0) {
-                this.activeMessageTranslations = [];
-            }
-            this.toastr.toasts.map(toast => {
-                const activeMessageTranslation = this.activeMessageTranslations.find(amt => amt.id === toast.toastId);
-                if (activeMessageTranslation) {
-                    const translatedTextInterpolateParams = { ...activeMessageTranslation.textInterpolateParams };
-                    const translatedTitleInterpolateParams = { ...activeMessageTranslation.titleInterpolateParams };
-                    if (activeMessageTranslation.textInterpolateParams) {
-                        Object.keys(activeMessageTranslation.textInterpolateParams).map(k => {
-                            if (k) {
-                                translatedTextInterpolateParams[k] =
-                                    this.languageService.translate.instant(activeMessageTranslation.textInterpolateParams[k]);
-                            }
-                        });
-                    }
-                    if (activeMessageTranslation.titleInterpolateParams) {
-                        Object.keys(activeMessageTranslation.titleInterpolateParams).map(k => {
-                            if (k) {
-                                translatedTitleInterpolateParams[k] =
-                                    this.languageService.translate.instant(activeMessageTranslation.titleInterpolateParams[k]);
-                            }
-                        });
-                    }
-                    forkJoin([
-                        this.languageService.translate.get(activeMessageTranslation.textKey, translatedTextInterpolateParams),
-                        this.languageService.translate.get(activeMessageTranslation.titleKey, translatedTitleInterpolateParams)
-                    ]).pipe(first()).subscribe((res) => {
-                        toast.toastRef.componentInstance.message = res[0];
-                        toast.toastRef.componentInstance.title = res[1];
-                    });
-                }
-            });
-        });
-    }
-    get toastr() {
-        return this.injector.get(ToastrService);
-    }
-    showError(httpError) {
-        httpError.error.caught = true;
-        return this.error(httpError.error.message, httpError.error.title);
-    }
-    message(message) {
-        const messageType = message.type;
-        this.toastr.toastrConfig.iconClasses[messageType] = `toast-${messageType}`;
-        this.messages$.next(this.messages$.value.concat([message]));
-        message.options = message.options || {};
-        const currentDate = new Date();
-        message.options.from = message.options.from ? message.options.from : new Date('1 jan 1900');
-        message.options.to = message.options.to ? message.options.to : new Date('1 jan 3000');
-        if (typeof message.options.from === 'string') {
-            message.options.from = new Date(Date.parse(message.options.from.replace(/-/g, ' ')));
-        }
-        if (typeof message.options.to === 'string') {
-            message.options.to = new Date(Date.parse(message.options.to.replace(/-/g, ' ')));
-        }
-        if (currentDate > message.options.from && currentDate < message.options.to) {
-            if (message.showIcon === false) {
-                this.toastr.toastrConfig.iconClasses[messageType] = `toast-${messageType} toast-no-icon`;
-            }
-            message = this.handleTemplate(message);
-            if (message.text) {
-                let messageShown;
-                switch (message.type) {
-                    case MessageType.SUCCESS:
-                        messageShown = this.success(message.text, message.title, message.options, message.textInterpolateParams, message.titleInterpolateParams);
-                        break;
-                    case MessageType.ERROR:
-                        messageShown = this.error(message.text, message.title, message.options, message.textInterpolateParams, message.titleInterpolateParams);
-                        break;
-                    case MessageType.INFO:
-                        messageShown = this.info(message.text, message.title, message.options, message.textInterpolateParams, message.titleInterpolateParams);
-                        break;
-                    case MessageType.SHOW:
-                        messageShown = this.show(message.text, message.title, message.options, message.textInterpolateParams, message.titleInterpolateParams);
-                        break;
-                    case MessageType.ALERT:
-                    case MessageType.WARNING:
-                        messageShown = this.alert(message.text, message.title, message.options, message.textInterpolateParams, message.titleInterpolateParams);
-                        break;
-                    default:
-                        messageShown = this.info(message.text, message.title, message.options, message.textInterpolateParams, message.titleInterpolateParams);
-                        break;
-                }
-                message.options.id = messageShown.toastId;
-            }
-        }
-    }
-    success(text, title = 'igo.core.message.success', options = {}, textInterpolateParams, titleInterpolateParams) {
-        return this.handleNgxToastr('success', text, title, options, textInterpolateParams, titleInterpolateParams);
-    }
-    error(text, title = 'igo.core.message.error', options = {}, textInterpolateParams, titleInterpolateParams) {
-        return this.handleNgxToastr('error', text, title, options, textInterpolateParams, titleInterpolateParams);
-    }
-    info(text, title = 'igo.core.message.info', options = {}, textInterpolateParams, titleInterpolateParams) {
-        return this.handleNgxToastr('info', text, title, options, textInterpolateParams, titleInterpolateParams);
-    }
-    alert(text, title = 'igo.core.message.alert', options = {}, textInterpolateParams, titleInterpolateParams) {
-        return this.handleNgxToastr('alert', text, title, options, textInterpolateParams, titleInterpolateParams);
-    }
-    show(text, title = 'igo.core.message.info', options = {}, textInterpolateParams, titleInterpolateParams) {
-        return this.handleNgxToastr('show', text, title, options, textInterpolateParams, titleInterpolateParams);
-    }
-    handleNgxToastr(type, text, title, options = {}, textInterpolateParams, titleInterpolateParams) {
-        const translatedTextInterpolateParams = { ...textInterpolateParams };
-        const translatedTitlenterpolateParams = { ...titleInterpolateParams };
-        if (textInterpolateParams) {
-            Object.keys(textInterpolateParams).map(k => {
-                if (textInterpolateParams[k]) {
-                    translatedTextInterpolateParams[k] =
-                        this.languageService.translate.instant(textInterpolateParams[k]);
-                }
-            });
-        }
-        if (titleInterpolateParams) {
-            Object.keys(titleInterpolateParams).map(k => {
-                if (k) {
-                    translatedTitlenterpolateParams[k] =
-                        this.languageService.translate.instant(titleInterpolateParams[k]);
-                }
-            });
-        }
-        const message = this.languageService.translate.instant(text, translatedTextInterpolateParams);
-        const translatedTitle = this.languageService.translate.instant(title, translatedTitlenterpolateParams);
-        let activeToast;
-        switch (type) {
-            case 'success':
-                activeToast = this.toastr.success(message, translatedTitle, options);
-                break;
-            case 'error':
-                activeToast = this.toastr.error(message, translatedTitle, options);
-                break;
-            case 'show':
-            case 'info':
-                activeToast = this.toastr.info(message, translatedTitle, options);
-                break;
-            case 'alert':
-                activeToast = this.toastr.warning(message, translatedTitle, options);
-                break;
-        }
-        this.activeMessageTranslations.push({
-            id: activeToast.toastId,
-            titleKey: title,
-            textKey: text,
-            textInterpolateParams,
-            titleInterpolateParams
-        });
-        return activeToast;
-    }
-    remove(id) {
-        this.toastr.remove(id);
-    }
-    removeAllAreNotError() {
-        for (const mess of this.messages$.value) {
-            if (mess.type !== MessageType.ERROR) {
-                this.remove(mess.options.id);
-            }
-        }
-    }
-    handleTemplate(message) {
-        if (!this.options.template || message.html) {
-            return message;
-        }
-        let html = this.options.template;
-        html = html.replace('${text}', message.text);
-        html = html.replace('${title}', message.title);
-        message.html = undefined;
-        message.text = html;
-        message.title = undefined;
-        return message;
-    }
-}
-MessageService.ɵfac = function MessageService_Factory(t) { return new (t || MessageService)(i0.ɵɵinject(Injector), i0.ɵɵinject(ConfigService), i0.ɵɵinject(LanguageService)); };
-MessageService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: MessageService, factory: MessageService.ɵfac, providedIn: 'root' });
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MessageService, [{
-        type: Injectable,
-        args: [{
-                providedIn: 'root'
-            }]
-    }], function () { return [{ type: i0.Injector, decorators: [{
-                type: Inject,
-                args: [Injector]
+class MessageService {
+    injector;
+    configService;
+    languageService;
+    messages$ = new BehaviorSubject([]);
+    options;
+    activeMessageTranslations = [];
+    constructor(injector, configService, languageService) {
+        this.injector = injector;
+        this.configService = configService;
+        this.languageService = languageService;
+        this.options = this.configService.getConfig('message');
+        this.languageService.language$.pipe(debounceTime(500)).subscribe((r) => {
+            if (this.toastr.toasts.length === 0) {
+                this.activeMessageTranslations = [];
+            }
+            this.toastr.toasts.map((toast) => {
+                const activeMessageTranslation = this.activeMessageTranslations.find((amt) => amt.id === toast.toastId);
+                if (activeMessageTranslation) {
+                    const translatedTextInterpolateParams = {
+                        ...activeMessageTranslation.textInterpolateParams
+                    };
+                    const translatedTitleInterpolateParams = {
+                        ...activeMessageTranslation.titleInterpolateParams
+                    };
+                    if (activeMessageTranslation.textInterpolateParams) {
+                        Object.keys(activeMessageTranslation.textInterpolateParams).map((k) => {
+                            if (k) {
+                                translatedTextInterpolateParams[k] =
+                                    this.languageService.translate.instant(activeMessageTranslation.textInterpolateParams[k]);
+                            }
+                        });
+                    }
+                    if (activeMessageTranslation.titleInterpolateParams) {
+                        Object.keys(activeMessageTranslation.titleInterpolateParams).map((k) => {
+                            if (k) {
+                                translatedTitleInterpolateParams[k] =
+                                    this.languageService.translate.instant(activeMessageTranslation.titleInterpolateParams[k]);
+                            }
+                        });
+                    }
+                    forkJoin([
+                        this.languageService.translate.get(activeMessageTranslation.textKey, translatedTextInterpolateParams),
+                        this.languageService.translate.get(activeMessageTranslation.titleKey, translatedTitleInterpolateParams)
+                    ])
+                        .pipe(first())
+                        .subscribe((res) => {
+                        toast.toastRef.componentInstance.message = res[0];
+                        toast.toastRef.componentInstance.title = res[1];
+                    });
+                }
+            });
+        });
+    }
+    get toastr() {
+        return this.injector.get(ToastrService);
+    }
+    showError(httpError) {
+        httpError.error.caught = true;
+        return this.error(httpError.error.message, httpError.error.title);
+    }
+    message(message) {
+        const messageType = message.type;
+        this.toastr.toastrConfig.iconClasses[messageType] = `toast-${messageType}`;
+        this.messages$.next(this.messages$.value.concat([message]));
+        message.options = message.options || {};
+        const currentDate = new Date();
+        message.options.from = message.options.from
+            ? message.options.from
+            : new Date('1 jan 1900');
+        message.options.to = message.options.to
+            ? message.options.to
+            : new Date('1 jan 3000');
+        if (typeof message.options.from === 'string') {
+            message.options.from = new Date(Date.parse(message.options.from.replace(/-/g, ' ')));
+        }
+        if (typeof message.options.to === 'string') {
+            message.options.to = new Date(Date.parse(message.options.to.replace(/-/g, ' ')));
+        }
+        if (currentDate > message.options.from &&
+            currentDate < message.options.to) {
+            if (message.showIcon === false) {
+                this.toastr.toastrConfig.iconClasses[messageType] = `toast-${messageType} toast-no-icon`;
+            }
+            message = this.handleTemplate(message);
+            if (message.text) {
+                let messageShown;
+                switch (message.type) {
+                    case MessageType.SUCCESS:
+                        messageShown = this.success(message.text, message.title, message.options, message.textInterpolateParams, message.titleInterpolateParams);
+                        break;
+                    case MessageType.ERROR:
+                        messageShown = this.error(message.text, message.title, message.options, message.textInterpolateParams, message.titleInterpolateParams);
+                        break;
+                    case MessageType.INFO:
+                        messageShown = this.info(message.text, message.title, message.options, message.textInterpolateParams, message.titleInterpolateParams);
+                        break;
+                    case MessageType.SHOW:
+                        messageShown = this.show(message.text, message.title, message.options, message.textInterpolateParams, message.titleInterpolateParams);
+                        break;
+                    case MessageType.ALERT:
+                    case MessageType.WARNING:
+                        messageShown = this.alert(message.text, message.title, message.options, message.textInterpolateParams, message.titleInterpolateParams);
+                        break;
+                    default:
+                        messageShown = this.info(message.text, message.title, message.options, message.textInterpolateParams, message.titleInterpolateParams);
+                        break;
+                }
+                message.options.id = messageShown.toastId;
+            }
+        }
+    }
+    success(text, title = 'igo.core.message.success', options = {}, textInterpolateParams, titleInterpolateParams) {
+        return this.handleNgxToastr('success', text, title, options, textInterpolateParams, titleInterpolateParams);
+    }
+    error(text, title = 'igo.core.message.error', options = {}, textInterpolateParams, titleInterpolateParams) {
+        return this.handleNgxToastr('error', text, title, options, textInterpolateParams, titleInterpolateParams);
+    }
+    info(text, title = 'igo.core.message.info', options = {}, textInterpolateParams, titleInterpolateParams) {
+        return this.handleNgxToastr('info', text, title, options, textInterpolateParams, titleInterpolateParams);
+    }
+    alert(text, title = 'igo.core.message.alert', options = {}, textInterpolateParams, titleInterpolateParams) {
+        return this.handleNgxToastr('alert', text, title, options, textInterpolateParams, titleInterpolateParams);
+    }
+    show(text, title = 'igo.core.message.info', options = {}, textInterpolateParams, titleInterpolateParams) {
+        return this.handleNgxToastr('show', text, title, options, textInterpolateParams, titleInterpolateParams);
+    }
+    handleNgxToastr(type, text, title, options = {}, textInterpolateParams, titleInterpolateParams) {
+        const translatedTextInterpolateParams = { ...textInterpolateParams };
+        const translatedTitlenterpolateParams = { ...titleInterpolateParams };
+        if (textInterpolateParams) {
+            Object.keys(textInterpolateParams).map((k) => {
+                if (textInterpolateParams[k]) {
+                    translatedTextInterpolateParams[k] =
+                        this.languageService.translate.instant(textInterpolateParams[k]);
+                }
+            });
+        }
+        if (titleInterpolateParams) {
+            Object.keys(titleInterpolateParams).map((k) => {
+                if (k) {
+                    translatedTitlenterpolateParams[k] =
+                        this.languageService.translate.instant(titleInterpolateParams[k]);
+                }
+            });
+        }
+        const message = this.languageService.translate.instant(text, translatedTextInterpolateParams);
+        const translatedTitle = this.languageService.translate.instant(title, translatedTitlenterpolateParams);
+        let activeToast;
+        switch (type) {
+            case 'success':
+                activeToast = this.toastr.success(message, translatedTitle, options);
+                break;
+            case 'error':
+                activeToast = this.toastr.error(message, translatedTitle, options);
+                break;
+            case 'show':
+            case 'info':
+                activeToast = this.toastr.info(message, translatedTitle, options);
+                break;
+            case 'alert':
+                activeToast = this.toastr.warning(message, translatedTitle, options);
+                break;
+        }
+        this.activeMessageTranslations.push({
+            id: activeToast.toastId,
+            titleKey: title,
+            textKey: text,
+            textInterpolateParams,
+            titleInterpolateParams
+        });
+        return activeToast;
+    }
+    remove(id) {
+        this.toastr.remove(id);
+    }
+    removeAllAreNotError() {
+        for (const mess of this.messages$.value) {
+            if (mess.type !== MessageType.ERROR) {
+                this.remove(mess.options.id);
+            }
+        }
+    }
+    handleTemplate(message) {
+        if (!this.options?.template || message.html) {
+            return message;
+        }
+        let html = this.options?.template;
+        html = html.replace('${text}', message.text);
+        html = html.replace('${title}', message.title);
+        message.html = undefined;
+        message.text = html;
+        message.title = undefined;
+        return message;
+    }
+    static ɵfac = function MessageService_Factory(t) { return new (t || MessageService)(i0.ɵɵinject(Injector), i0.ɵɵinject(ConfigService), i0.ɵɵinject(LanguageService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: MessageService, factory: MessageService.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MessageService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i0.Injector, decorators: [{
+                type: Inject,
+                args: [Injector]
             }] }, { type: ConfigService }, { type: LanguageService }]; }, null); })();
 
-class ErrorInterceptor {
-    constructor(injector) {
-        this.injector = injector;
-    }
-    intercept(originalReq, next) {
-        const interceptError = originalReq.headers.get('interceptError');
-        const req = originalReq.clone({
-            headers: originalReq.headers.delete('interceptError')
-        });
-        if (interceptError === 'false') {
-            return next.handle(req);
-        }
-        const errorContainer = { httpError: undefined };
-        return next.handle(req).pipe(catchError(error => this.handleError(error, errorContainer)), finalize(() => {
-            this.handleCaughtError(errorContainer);
-            this.handleUncaughtError(errorContainer);
-        }));
-    }
-    handleError(httpError, errorContainer) {
-        if (httpError instanceof HttpErrorResponse) {
-            const errorObj = httpError.error === 'object' ? httpError.error : {};
-            errorObj.message = httpError.error?.message || httpError.statusText;
-            errorObj.caught = false;
-            httpError = new HttpErrorResponse({
-                error: errorObj,
-                headers: httpError.headers,
-                status: httpError.status,
-                statusText: httpError.statusText,
-                url: httpError.url
-            });
-        }
-        errorContainer.httpError = httpError;
-        return throwError(httpError);
-    }
-    handleCaughtError(errorContainer) {
-        const httpError = errorContainer.httpError;
-        if (httpError && httpError.error.toDisplay) {
-            httpError.error.caught = true;
-            const messageService = this.injector.get(MessageService);
-            messageService.error(httpError.error.message, httpError.error.title);
-        }
-    }
-    handleUncaughtError(errorContainer) {
-        const httpError = errorContainer.httpError;
-        if (httpError && !httpError.error.caught) {
-            const messageService = this.injector.get(MessageService);
-            httpError.error.caught = true;
-            messageService.error('igo.core.errors.uncaught.message', 'igo.core.errors.uncaught.title');
-        }
-    }
-}
-ErrorInterceptor.ɵfac = function ErrorInterceptor_Factory(t) { return new (t || ErrorInterceptor)(i0.ɵɵinject(i0.Injector)); };
-ErrorInterceptor.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ErrorInterceptor, factory: ErrorInterceptor.ɵfac, providedIn: 'root' });
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ErrorInterceptor, [{
-        type: Injectable,
-        args: [{
-                providedIn: 'root'
-            }]
+class ErrorInterceptor {
+    injector;
+    constructor(injector) {
+        this.injector = injector;
+    }
+    intercept(originalReq, next) {
+        const interceptError = originalReq.headers.get('interceptError');
+        const req = originalReq.clone({
+            headers: originalReq.headers.delete('interceptError')
+        });
+        if (interceptError === 'false') {
+            return next.handle(req);
+        }
+        const errorContainer = { httpError: undefined };
+        return next.handle(req).pipe(catchError((error) => this.handleError(error, errorContainer)), finalize(() => {
+            this.handleCaughtError(errorContainer);
+            this.handleUncaughtError(errorContainer);
+        }));
+    }
+    handleError(httpError, errorContainer) {
+        if (httpError instanceof HttpErrorResponse) {
+            const errorObj = httpError.error === 'object' ? httpError.error : {};
+            errorObj.message = httpError.error?.message || httpError.statusText;
+            errorObj.caught = false;
+            httpError = new HttpErrorResponse({
+                error: errorObj,
+                headers: httpError.headers,
+                status: httpError.status,
+                statusText: httpError.statusText,
+                url: httpError.url
+            });
+        }
+        errorContainer.httpError = httpError;
+        return throwError(httpError);
+    }
+    handleCaughtError(errorContainer) {
+        const httpError = errorContainer.httpError;
+        if (httpError && httpError.error.toDisplay) {
+            httpError.error.caught = true;
+            const messageService = this.injector.get(MessageService);
+            messageService.error(httpError.error.message, httpError.error.title);
+        }
+    }
+    handleUncaughtError(errorContainer) {
+        const httpError = errorContainer.httpError;
+        if (httpError && !httpError.error.caught) {
+            const messageService = this.injector.get(MessageService);
+            httpError.error.caught = true;
+            messageService.error('igo.core.errors.uncaught.message', 'igo.core.errors.uncaught.title');
+        }
+    }
+    static ɵfac = function ErrorInterceptor_Factory(t) { return new (t || ErrorInterceptor)(i0.ɵɵinject(i0.Injector)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ErrorInterceptor, factory: ErrorInterceptor.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ErrorInterceptor, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
     }], function () { return [{ type: i0.Injector }]; }, null); })();
 
-class IgoErrorModule {
-    constructor(parentModule) {
-        if (parentModule) {
-            throw new Error('IgoErrorModule is already loaded. Import it in the AppModule only');
-        }
-    }
-    static forRoot() {
-        return {
-            ngModule: IgoErrorModule,
-            providers: [
-                {
-                    provide: HTTP_INTERCEPTORS,
-                    useClass: ErrorInterceptor,
-                    multi: true
-                }
-            ]
-        };
-    }
-}
-IgoErrorModule.ɵfac = function IgoErrorModule_Factory(t) { return new (t || IgoErrorModule)(i0.ɵɵinject(IgoErrorModule, 12)); };
-IgoErrorModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoErrorModule });
-IgoErrorModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({});
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoErrorModule, [{
-        type: NgModule,
-        args: [{
-                imports: [],
-                declarations: [],
-                exports: []
-            }]
-    }], function () { return [{ type: IgoErrorModule, decorators: [{
-                type: Optional
-            }, {
-                type: SkipSelf
+class IgoErrorModule {
+    static forRoot() {
+        return {
+            ngModule: IgoErrorModule,
+            providers: [
+                {
+                    provide: HTTP_INTERCEPTORS,
+                    useClass: ErrorInterceptor,
+                    multi: true
+                }
+            ]
+        };
+    }
+    constructor(parentModule) {
+        if (parentModule) {
+            throw new Error('IgoErrorModule is already loaded. Import it in the AppModule only');
+        }
+    }
+    static ɵfac = function IgoErrorModule_Factory(t) { return new (t || IgoErrorModule)(i0.ɵɵinject(IgoErrorModule, 12)); };
+    static ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoErrorModule });
+    static ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({});
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoErrorModule, [{
+        type: NgModule,
+        args: [{
+                imports: [],
+                declarations: [],
+                exports: []
+            }]
+    }], function () { return [{ type: IgoErrorModule, decorators: [{
+                type: Optional
+            }, {
+                type: SkipSelf
             }] }]; }, null); })();
 
-const dbConfig = {
-    name: 'igo2DB',
-    version: 2,
-    objectStoresMeta: [{
-            store: 'geoData',
-            storeConfig: { keyPath: 'url', autoIncrement: false },
-            storeSchema: [
-                { name: 'regionID', keypath: 'regionID', options: { unique: false } }
-            ]
-        },
-        {
-            store: 'layerData',
-            storeConfig: { keyPath: 'layerId', autoIncrement: false },
-            storeSchema: [
-                { name: 'layerOptions', keypath: 'layerOptions', options: { unique: false } },
-                { name: 'sourceOptions', keypath: 'sourceOptions', options: { unique: false } }
-            ]
-        }]
-};
-class IgoCoreModule {
-    constructor(matIconRegistry, domSanitizer) {
-        matIconRegistry.addSvgIconSet(domSanitizer.bypassSecurityTrustResourceUrl('./assets/igo2/core/icons/mdi.svg'));
-    }
-    static forRoot() {
-        return {
-            ngModule: IgoCoreModule,
-            providers: []
-        };
-    }
-}
-IgoCoreModule.ɵfac = function IgoCoreModule_Factory(t) { return new (t || IgoCoreModule)(i0.ɵɵinject(i1$2.MatIconRegistry), i0.ɵɵinject(i2.DomSanitizer)); };
-IgoCoreModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoCoreModule });
-IgoCoreModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [CommonModule,
-        HttpClientModule,
-        IgoActivityModule.forRoot(),
-        IgoConfigModule.forRoot(),
-        IgoErrorModule.forRoot(),
-        IgoLanguageModule.forRoot(),
-        IgoMessageModule.forRoot(),
-        NgxIndexedDBModule.forRoot(dbConfig), IgoActivityModule,
-        IgoConfigModule,
-        IgoErrorModule,
-        IgoLanguageModule,
-        IgoMessageModule] });
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoCoreModule, [{
-        type: NgModule,
-        args: [{
-                imports: [
-                    CommonModule,
-                    HttpClientModule,
-                    IgoActivityModule.forRoot(),
-                    IgoConfigModule.forRoot(),
-                    IgoErrorModule.forRoot(),
-                    IgoLanguageModule.forRoot(),
-                    IgoMessageModule.forRoot(),
-                    NgxIndexedDBModule.forRoot(dbConfig)
-                ],
-                declarations: [],
-                exports: [
-                    IgoActivityModule,
-                    IgoConfigModule,
-                    IgoErrorModule,
-                    IgoLanguageModule,
-                    IgoMessageModule
-                ]
-            }]
-    }], function () { return [{ type: i1$2.MatIconRegistry }, { type: i2.DomSanitizer }]; }, null); })();
-(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(IgoCoreModule, { imports: [CommonModule,
-        HttpClientModule, IgoActivityModule, IgoConfigModule, IgoErrorModule, IgoLanguageModule, IgoMessageModule, i8.NgxIndexedDBModule], exports: [IgoActivityModule,
-        IgoConfigModule,
-        IgoErrorModule,
-        IgoLanguageModule,
+const dbConfig = {
+    name: 'igo2DB',
+    version: 2,
+    objectStoresMeta: [
+        {
+            store: 'geoData',
+            storeConfig: { keyPath: 'url', autoIncrement: false },
+            storeSchema: [
+                { name: 'regionID', keypath: 'regionID', options: { unique: false } }
+            ]
+        },
+        {
+            store: 'layerData',
+            storeConfig: { keyPath: 'layerId', autoIncrement: false },
+            storeSchema: [
+                {
+                    name: 'layerOptions',
+                    keypath: 'layerOptions',
+                    options: { unique: false }
+                },
+                {
+                    name: 'sourceOptions',
+                    keypath: 'sourceOptions',
+                    options: { unique: false }
+                }
+            ]
+        }
+    ]
+};
+class IgoCoreModule {
+    static forRoot() {
+        return {
+            ngModule: IgoCoreModule,
+            providers: []
+        };
+    }
+    constructor(matIconRegistry, domSanitizer) {
+        matIconRegistry.addSvgIconSet(domSanitizer.bypassSecurityTrustResourceUrl('./assets/igo2/core/icons/mdi.svg'));
+    }
+    static ɵfac = function IgoCoreModule_Factory(t) { return new (t || IgoCoreModule)(i0.ɵɵinject(i1$3.MatIconRegistry), i0.ɵɵinject(i2.DomSanitizer)); };
+    static ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoCoreModule });
+    static ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [CommonModule,
+            HttpClientModule,
+            IgoActivityModule.forRoot(),
+            IgoConfigModule.forRoot(),
+            IgoErrorModule.forRoot(),
+            IgoLanguageModule.forRoot(),
+            IgoMessageModule.forRoot(),
+            NgxIndexedDBModule.forRoot(dbConfig), IgoActivityModule,
+            IgoConfigModule,
+            IgoErrorModule,
+            IgoLanguageModule,
+            IgoMessageModule] });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoCoreModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    CommonModule,
+                    HttpClientModule,
+                    IgoActivityModule.forRoot(),
+                    IgoConfigModule.forRoot(),
+                    IgoErrorModule.forRoot(),
+                    IgoLanguageModule.forRoot(),
+                    IgoMessageModule.forRoot(),
+                    NgxIndexedDBModule.forRoot(dbConfig)
+                ],
+                declarations: [],
+                exports: [
+                    IgoActivityModule,
+                    IgoConfigModule,
+                    IgoErrorModule,
+                    IgoLanguageModule,
+                    IgoMessageModule
+                ]
+            }]
+    }], function () { return [{ type: i1$3.MatIconRegistry }, { type: i2.DomSanitizer }]; }, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(IgoCoreModule, { imports: [CommonModule,
+        HttpClientModule, IgoActivityModule, IgoConfigModule, IgoErrorModule, IgoLanguageModule, IgoMessageModule, i8.NgxIndexedDBModule], exports: [IgoActivityModule,
+        IgoConfigModule,
+        IgoErrorModule,
+        IgoLanguageModule,
         IgoMessageModule] }); })();
 
-class IgoGestureConfig extends HammerGestureConfig {
-    buildHammer(element) {
-        const mc = super.buildHammer(element);
-        mc.set({ touchAction: 'pan-y' });
-        return mc;
-    }
-}
-IgoGestureConfig.ɵfac = /*@__PURE__*/ function () { let ɵIgoGestureConfig_BaseFactory; return function IgoGestureConfig_Factory(t) { return (ɵIgoGestureConfig_BaseFactory || (ɵIgoGestureConfig_BaseFactory = i0.ɵɵgetInheritedFactory(IgoGestureConfig)))(t || IgoGestureConfig); }; }();
-IgoGestureConfig.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: IgoGestureConfig, factory: IgoGestureConfig.ɵfac });
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoGestureConfig, [{
-        type: Injectable
+class IgoGestureConfig extends HammerGestureConfig {
+    buildHammer(element) {
+        const mc = super.buildHammer(element);
+        mc.set({ touchAction: 'pan-y' });
+        return mc;
+    }
+    static ɵfac = /*@__PURE__*/ function () { let ɵIgoGestureConfig_BaseFactory; return function IgoGestureConfig_Factory(t) { return (ɵIgoGestureConfig_BaseFactory || (ɵIgoGestureConfig_BaseFactory = i0.ɵɵgetInheritedFactory(IgoGestureConfig)))(t || IgoGestureConfig); }; }();
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: IgoGestureConfig, factory: IgoGestureConfig.ɵfac });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoGestureConfig, [{
+        type: Injectable
     }], null, null); })();
 
-class IgoGestureModule {
-    static forRoot() {
-        return {
-            ngModule: IgoGestureModule,
-            providers: [
-                {
-                    provide: HAMMER_GESTURE_CONFIG,
-                    useClass: IgoGestureConfig
-                }
-            ]
-        };
-    }
-}
-IgoGestureModule.ɵfac = function IgoGestureModule_Factory(t) { return new (t || IgoGestureModule)(); };
-IgoGestureModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoGestureModule });
-IgoGestureModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [HammerModule] });
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoGestureModule, [{
-        type: NgModule,
-        args: [{
-                imports: [HammerModule],
-                declarations: [],
-                exports: []
-            }]
-    }], null, null); })();
+class IgoGestureModule {
+    static forRoot() {
+        return {
+            ngModule: IgoGestureModule,
+            providers: [
+                {
+                    provide: HAMMER_GESTURE_CONFIG,
+                    useClass: IgoGestureConfig
+                }
+            ]
+        };
+    }
+    static ɵfac = function IgoGestureModule_Factory(t) { return new (t || IgoGestureModule)(); };
+    static ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoGestureModule });
+    static ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [HammerModule] });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoGestureModule, [{
+        type: NgModule,
+        args: [{
+                imports: [HammerModule],
+                declarations: [],
+                exports: []
+            }]
+    }], null, null); })();
 (function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(IgoGestureModule, { imports: [HammerModule] }); })();
 
-class LoggingInterceptor {
-    intercept(req, next) {
-        const started = Date.now();
-        let ok;
-        // extend server response observable with logging
-        return next.handle(req).pipe(tap(
-        // Succeeds when there is a response; ignore other events
-        event => (ok = event instanceof HttpResponse ? 'succeeded' : ''), 
-        // Operation failed; error is an HttpErrorResponse
-        error => (ok = 'failed')), 
-        // Log when response observable either completes or errors
-        finalize(() => {
-            const elapsed = Date.now() - started;
+class LoggingInterceptor {
+    intercept(req, next) {
+        const started = Date.now();
+        let ok;
+        // extend server response observable with logging
+        return next.handle(req).pipe(tap(
+        // Succeeds when there is a response; ignore other events
+        (event) => (ok = event instanceof HttpResponse ? 'succeeded' : ''), 
+        // Operation failed; error is an HttpErrorResponse
+        (error) => (ok = 'failed')), 
+        // Log when response observable either completes or errors
+        finalize(() => {
+            const elapsed = Date.now() - started;
             const msg = `${req.method} "${req.urlWithParams}"
-             ${ok} in ${elapsed} ms.`;
-            console.log(msg);
-        }));
-    }
-}
-LoggingInterceptor.ɵfac = function LoggingInterceptor_Factory(t) { return new (t || LoggingInterceptor)(); };
-LoggingInterceptor.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: LoggingInterceptor, factory: LoggingInterceptor.ɵfac });
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LoggingInterceptor, [{
-        type: Injectable
+             ${ok} in ${elapsed} ms.`;
+            console.log(msg);
+        }));
+    }
+    static ɵfac = function LoggingInterceptor_Factory(t) { return new (t || LoggingInterceptor)(); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: LoggingInterceptor, factory: LoggingInterceptor.ɵfac });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LoggingInterceptor, [{
+        type: Injectable
     }], null, null); })();
 
-class IgoLoggingModule {
-    static forRoot() {
-        return {
-            ngModule: IgoLoggingModule,
-            providers: [
-                {
-                    provide: HTTP_INTERCEPTORS,
-                    useClass: LoggingInterceptor,
-                    multi: true
-                }
-            ]
-        };
-    }
-}
-IgoLoggingModule.ɵfac = function IgoLoggingModule_Factory(t) { return new (t || IgoLoggingModule)(); };
-IgoLoggingModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoLoggingModule });
-IgoLoggingModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({});
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoLoggingModule, [{
-        type: NgModule,
-        args: [{
-                imports: [],
-                declarations: [],
-                exports: []
-            }]
+class IgoLoggingModule {
+    static forRoot() {
+        return {
+            ngModule: IgoLoggingModule,
+            providers: [
+                {
+                    provide: HTTP_INTERCEPTORS,
+                    useClass: LoggingInterceptor,
+                    multi: true
+                }
+            ]
+        };
+    }
+    static ɵfac = function IgoLoggingModule_Factory(t) { return new (t || IgoLoggingModule)(); };
+    static ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoLoggingModule });
+    static ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({});
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoLoggingModule, [{
+        type: NgModule,
+        args: [{
+                imports: [],
+                declarations: [],
+                exports: []
+            }]
     }], null, null); })();
 
-let ROUTE_SERVICE_OPTIONS = new InjectionToken('routeServiceOptions');
-function provideRouteServiceOptions(options) {
-    return {
-        provide: ROUTE_SERVICE_OPTIONS,
-        useValue: options
-    };
-}
-class RouteService {
-    constructor(router, route, options) {
-        this.router = router;
-        this.route = route;
-        const defaultOptions = {
-            centerKey: 'center',
-            zoomKey: 'zoom',
-            projectionKey: 'projection',
-            contextKey: 'context',
-            searchKey: 'search',
-            visibleOnLayersKey: 'visiblelayers',
-            visibleOffLayersKey: 'invisiblelayers',
-            directionsCoordKey: 'routing',
-            directionsOptionsKey: 'routingOptions',
-            toolKey: 'tool',
-            wmsUrlKey: 'wmsUrl',
-            wmsLayersKey: 'wmsLayers',
-            wmtsUrlKey: 'wmtsUrl',
-            wmtsLayersKey: 'wmtsLayers',
-            arcgisUrlKey: 'arcgisUrl',
-            arcgisLayersKey: 'arcgisLayers',
-            iarcgisUrlKey: 'iarcgisUrl',
-            iarcgisLayersKey: 'iarcgisLayers',
-            tarcgisUrlKey: 'tarcgisUrl',
-            tarcgisLayersKey: 'tarcgisLayers',
-            vectorKey: 'vector'
-        };
-        this.options = Object.assign({}, defaultOptions, options);
-    }
-    get queryParams() {
-        let url = decodeURIComponent(location.search);
-        if (url.includes('¢er=')) {
-            url = url.replace('¢er', '&center');
-            const queryParams = url
-                .slice(1)
-                .split('&')
-                .map(p => p.split('='))
-                .reduce((obj, pair) => {
-                const [key, value] = pair.map(decodeURIComponent);
-                obj[key] = value;
-                return obj;
-            }, {});
-            this.router.navigate([], { queryParams });
-        }
-        return this.route.queryParams;
-    }
-}
-RouteService.ɵfac = function RouteService_Factory(t) { return new (t || RouteService)(i0.ɵɵinject(i1$3.Router), i0.ɵɵinject(i1$3.ActivatedRoute), i0.ɵɵinject(ROUTE_SERVICE_OPTIONS, 8)); };
-RouteService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: RouteService, factory: RouteService.ɵfac, providedIn: 'root' });
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(RouteService, [{
-        type: Injectable,
-        args: [{
-                providedIn: 'root'
-            }]
-    }], function () { return [{ type: i1$3.Router }, { type: i1$3.ActivatedRoute }, { type: undefined, decorators: [{
-                type: Inject,
-                args: [ROUTE_SERVICE_OPTIONS]
-            }, {
-                type: Optional
+let ROUTE_SERVICE_OPTIONS = new InjectionToken('routeServiceOptions');
+function provideRouteServiceOptions(options) {
+    return {
+        provide: ROUTE_SERVICE_OPTIONS,
+        useValue: options
+    };
+}
+class RouteService {
+    router;
+    route;
+    options;
+    constructor(router, route, options) {
+        this.router = router;
+        this.route = route;
+        const defaultOptions = {
+            centerKey: 'center',
+            zoomKey: 'zoom',
+            projectionKey: 'projection',
+            contextKey: 'context',
+            searchKey: 'search',
+            visibleOnLayersKey: 'visiblelayers',
+            visibleOffLayersKey: 'invisiblelayers',
+            directionsCoordKey: 'routing',
+            directionsOptionsKey: 'routingOptions',
+            toolKey: 'tool',
+            wmsUrlKey: 'wmsUrl',
+            wmsLayersKey: 'wmsLayers',
+            wmtsUrlKey: 'wmtsUrl',
+            wmtsLayersKey: 'wmtsLayers',
+            arcgisUrlKey: 'arcgisUrl',
+            arcgisLayersKey: 'arcgisLayers',
+            iarcgisUrlKey: 'iarcgisUrl',
+            iarcgisLayersKey: 'iarcgisLayers',
+            tarcgisUrlKey: 'tarcgisUrl',
+            tarcgisLayersKey: 'tarcgisLayers',
+            vectorKey: 'vector'
+        };
+        this.options = Object.assign({}, defaultOptions, options);
+    }
+    get queryParams() {
+        let url = decodeURIComponent(location.search);
+        if (url.includes('¢er=')) {
+            url = url.replace('¢er', '&center');
+            const queryParams = url
+                .slice(1)
+                .split('&')
+                .map((p) => p.split('='))
+                .reduce((obj, pair) => {
+                const [key, value] = pair.map(decodeURIComponent);
+                obj[key] = value;
+                return obj;
+            }, {});
+            this.router.navigate([], { queryParams });
+        }
+        return this.route.queryParams;
+    }
+    static ɵfac = function RouteService_Factory(t) { return new (t || RouteService)(i0.ɵɵinject(i1$4.Router), i0.ɵɵinject(i1$4.ActivatedRoute), i0.ɵɵinject(ROUTE_SERVICE_OPTIONS, 8)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: RouteService, factory: RouteService.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(RouteService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1$4.Router }, { type: i1$4.ActivatedRoute }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [ROUTE_SERVICE_OPTIONS]
+            }, {
+                type: Optional
             }] }]; }, null); })();
 
-class AnalyticsService {
-    constructor(config) {
-        this.config = config;
-        this.options = this.config.getConfig('analytics') || {};
-        if (this.options.provider === 'matomo') {
-            this.initMatomo();
-        }
-    }
-    get paq() {
-        return (window._paq = window._paq || []);
-    }
-    initMatomo() {
-        if (!this.options.url || !this.options.id) {
-            return;
-        }
-        const url = this.options.url.substr(-1) === '/'
-            ? this.options.url + 'matomo'
-            : this.options.url;
-        // this.paq.push(['trackPageView']);
-        // this.paq.push(['enableLinkTracking']);
-        (() => {
-            this.paq.push(['setTrackerUrl', url + '.php']);
-            this.paq.push(['setSiteId', this.options.id]);
-            const g = document.createElement('script');
-            const s = document.getElementsByTagName('script')[0];
-            g.type = 'text/javascript';
-            g.async = true;
-            g.defer = true;
-            g.src = url + '.js';
-            s.parentNode.insertBefore(g, s);
-        })();
-    }
-    setUser(user, profils) {
-        if (this.options.provider === 'matomo') {
-            if (!user) {
-                this.paq.push(['resetUserId']);
-                this.paq.push(['deleteCustomVariable', 1, 'user']);
-                this.paq.push(['deleteCustomVariable', 2, 'name']);
-                this.paq.push(['deleteCustomVariable', 3, 'profils']);
-            }
-            else {
-                this.paq.push(['setUserId', user.id]);
-                const name = `${user.firstName} ${user.lastName}`;
-                this.paq.push(['setCustomVariable', 1, 'user', user.sourceId, 'visit']);
-                this.paq.push(['setCustomVariable', 2, 'name', name, 'visit']);
-                this.paq.push(['setCustomVariable', 3, 'profils', profils, 'visit']);
-            }
-            this.paq.push(['trackPageView']);
-            this.paq.push(['enableLinkTracking']);
-        }
-    }
-    trackSearch(term, nbResults) {
-        if (this.options.provider === 'matomo') {
-            this.paq.push(['trackSiteSearch', term, false, nbResults]);
-        }
-    }
-    trackEvent(category, action, name) {
-        if (this.options.provider === 'matomo') {
-            this.paq.push(['trackEvent', category, action, name]);
-        }
-    }
-    /**
-     * Function that tracks layers added to the map
-     */
-    trackLayer(category, action, parameters) {
-        if (this.options.provider === 'matomo')
-            this.paq.push(['trackEvent', category, action, parameters]);
-    }
-}
-AnalyticsService.ɵfac = function AnalyticsService_Factory(t) { return new (t || AnalyticsService)(i0.ɵɵinject(ConfigService)); };
-AnalyticsService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: AnalyticsService, factory: AnalyticsService.ɵfac, providedIn: 'root' });
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AnalyticsService, [{
-        type: Injectable,
-        args: [{
-                providedIn: 'root'
-            }]
+class AnalyticsService {
+    config;
+    options;
+    get paq() {
+        return (window._paq = window._paq || []);
+    }
+    constructor(config) {
+        this.config = config;
+        this.options = this.config.getConfig('analytics') || {};
+        if (this.options.provider === 'matomo') {
+            this.initMatomo();
+        }
+    }
+    initMatomo() {
+        if (!this.options.url || !this.options.id) {
+            return;
+        }
+        const url = this.options.url.substr(-1) === '/'
+            ? this.options.url + 'matomo'
+            : this.options.url;
+        // this.paq.push(['trackPageView']);
+        // this.paq.push(['enableLinkTracking']);
+        (() => {
+            this.paq.push(['setTrackerUrl', url + '.php']);
+            this.paq.push(['setSiteId', this.options.id]);
+            const g = document.createElement('script');
+            const s = document.getElementsByTagName('script')[0];
+            g.type = 'text/javascript';
+            g.async = true;
+            g.defer = true;
+            g.src = url + '.js';
+            s.parentNode.insertBefore(g, s);
+        })();
+    }
+    setUser(user, profils) {
+        if (this.options.provider === 'matomo') {
+            if (!user) {
+                this.paq.push(['resetUserId']);
+                this.paq.push(['deleteCustomVariable', 1, 'user']);
+                this.paq.push(['deleteCustomVariable', 2, 'name']);
+                this.paq.push(['deleteCustomVariable', 3, 'profils']);
+            }
+            else {
+                this.paq.push(['setUserId', user.id]);
+                const name = `${user.firstName} ${user.lastName}`;
+                this.paq.push(['setCustomVariable', 1, 'user', user.sourceId, 'visit']);
+                this.paq.push(['setCustomVariable', 2, 'name', name, 'visit']);
+                this.paq.push(['setCustomVariable', 3, 'profils', profils, 'visit']);
+            }
+            this.paq.push(['trackPageView']);
+            this.paq.push(['enableLinkTracking']);
+        }
+    }
+    trackSearch(term, nbResults) {
+        if (this.options.provider === 'matomo') {
+            this.paq.push(['trackSiteSearch', term, false, nbResults]);
+        }
+    }
+    trackEvent(category, action, name) {
+        if (this.options.provider === 'matomo') {
+            this.paq.push(['trackEvent', category, action, name]);
+        }
+    }
+    /**
+     * Function that tracks layers added to the map
+     */
+    trackLayer(category, action, parameters) {
+        if (this.options.provider === 'matomo')
+            this.paq.push(['trackEvent', category, action, parameters]);
+    }
+    static ɵfac = function AnalyticsService_Factory(t) { return new (t || AnalyticsService)(i0.ɵɵinject(ConfigService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: AnalyticsService, factory: AnalyticsService.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AnalyticsService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
     }], function () { return [{ type: ConfigService }]; }, null); })();
 
-var Media;
-(function (Media) {
-    Media["Mobile"] = "mobile";
-    Media["Tablet"] = "tablet";
-    Media["Desktop"] = "desktop";
-})(Media || (Media = {}));
-var MediaOrientation;
-(function (MediaOrientation) {
-    MediaOrientation["Portrait"] = "portrait";
-    MediaOrientation["Landscape"] = "landscape";
+var Media;
+(function (Media) {
+    Media["Mobile"] = "mobile";
+    Media["Tablet"] = "tablet";
+    Media["Desktop"] = "desktop";
+})(Media || (Media = {}));
+var MediaOrientation;
+(function (MediaOrientation) {
+    MediaOrientation["Portrait"] = "portrait";
+    MediaOrientation["Landscape"] = "landscape";
 })(MediaOrientation || (MediaOrientation = {}));
 
-class MediaService {
-    constructor(breakpointObserver) {
-        this.media$ = new BehaviorSubject(undefined);
-        this.orientation$ = new BehaviorSubject(undefined);
-        breakpointObserver
-            .observe([Breakpoints.HandsetLandscape])
-            .subscribe(res => {
-            if (res.matches) {
-                this.media$.next(Media.Mobile);
-                this.orientation$.next(MediaOrientation.Landscape);
-            }
-        });
-        breakpointObserver.observe([Breakpoints.HandsetPortrait]).subscribe(res => {
-            if (res.matches) {
-                this.media$.next(Media.Mobile);
-                this.orientation$.next(MediaOrientation.Portrait);
-            }
-        });
-        breakpointObserver.observe([Breakpoints.TabletLandscape]).subscribe(res => {
-            if (res.matches) {
-                this.media$.next(Media.Tablet);
-                this.orientation$.next(MediaOrientation.Landscape);
-            }
-        });
-        breakpointObserver.observe([Breakpoints.TabletPortrait]).subscribe(res => {
-            if (res.matches) {
-                this.media$.next(Media.Tablet);
-                this.orientation$.next(MediaOrientation.Portrait);
-            }
-        });
-        breakpointObserver.observe([Breakpoints.WebLandscape]).subscribe(res => {
-            if (res.matches) {
-                this.media$.next(Media.Desktop);
-                this.orientation$.next(MediaOrientation.Landscape);
-            }
-        });
-        breakpointObserver.observe([Breakpoints.WebPortrait]).subscribe(res => {
-            if (res.matches) {
-                this.media$.next(Media.Desktop);
-                this.orientation$.next(MediaOrientation.Portrait);
-            }
-        });
-    }
-    getMedia() {
-        return this.media$.value;
-    }
-    getOrientation() {
-        return this.orientation$.value;
-    }
-    isTouchScreen() {
-        return 'ontouchstart' in document.documentElement ? true : false;
-    }
-    isMobile() {
-        const media = this.getMedia();
-        return media === 'mobile';
-    }
-    isDesktop() {
-        const media = this.getMedia();
-        return media === 'desktop';
-    }
-}
-MediaService.ɵfac = function MediaService_Factory(t) { return new (t || MediaService)(i0.ɵɵinject(i1$4.BreakpointObserver)); };
-MediaService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: MediaService, factory: MediaService.ɵfac, providedIn: 'root' });
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MediaService, [{
-        type: Injectable,
-        args: [{
-                providedIn: 'root'
-            }]
-    }], function () { return [{ type: i1$4.BreakpointObserver }]; }, null); })();
+class MediaService {
+    media$ = new BehaviorSubject(undefined);
+    orientation$ = new BehaviorSubject(undefined);
+    constructor(breakpointObserver) {
+        breakpointObserver
+            .observe([Breakpoints.HandsetLandscape])
+            .subscribe((res) => {
+            if (res.matches) {
+                this.media$.next(Media.Mobile);
+                this.orientation$.next(MediaOrientation.Landscape);
+            }
+        });
+        breakpointObserver
+            .observe([Breakpoints.HandsetPortrait])
+            .subscribe((res) => {
+            if (res.matches) {
+                this.media$.next(Media.Mobile);
+                this.orientation$.next(MediaOrientation.Portrait);
+            }
+        });
+        breakpointObserver
+            .observe([Breakpoints.TabletLandscape])
+            .subscribe((res) => {
+            if (res.matches) {
+                this.media$.next(Media.Tablet);
+                this.orientation$.next(MediaOrientation.Landscape);
+            }
+        });
+        breakpointObserver
+            .observe([Breakpoints.TabletPortrait])
+            .subscribe((res) => {
+            if (res.matches) {
+                this.media$.next(Media.Tablet);
+                this.orientation$.next(MediaOrientation.Portrait);
+            }
+        });
+        breakpointObserver.observe([Breakpoints.WebLandscape]).subscribe((res) => {
+            if (res.matches) {
+                this.media$.next(Media.Desktop);
+                this.orientation$.next(MediaOrientation.Landscape);
+            }
+        });
+        breakpointObserver.observe([Breakpoints.WebPortrait]).subscribe((res) => {
+            if (res.matches) {
+                this.media$.next(Media.Desktop);
+                this.orientation$.next(MediaOrientation.Portrait);
+            }
+        });
+    }
+    getMedia() {
+        return this.media$.value;
+    }
+    getOrientation() {
+        return this.orientation$.value;
+    }
+    isTouchScreen() {
+        return 'ontouchstart' in document.documentElement ? true : false;
+    }
+    isMobile() {
+        const media = this.getMedia();
+        return media === 'mobile';
+    }
+    isDesktop() {
+        const media = this.getMedia();
+        return media === 'desktop';
+    }
+    static ɵfac = function MediaService_Factory(t) { return new (t || MediaService)(i0.ɵɵinject(i1$5.BreakpointObserver)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: MediaService, factory: MediaService.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MediaService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1$5.BreakpointObserver }]; }, null); })();
 
-var StorageScope;
-(function (StorageScope) {
-    StorageScope["SESSION"] = "Session";
-    StorageScope["LOCAL"] = "Local";
-})(StorageScope || (StorageScope = {}));
-var StorageServiceEventEnum;
-(function (StorageServiceEventEnum) {
-    StorageServiceEventEnum["ADDED"] = "Added";
-    StorageServiceEventEnum["MODIFIED"] = "Modified";
-    StorageServiceEventEnum["REMOVED"] = "Removed";
-    StorageServiceEventEnum["CLEARED"] = "Cleared";
+var StorageScope;
+(function (StorageScope) {
+    StorageScope["SESSION"] = "Session";
+    StorageScope["LOCAL"] = "Local";
+})(StorageScope || (StorageScope = {}));
+var StorageServiceEventEnum;
+(function (StorageServiceEventEnum) {
+    StorageServiceEventEnum["ADDED"] = "Added";
+    StorageServiceEventEnum["MODIFIED"] = "Modified";
+    StorageServiceEventEnum["REMOVED"] = "Removed";
+    StorageServiceEventEnum["CLEARED"] = "Cleared";
 })(StorageServiceEventEnum || (StorageServiceEventEnum = {}));
 
-class StorageService {
-    constructor(config) {
-        this.config = config;
-        this.storageChange$ = new BehaviorSubject(undefined);
-        this.options = this.config.getConfig('storage') || { key: 'igo' };
-    }
-    /**
-     * Use to get the data found in storage file
-     */
-    get(key, scope) {
-        let value;
-        if (!scope || scope === StorageScope.SESSION) {
-            value = sessionStorage.getItem(`${this.options.key}.${key}`);
-        }
-        if (scope === StorageScope.LOCAL || (!value && !scope)) {
-            value = localStorage.getItem(`${this.options.key}.${key}`);
-        }
-        if (value) {
-            try {
-                value = JSON.parse(value);
-            }
-            catch {
-                value = value;
-            }
-        }
-        return value;
-    }
-    set(key, value, scope = StorageScope.LOCAL) {
-        const previousValue = this.get(key, scope);
-        if (scope === StorageScope.SESSION) {
-            sessionStorage.setItem(`${this.options.key}.${key}`, JSON.stringify(value));
-        }
-        else {
-            localStorage.setItem(`${this.options.key}.${key}`, JSON.stringify(value));
-        }
-        const currentValue = this.get(key, scope);
-        if (currentValue !== previousValue) {
-            this.storageChange$.next({
-                key, scope,
-                event: previousValue !== undefined ? StorageServiceEventEnum.MODIFIED : StorageServiceEventEnum.ADDED,
-                previousValue,
-                currentValue
-            });
-        }
-    }
-    remove(key, scope = StorageScope.LOCAL) {
-        const previousValue = this.get(key, scope);
-        if (scope === StorageScope.SESSION) {
-            sessionStorage.removeItem(`${this.options.key}.${key}`);
-        }
-        else {
-            localStorage.removeItem(`${this.options.key}.${key}`);
-        }
-        this.storageChange$.next({ key, scope, event: StorageServiceEventEnum.REMOVED, previousValue });
-    }
-    clear(scope = StorageScope.LOCAL) {
-        if (scope === StorageScope.SESSION) {
-            sessionStorage.clear();
-        }
-        else {
-            localStorage.clear();
-        }
-        this.storageChange$.next({ scope, event: StorageServiceEventEnum.CLEARED });
-    }
-}
-StorageService.ɵfac = function StorageService_Factory(t) { return new (t || StorageService)(i0.ɵɵinject(ConfigService)); };
-StorageService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: StorageService, factory: StorageService.ɵfac, providedIn: 'root' });
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(StorageService, [{
-        type: Injectable,
-        args: [{
-                providedIn: 'root'
-            }]
+class BaseStorage {
+    options;
+    storageChange$ = new BehaviorSubject(undefined);
+    constructor(config) {
+        this.options = config.getConfig('storage') || { key: 'igo' };
+    }
+    /**
+     * Use to get the data found in storage file
+     */
+    get(key, scope) {
+        let value;
+        if (!scope || scope === StorageScope.SESSION) {
+            value = sessionStorage.getItem(`${this.options.key}.${key}`);
+        }
+        if (scope === StorageScope.LOCAL || (!value && !scope)) {
+            value = localStorage.getItem(`${this.options.key}.${key}`);
+        }
+        if (value) {
+            try {
+                value = JSON.parse(value);
+            }
+            catch {
+                value = value;
+            }
+        }
+        return value;
+    }
+    set(key, value, scope = StorageScope.LOCAL) {
+        const previousValue = this.get(key, scope);
+        if (scope === StorageScope.SESSION) {
+            sessionStorage.setItem(`${this.options.key}.${key}`, JSON.stringify(value));
+        }
+        else {
+            localStorage.setItem(`${this.options.key}.${key}`, JSON.stringify(value));
+        }
+        const currentValue = this.get(key, scope);
+        if (currentValue !== previousValue) {
+            this.storageChange$.next({
+                key,
+                scope,
+                event: previousValue !== undefined
+                    ? StorageServiceEventEnum.MODIFIED
+                    : StorageServiceEventEnum.ADDED,
+                previousValue,
+                currentValue
+            });
+        }
+    }
+    remove(key, scope = StorageScope.LOCAL) {
+        const previousValue = this.get(key, scope);
+        if (scope === StorageScope.SESSION) {
+            sessionStorage.removeItem(`${this.options.key}.${key}`);
+        }
+        else {
+            localStorage.removeItem(`${this.options.key}.${key}`);
+        }
+        this.storageChange$.next({
+            key,
+            scope,
+            event: StorageServiceEventEnum.REMOVED,
+            previousValue
+        });
+    }
+    clear(scope = StorageScope.LOCAL) {
+        if (scope === StorageScope.SESSION) {
+            sessionStorage.clear();
+        }
+        else {
+            localStorage.clear();
+        }
+        this.storageChange$.next({ scope, event: StorageServiceEventEnum.CLEARED });
+    }
+}
+
+class StorageService extends BaseStorage {
+    config;
+    constructor(config) {
+        super(config);
+        this.config = config;
+    }
+    static ɵfac = function StorageService_Factory(t) { return new (t || StorageService)(i0.ɵɵinject(ConfigService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: StorageService, factory: StorageService.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(StorageService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
     }], function () { return [{ type: ConfigService }]; }, null); })();
 
-function getNumber(v, endposition, length) {
-    /* tslint:disable:no-bitwise*/
-    const mask = ((1 << length) - 1);
-    return (v >> endposition) & mask;
-    /* tslint:enable:no-bitwise*/
-}
-class CompressionService {
-    constructor() {
-        this.base64Index = new Map();
-        this.indexBase64 = new Map();
-        this.generateBase64Index();
-    }
-    generateBase64Index() {
-        // https://fr.wikipedia.org/wiki/Base64
-        // A-Z => [0, 25]
-        for (let i = 0; i < 26; i++) {
-            this.base64Index.set(String.fromCharCode('A'.charCodeAt(0) + i), i);
-            this.indexBase64.set(i, String.fromCharCode('A'.charCodeAt(0) + i));
-        }
-        // a-z => [26, 51]
-        for (let i = 0; i < 26; i++) {
-            this.base64Index.set(String.fromCharCode('a'.charCodeAt(0) + i), i + 26);
-            this.indexBase64.set(i + 26, String.fromCharCode('a'.charCodeAt(0) + i));
-        }
-        // 0-9 => [52, 61]
-        for (let i = 0; i < 10; i++) {
-            this.base64Index.set(String.fromCharCode('0'.charCodeAt(0) + i), i + 52);
-            this.indexBase64.set(i + 52, String.fromCharCode('0'.charCodeAt(0) + i));
-        }
-        // + / => [62, 63]
-        this.base64Index.set('+', 62);
-        this.base64Index.set('/', 63);
-        this.indexBase64.set(62, '+');
-        this.indexBase64.set(63, '/');
-    }
-    compressBlob(blob) {
-        if (!blob) {
-            return;
-        }
-        const observable = new Observable((observer) => {
-            const reader = new FileReader();
-            reader.readAsDataURL(blob);
-            reader.onload = () => {
-                const base64 = reader.result.valueOf();
-                const text64 = base64.substr(base64.indexOf(',') + 1);
-                const compressed = this.compressStringBase64(text64);
-                const compressedData = { length: text64.length,
-                    type: blob.type,
-                    object: compressed };
-                observer.next(compressedData);
-            };
-        });
-        return observable;
-    }
-    decompressBlob(compressedData) {
-        /* tslint:disable:no-bitwise*/
-        const object = compressedData.object;
-        const length = compressedData.length;
-        const decompressed = this.decompressStringBase64(object, length);
-        const byteCharacters = atob(decompressed);
-        const byteNumbers = new Array(byteCharacters.length);
-        for (let i = 0; i < byteCharacters.length; i++) {
-            byteNumbers[i] = byteCharacters.charCodeAt(i);
-        }
-        const byteArray = new Uint8Array(byteNumbers);
-        const blob = new Blob([byteArray], { type: compressedData.type });
-        /* tslint:enable:no-bitwise*/
-        return blob;
-    }
-    compressStringBase64(s) {
-        /* tslint:disable:no-bitwise*/
-        let out = '';
-        let bits = 16;
-        let chr = 0;
-        let rem = 0;
-        for (const c of s) {
-            const value = this.base64Index.get(c);
-            if (bits > 6) {
-                bits -= 6;
-                chr += value << bits;
-            }
-            else {
-                rem = 6 - bits;
-                chr += value >> rem;
-                out += String.fromCharCode(chr);
-                chr = (value) << (16 - rem);
-                bits = 16 - rem;
-            }
-        }
-        if (s.length % 8 !== 0) {
-            out += String.fromCharCode(chr);
-        }
-        /* tslint:enable:no-bitwise*/
-        return String.fromCharCode(9731) + out;
-    }
-    decompressStringBase64(c, length) {
-        /* tslint:disable:no-bitwise*/
-        if (!c) {
-            return;
-        }
-        if (c.charCodeAt(0) !== 9731) {
-            return c;
-        }
-        let chr = 0;
-        let rem = 0;
-        let bits = 16;
-        let out = '';
-        let j = 1;
-        let value = c.charCodeAt(j);
-        for (let i = 0; i < length; i++) {
-            if (bits > 6) {
-                bits -= 6;
-                chr = getNumber(value, bits, 6);
-                out += this.indexBase64.get(chr);
-            }
-            else {
-                rem = 6 - bits;
-                chr = getNumber(value, 0, bits) << rem;
-                value = c.charCodeAt(++j);
-                chr += getNumber(value, 16 - rem, rem);
-                out += this.indexBase64.get(chr);
-                bits = 16 - rem;
-            }
-        }
-        return out;
-        /* tslint:enable:no-bitwise*/
-    }
-}
-CompressionService.ɵfac = function CompressionService_Factory(t) { return new (t || CompressionService)(); };
-CompressionService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: CompressionService, factory: CompressionService.ɵfac, providedIn: 'root' });
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CompressionService, [{
-        type: Injectable,
-        args: [{
-                providedIn: 'root'
-            }]
+function getNumber(v, endposition, length) {
+    /* tslint:disable:no-bitwise*/
+    const mask = (1 << length) - 1;
+    return (v >> endposition) & mask;
+    /* tslint:enable:no-bitwise*/
+}
+class CompressionService {
+    base64Index = new Map();
+    indexBase64 = new Map();
+    constructor() {
+        this.generateBase64Index();
+    }
+    generateBase64Index() {
+        // https://fr.wikipedia.org/wiki/Base64
+        // A-Z => [0, 25]
+        for (let i = 0; i < 26; i++) {
+            this.base64Index.set(String.fromCharCode('A'.charCodeAt(0) + i), i);
+            this.indexBase64.set(i, String.fromCharCode('A'.charCodeAt(0) + i));
+        }
+        // a-z => [26, 51]
+        for (let i = 0; i < 26; i++) {
+            this.base64Index.set(String.fromCharCode('a'.charCodeAt(0) + i), i + 26);
+            this.indexBase64.set(i + 26, String.fromCharCode('a'.charCodeAt(0) + i));
+        }
+        // 0-9 => [52, 61]
+        for (let i = 0; i < 10; i++) {
+            this.base64Index.set(String.fromCharCode('0'.charCodeAt(0) + i), i + 52);
+            this.indexBase64.set(i + 52, String.fromCharCode('0'.charCodeAt(0) + i));
+        }
+        // + / => [62, 63]
+        this.base64Index.set('+', 62);
+        this.base64Index.set('/', 63);
+        this.indexBase64.set(62, '+');
+        this.indexBase64.set(63, '/');
+    }
+    compressBlob(blob) {
+        if (!blob) {
+            return;
+        }
+        const observable = new Observable((observer) => {
+            const reader = new FileReader();
+            reader.readAsDataURL(blob);
+            reader.onload = () => {
+                const base64 = reader.result.valueOf();
+                const text64 = base64.substr(base64.indexOf(',') + 1);
+                const compressed = this.compressStringBase64(text64);
+                const compressedData = {
+                    length: text64.length,
+                    type: blob.type,
+                    object: compressed
+                };
+                observer.next(compressedData);
+            };
+        });
+        return observable;
+    }
+    decompressBlob(compressedData) {
+        /* tslint:disable:no-bitwise*/
+        const object = compressedData.object;
+        const length = compressedData.length;
+        const decompressed = this.decompressStringBase64(object, length);
+        const byteCharacters = atob(decompressed);
+        const byteNumbers = new Array(byteCharacters.length);
+        for (let i = 0; i < byteCharacters.length; i++) {
+            byteNumbers[i] = byteCharacters.charCodeAt(i);
+        }
+        const byteArray = new Uint8Array(byteNumbers);
+        const blob = new Blob([byteArray], { type: compressedData.type });
+        /* tslint:enable:no-bitwise*/
+        return blob;
+    }
+    compressStringBase64(s) {
+        /* tslint:disable:no-bitwise*/
+        let out = '';
+        let bits = 16;
+        let chr = 0;
+        let rem = 0;
+        for (const c of s) {
+            const value = this.base64Index.get(c);
+            if (bits > 6) {
+                bits -= 6;
+                chr += value << bits;
+            }
+            else {
+                rem = 6 - bits;
+                chr += value >> rem;
+                out += String.fromCharCode(chr);
+                chr = value << (16 - rem);
+                bits = 16 - rem;
+            }
+        }
+        if (s.length % 8 !== 0) {
+            out += String.fromCharCode(chr);
+        }
+        /* tslint:enable:no-bitwise*/
+        return String.fromCharCode(9731) + out;
+    }
+    decompressStringBase64(c, length) {
+        /* tslint:disable:no-bitwise*/
+        if (!c) {
+            return;
+        }
+        if (c.charCodeAt(0) !== 9731) {
+            return c;
+        }
+        let chr = 0;
+        let rem = 0;
+        let bits = 16;
+        let out = '';
+        let j = 1;
+        let value = c.charCodeAt(j);
+        for (let i = 0; i < length; i++) {
+            if (bits > 6) {
+                bits -= 6;
+                chr = getNumber(value, bits, 6);
+                out += this.indexBase64.get(chr);
+            }
+            else {
+                rem = 6 - bits;
+                chr = getNumber(value, 0, bits) << rem;
+                value = c.charCodeAt(++j);
+                chr += getNumber(value, 16 - rem, rem);
+                out += this.indexBase64.get(chr);
+                bits = 16 - rem;
+            }
+        }
+        return out;
+        /* tslint:enable:no-bitwise*/
+    }
+    static ɵfac = function CompressionService_Factory(t) { return new (t || CompressionService)(); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: CompressionService, factory: CompressionService.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CompressionService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
     }], function () { return []; }, null); })();
 
-class NetworkService {
-    constructor(messageService, injector) {
-        this.messageService = messageService;
-        this.injector = injector;
-        this.stateChangeEventEmitter = new EventEmitter();
-        this.state = {
-            connection: window.navigator.onLine
-        };
-        this.checkNetworkState();
-    }
-    checkNetworkState() {
-        this.onlineSubscription = fromEvent(window, 'online').subscribe(() => {
-            if (this.previousMessageId) {
-                this.messageService.remove(this.previousMessageId);
-            }
-            const messageObj = this.messageService.info('igo.core.network.online.message', 'igo.core.network.online.title');
-            this.previousMessageId = messageObj.toastId;
-            this.state.connection = true;
-            this.emitEvent();
-        });
-        this.offlineSubscription = fromEvent(window, 'offline').subscribe(() => {
-            if (this.previousMessageId) {
-                this.messageService.remove(this.previousMessageId);
-            }
-            const messageObj = this.messageService.info('igo.core.network.offline.message', 'igo.core.network.offline.title');
-            this.previousMessageId = messageObj.toastId;
-            this.state.connection = false;
-            this.emitEvent();
-        });
-    }
-    emitEvent() {
-        this.stateChangeEventEmitter.emit(this.state);
-    }
-    ngOnDestroy() {
-        try {
-            this.offlineSubscription.unsubscribe();
-            this.onlineSubscription.unsubscribe();
-        }
-        catch (e) { }
-    }
-    currentState(reportState = true) {
-        return reportState
-            ? this.stateChangeEventEmitter.pipe(debounceTime(300), startWith(this.state))
-            : this.stateChangeEventEmitter.pipe(debounceTime(300));
-    }
-}
-NetworkService.ɵfac = function NetworkService_Factory(t) { return new (t || NetworkService)(i0.ɵɵinject(MessageService), i0.ɵɵinject(i0.Injector)); };
-NetworkService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: NetworkService, factory: NetworkService.ɵfac, providedIn: 'root' });
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(NetworkService, [{
-        type: Injectable,
-        args: [{
-                providedIn: 'root'
-            }]
+class NetworkService {
+    messageService;
+    injector;
+    stateChangeEventEmitter = new EventEmitter();
+    onlineSubscription;
+    offlineSubscription;
+    previousMessageId;
+    state = {
+        connection: window.navigator.onLine
+    };
+    constructor(messageService, injector) {
+        this.messageService = messageService;
+        this.injector = injector;
+        this.checkNetworkState();
+    }
+    checkNetworkState() {
+        this.onlineSubscription = fromEvent(window, 'online').subscribe(() => {
+            if (this.previousMessageId) {
+                this.messageService.remove(this.previousMessageId);
+            }
+            const messageObj = this.messageService.info('igo.core.network.online.message', 'igo.core.network.online.title');
+            this.previousMessageId = messageObj.toastId;
+            this.state.connection = true;
+            this.emitEvent();
+        });
+        this.offlineSubscription = fromEvent(window, 'offline').subscribe(() => {
+            if (this.previousMessageId) {
+                this.messageService.remove(this.previousMessageId);
+            }
+            const messageObj = this.messageService.info('igo.core.network.offline.message', 'igo.core.network.offline.title');
+            this.previousMessageId = messageObj.toastId;
+            this.state.connection = false;
+            this.emitEvent();
+        });
+    }
+    emitEvent() {
+        this.stateChangeEventEmitter.emit(this.state);
+    }
+    ngOnDestroy() {
+        try {
+            this.offlineSubscription.unsubscribe();
+            this.onlineSubscription.unsubscribe();
+        }
+        catch (e) { }
+    }
+    currentState(reportState = true) {
+        return reportState
+            ? this.stateChangeEventEmitter.pipe(debounceTime(300), startWith(this.state))
+            : this.stateChangeEventEmitter.pipe(debounceTime(300));
+    }
+    static ɵfac = function NetworkService_Factory(t) { return new (t || NetworkService)(i0.ɵɵinject(MessageService), i0.ɵɵinject(i0.Injector)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: NetworkService, factory: NetworkService.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(NetworkService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
     }], function () { return [{ type: MessageService }, { type: i0.Injector }]; }, null); })();
 
-class RegexService {
-    constructor(config) {
-        this.config = config;
-        this.options = this.config.getConfig('regex');
-    }
-    getAll() {
-        return this.options;
-    }
-    get(key) {
-        if (this.options) {
-            return this.options[key];
-        }
-        return;
-    }
-}
-RegexService.ɵfac = function RegexService_Factory(t) { return new (t || RegexService)(i0.ɵɵinject(ConfigService)); };
-RegexService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: RegexService, factory: RegexService.ɵfac, providedIn: 'root' });
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(RegexService, [{
-        type: Injectable,
-        args: [{
-                providedIn: 'root'
-            }]
+class RegexService {
+    config;
+    options;
+    constructor(config) {
+        this.config = config;
+        this.options = this.config.getConfig('regex');
+    }
+    getAll() {
+        return this.options;
+    }
+    get(key) {
+        if (this.options) {
+            return this.options[key];
+        }
+        return;
+    }
+    static ɵfac = function RegexService_Factory(t) { return new (t || RegexService)(i0.ɵɵinject(ConfigService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: RegexService, factory: RegexService.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(RegexService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
     }], function () { return [{ type: ConfigService }]; }, null); })();
 
-/*
- * Public API Surface of core
+/*
+ * Public API Surface of core
  */
 
-/**
- * Generated bundle index. Do not edit.
+/**
+ * Generated bundle index. Do not edit.
  */
 
-export { ActivityInterceptor, ActivityService, AnalyticsService, CONFIG_OPTIONS, CompressionService, ConfigService, ErrorInterceptor, IgoActivityModule, IgoConfigModule, IgoCoreModule, IgoErrorModule, IgoGestureConfig, IgoGestureModule, IgoLanguageModule, IgoLoggingModule, IgoMessageModule, IgoMissingTranslationHandler, LanguageLoader, LanguageService, LoggingInterceptor, Media, MediaOrientation, MediaService, MessageService, MessageType, NetworkService, ROUTE_SERVICE_OPTIONS, RegexService, RouteService, StorageScope, StorageService, StorageServiceEventEnum, configFactory, defaultLanguageLoader, provideConfigLoader, provideConfigOptions, provideDefaultLanguageLoader, provideLanguageLoader, provideRouteServiceOptions, version };
+export { ActivityInterceptor, ActivityService, AnalyticsService, BaseStorage, CONFIG_OPTIONS, CompressionService, ConfigService, ErrorInterceptor, IgoActivityModule, IgoConfigModule, IgoCoreModule, IgoErrorModule, IgoGestureConfig, IgoGestureModule, IgoLanguageModule, IgoLoggingModule, IgoMessageModule, IgoMissingTranslationHandler, LanguageLoader, LanguageService, LoggingInterceptor, Media, MediaOrientation, MediaService, MessageService, MessageType, NetworkService, ROUTE_SERVICE_OPTIONS, RegexService, RouteService, StorageScope, StorageService, StorageServiceEventEnum, configFactory, defaultLanguageLoader, provideConfigLoader, provideConfigOptions, provideDefaultLanguageLoader, provideLanguageLoader, provideRouteServiceOptions, version };
 //# sourceMappingURL=igo2-core.mjs.map