@igo2/core 1.15.4 → 16.0.0-rc.1

package/fesm2015/igo2-core.mjs

@@ -1,1418 +0,0 @@
-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 { 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 { TranslateLoader, TranslateModule, MissingTranslationHandler } from '@ngx-translate/core';
-import * as i1$1 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 { 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'
-                }]
-        }], 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
-        }], 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: []
-                }]
-        }], null, null);
-})();
-
-const version = {
-    lib: '1.15.4',
-    releaseDate: 1688557109892
-};
-
-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);
-})();
-
-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: []
-                }]
-        }], 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), {});
-        }));
-    }
-}
-
-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]
-    };
-}
-
-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 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] }); })();
-
-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 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 = Object.assign({}, activeMessageTranslation.textInterpolateParams);
-                    const translatedTitleInterpolateParams = Object.assign({}, 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 = Object.assign({}, textInterpolateParams);
-        const translatedTitlenterpolateParams = Object.assign({}, 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]
-                    }] }, { 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) {
-        var _a;
-        if (httpError instanceof HttpErrorResponse) {
-            const errorObj = httpError.error === 'object' ? httpError.error : {};
-            errorObj.message = ((_a = httpError.error) === null || _a === void 0 ? void 0 : _a.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'
-                }]
-        }], 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
-                    }] }];
-    }, 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,
-            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
-        }], 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);
-})();
-(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;
-            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
-        }], 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: []
-                }]
-        }], 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
-                    }] }];
-    }, 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'
-                }]
-        }], 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";
-})(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);
-})();
-
-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 (_a) {
-                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'
-                }]
-        }], 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 () { 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'
-                }]
-        }], 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'
-                }]
-        }], function () { return [{ type: ConfigService }]; }, null);
-})();
-
-/*
- * Public API Surface of core
- */
-
-/**
- * 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 };
-//# sourceMappingURL=igo2-core.mjs.map